test.goasdfas

asdfasdf

import (
	"bufio"
	"context"
	"database/sql"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	_ "github.com/lib/pq"
)

type App struct {
	DB *sql.DB
}

func main() {
	a := App{}
	a.Initialize()
}

var projectName string

var err error

func (a *App) Initialize() {
	dsn := fmt.Sprintf("host=localhost port=5432 sslmode=disable user=postgres password=changeme dbname=words")

	a.DB, err = sql.Open("postgres", dsn)
	if err != nil {
		panic(err)
	}
	defer a.DB.Close()

	err = a.DB.Ping()
	if err != nil {
		log.Printf("Error connecting to db: %v\n", err)
	}

	a.initializeDB()

}

func (a *App) initializeDB() {

	var err error

	words := []string{"noun", "adjective"}

	ctx, cancelfunc := context.WithTimeout(context.Background(), 90*time.Second)
	defer cancelfunc()

	for _, word := range words {

		checkRow := fmt.Sprintf("SELECT COUNT (DISTINCT word) FROM %s WHERE word IS NOT NULL", word)

		table := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s ( id serial PRIMARY KEY, word text )", word)

		insertRow := fmt.Sprintf("INSERT INTO %s ( word ) VALUES ($1)", word)

		var fileLines []string

		var rowCount int

		file := "words/adjectives.text"

		_, err = a.DB.ExecContext(ctx, table)
		if err != nil {
			panic(err)
		}

		if strings.Compare(word, "noun") == 0 {
			file = "words/nouns.text"
		}

		numRows := a.DB.QueryRow(checkRow)
		err = numRows.Scan(&rowCount)
		if err != nil {
			log.Fatal(err)
		}

		// if table has more than 10000 values break has it already has all words
		if rowCount > 10000 {
			continue
		}

		readFile, err := os.Open(file)

		if err != nil {
			fmt.Println(err)
		}
		fileScanner := bufio.NewScanner(readFile)

		fileScanner.Split(bufio.ScanLines)

		for fileScanner.Scan() {
			fileLines = append(fileLines, fileScanner.Text())
		}

		readFile.Close()

		for _, line := range fileLines {
			_, err = a.DB.ExecContext(ctx, insertRow, line)
			if err != nil {
				panic(err)
			}

		}

		readFile.Close()

		defer a.DB.Close()
	}
}