package main

import (
	_ "embed"
	"encoding/csv"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"
	"time"

	"github.com/stevedylandev/andromeda/pkg/auth"
	"github.com/stevedylandev/andromeda/pkg/sqlite"
)

const classicListPath = "classic_authors.txt"

// embeddedClassicList is baked into the binary so the seed command works inside
// a container (or anywhere the txt file is absent) without needing the file on
// disk. An on-disk classic_authors.txt still takes precedence, so local edits
// apply without a rebuild.
//
//go:embed classic_authors.txt
var embeddedClassicList string

func parseClassicList(data string) []string {
	var out []string
	for _, line := range strings.Split(data, "\n") {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		out = append(out, line)
	}
	return out
}

// loadClassicList reads the match list from disk, falling back to the embedded
// copy when the file is absent. Skips blank lines and # comments.
func loadClassicList(path string) ([]string, bool, error) {
	data, err := os.ReadFile(path)
	if errors.Is(err, os.ErrNotExist) {
		return parseClassicList(embeddedClassicList), true, nil
	}
	if err != nil {
		return nil, false, err
	}
	return parseClassicList(string(data)), false, nil
}

// matchesClassic reports whether the author column contains any list entry as a
// case-sensitive substring.
func matchesClassic(author string, list []string) bool {
	for _, name := range list {
		if strings.Contains(author, name) {
			return true
		}
	}
	return false
}

// splitAttribution splits a CSV author field of the form "Author, Book Title"
// at the first comma into author and source. No comma -> empty source.
func splitAttribution(field string) (author, source string) {
	if i := strings.Index(field, ","); i >= 0 {
		return strings.TrimSpace(field[:i]), strings.TrimSpace(field[i+1:])
	}
	return strings.TrimSpace(field), ""
}

func listSource(embedded bool) string {
	if embedded {
		return "embedded"
	}
	return classicListPath
}

func dedupKey(text, author string) string {
	return text + "\x00" + author
}

// runSeed imports classic-literature quotes from csvPath into the database at
// dbPath. It is idempotent: quotes already present (matched on text+author) are
// skipped, so re-running after editing classic_authors.txt only adds new rows.
func runSeed(logger *slog.Logger, dbPath, csvPath string) error {
	list, embedded, err := loadClassicList(classicListPath)
	if err != nil {
		return fmt.Errorf("read %s: %w", classicListPath, err)
	}
	logger.Info("loaded classic list", "entries", len(list), "source", listSource(embedded))

	db, err := sqlite.Open(dbPath, quotesSchema)
	if err != nil {
		return err
	}
	defer db.Close()

	// Preload existing (text, author) pairs so re-seeds stay idempotent.
	seen := map[string]struct{}{}
	rows, err := db.Query(`SELECT text, author FROM quotes`)
	if err != nil {
		return err
	}
	for rows.Next() {
		var t, a string
		if err := rows.Scan(&t, &a); err != nil {
			rows.Close()
			return err
		}
		seen[dedupKey(t, a)] = struct{}{}
	}
	rows.Close()

	f, err := os.Open(csvPath)
	if err != nil {
		return err
	}
	defer f.Close()

	reader := csv.NewReader(f)
	reader.FieldsPerRecord = -1
	if _, err := reader.Read(); err != nil { // skip header
		return err
	}

	tx, err := db.Begin()
	if err != nil {
		return err
	}
	stmt, err := tx.Prepare(
		`INSERT INTO quotes (short_id, text, author, source, added_at, updated_at)
		 VALUES (?, ?, ?, ?, ?, ?)`,
	)
	if err != nil {
		tx.Rollback()
		return err
	}
	defer stmt.Close()

	now := time.Now().UTC().Unix()
	var scanned, inserted, skipped int
	for {
		rec, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			logger.Warn("skipping malformed row", "err", err)
			continue
		}
		if len(rec) < 2 {
			continue
		}
		scanned++
		text := strings.TrimSpace(rec[0])
		rawAuthor := rec[1]
		if text == "" || !matchesClassic(rawAuthor, list) {
			continue
		}
		author, source := splitAttribution(rawAuthor)
		if author == "" {
			continue
		}
		key := dedupKey(text, author)
		if _, ok := seen[key]; ok {
			skipped++
			continue
		}
		shortID, err := auth.GenerateShortID(10)
		if err != nil {
			tx.Rollback()
			return err
		}
		var src any
		if source != "" {
			src = source
		}
		if _, err := stmt.Exec(shortID, text, author, src, now, now); err != nil {
			tx.Rollback()
			return err
		}
		seen[key] = struct{}{}
		inserted++
	}

	if err := tx.Commit(); err != nil {
		return err
	}
	total, _ := countQuotes(db)
	logger.Info("seed complete", "scanned", scanned, "inserted", inserted, "skipped_duplicates", skipped, "total_in_db", total)
	return nil
}