package main

import (
	"bufio"
	"database/sql"
	"fmt"
	"html/template"
	"os"
	"strings"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/goccy/go-json"
)

func setupTables(db *sql.DB) error {
	_, err := db.Exec("create table IF NOT EXISTS words (word text not null, definition text);")
	if err != nil {
		return fmt.Errorf("creating table: %s", err)
	}

	// Faster import performance.
	_, err = db.Exec("PRAGMA synchronous = OFF;")
	if err != nil {
		return fmt.Errorf("setting risky writes: %s", err)
	}

	return nil
}

func isDatabaseEmpty(db *sql.DB) tea.Cmd {
	return func() tea.Msg {
		row := db.QueryRow(`SELECT count(*) as count from words`)
		var count int
		err := row.Scan(&count)
		if err != nil {
			return errMsg(fmt.Errorf("counting rows: %s", err))
		}

		// Only populate the database if it is empty.
		return isDBEmptyMsg(count == 0)
	}
}

type rawDictionaryEntry struct {
	Word      string   `json:"word"`
	LangCode  string   `json:"lang_code"`
	POS       string   `json:"pos_title"`
	Etymology []string `json:"etymology_texts"`
	Senses    []sense  `json:"senses"`
	Sounds    []sound  `json:"sounds"`
	Tags      []string `json:"tags"`
}

type sense struct {
	Glosses  []string  `json:"glosses"`
	Examples []example `json:"examples"`
}

type example struct {
	Text string `json:"text"`
}

type sound struct {
	IPA string `json:"ipa"`
}

type templateReadyDictionaryEntry struct {
	Word      string
	POS       string
	Etymology string
	Senses    []SenseForDictionaryEntry
	Sound     string
	Gender    string
}

type SenseForDictionaryEntry struct {
	Sense   string
	Example string
}

func populateDictionary(rawDictionary string, db *sql.DB) tea.Cmd {
	return func() tea.Msg {
		// Set up the template
		tmpl, err := template.New("entry").Parse(
			`<p>{{ .Word }} {{ .Sound }} <i>{{ .POS }} {{ .Gender }}</i></p>
<ol>{{ range .Senses}}
	<li class=sense>{{ .Sense }}<br>
	{{ if .Example }}<ul><li><i>{{ .Example }}</i></li></ul></li>{{ end }}
{{ end }}</ol>
{{ if .Etymology }}<p><i>Étymologie: {{ .Etymology }}</i>{{ end }}`)
		if err != nil {
			panic(err)
		}

		tx, err := db.Begin()
		if err != nil {
			return errMsg(fmt.Errorf("starting transaction: %w", err))
		}

		// Set up a prepared statement
		stmt, err := tx.Prepare("insert into words(word, definition) values(?, ?)")
		if err != nil {
			return errMsg(fmt.Errorf("preparing statement: %w", err))
		}
		defer stmt.Close()

		file, err := os.Open(rawDictionary)
		if err != nil {
			return errMsg(fmt.Errorf("opening: %w", err))
		}
		defer file.Close()

		var wordsAdded int
		scanner := bufio.NewScanner(file)

		maxCapacity := 2_000_000
		buf := make([]byte, maxCapacity)
		scanner.Buffer(buf, maxCapacity)

		for scanner.Scan() {
			var result rawDictionaryEntry
			json.Unmarshal([]byte(scanner.Text()), &result)
			if result.LangCode != "fr" {
				continue
			}

			// Clean up the word. Replace apostrophes (common in phrases) with
			// single quotes (more likely to be typed by a user).
			result.Word = strings.ReplaceAll(result.Word, `’`, `'`)

			// Create the definition text.
			entry := templateReadyDictionaryEntry{
				Word: result.Word,
				POS:  strings.ToLower(result.POS),
			}
			if len(result.Etymology) > 0 {
				entry.Etymology = result.Etymology[0]
			}
			if len(result.Sounds) > 0 {
				entry.Sound = result.Sounds[0].IPA
			}

			var genders, numbers []string
			for _, r := range result.Tags {
				switch r {
				case "masculine":
					genders = append(genders, "masculin")
				case "feminine":
					genders = append(genders, "féminin")
				case "plural":
					numbers = append(numbers, "pluriel")
				case "singular":
					numbers = append(numbers, "singulier")
				}
			}
			entry.Gender = strings.Join(
				[]string{
					strings.Join(genders, " / "),
					strings.Join(numbers, " et "),
				},
				" ",
			)

			for _, s := range result.Senses {
				var example string
				if len(s.Examples) > 0 {
					example = s.Examples[0].Text
				}
				sense := strings.Join(s.Glosses, "; ")
				entry.Senses = append(entry.Senses, SenseForDictionaryEntry{Sense: sense, Example: example})
			}

			formattedDefinition := strings.Builder{}
			err := tmpl.Execute(&formattedDefinition, entry)
			if err != nil {
				return errMsg(fmt.Errorf("failed to render: %w", err))
			}

			// Insert the entry
			_, err = stmt.Exec(entry.Word, formattedDefinition.String())
			if err != nil {
				return errMsg(fmt.Errorf("inserting '%s': %w", entry.Word, err))
			}

			wordsAdded++

		}
		if err := scanner.Err(); err != nil {
			return errMsg(fmt.Errorf("scanning: %w", err))
		}

		if err := tx.Commit(); err != nil {
			return errMsg(fmt.Errorf("committing: %w", err))
		}

		_, err = db.Exec("create index wordindex on words(word);")
		if err != nil {
			return errMsg(fmt.Errorf("creating index: %s", err))
		}

		return isDBEmptyMsg(false)
	}
}