package sqlitestore

import (
	"context"
	_ "embed"
	"fmt"
	"time"

	"zombiezen.com/go/sqlite/sqlitex"

	"git.sunturtle.xyz/zephyr/kaiyan/emote"
)

type Store struct {
	pool *sqlitex.Pool
}

//go:embed schema.sql
var schemaSQL string

//go:embed metrics.sql
var metricsSQL string

// Open creates a metrics store using db as its underlying storage.
// It initializes the schema used for Kaiyan.
func Open(ctx context.Context, db *sqlitex.Pool) (*Store, error) {
	conn, err := db.Take(ctx)
	defer db.Put(conn)
	if err != nil {
		return nil, fmt.Errorf("couldn't get connection from pool: %w", err)
	}
	if err := sqlitex.ExecuteScript(conn, schemaSQL, nil); err != nil {
		return nil, fmt.Errorf("couldn't run migration: %w", err)
	}
	st := Store{db}
	return &st, nil
}

// Close closes the database.
func (db *Store) Close() error {
	return db.pool.Close()
}

// Record stores the emotes in a given message.
func (db *Store) Record(ctx context.Context, channel, message, sender string, tm time.Time, emotes []emote.Emote) (err error) {
	conn, err := db.pool.Take(ctx)
	defer db.pool.Put(conn)
	if err != nil {
		return fmt.Errorf("couldn't get connection to record emotes: %w", err)
	}
	defer sqlitex.Transaction(conn)(&err)

	st, err := conn.Prepare(`INSERT INTO emote (channel, message, time, sender, id, name, source, link, image) VALUES (:channel, :message, :time, :sender, :id, :name, :source, :link, :image)`)
	if err != nil {
		return fmt.Errorf("couldn't prepare emote insert: %w", err)
	}
	st.SetText(":channel", channel)
	st.SetText(":message", message)
	st.SetInt64(":time", tm.UnixNano())
	st.SetText(":sender", sender)
	for _, em := range emotes {
		st.SetText(":id", em.ID)
		st.SetText(":name", em.Name)
		st.SetText(":source", em.Source)
		st.SetText(":link", em.Link)
		st.SetText(":image", em.Image)
		_, err := st.Step()
		if err != nil {
			return fmt.Errorf("couldn't insert emote: %w", err)
		}
		st.Reset() // NOTE(branden): bound parameters are retained
	}
	return nil
}

// Metrics appends emote usage information for a channel in a given time range.
func (db *Store) Metrics(ctx context.Context, channel string, start, end time.Time, onto []emote.Metric) ([]emote.Metric, error) {
	conn, err := db.pool.Take(ctx)
	defer db.pool.Put(conn)
	if err != nil {
		return onto, fmt.Errorf("couldn't get connection for metrics: %w", err)
	}
	st, err := conn.Prepare(metricsSQL)
	if err != nil {
		return onto, fmt.Errorf("couldn't prepare metrics statement: %w", err)
	}
	st.SetText(":channel", channel)
	st.SetInt64(":start", start.UnixNano())
	st.SetInt64(":end", end.UnixNano())
	for {
		ok, err := st.Step()
		if err != nil {
			return onto, fmt.Errorf("couldn't step metrics selection: %w", err)
		}
		if !ok {
			break
		}

		m := emote.Metric{
			Emote: emote.Emote{
				ID:     st.ColumnText(0),
				Name:   st.ColumnText(1),
				Source: st.ColumnText(2),
				Link:   st.ColumnText(3),
				Image:  st.ColumnText(4),
			},
			Tokens:   st.ColumnInt64(5),
			Messages: st.ColumnInt64(6),
			Users:    st.ColumnInt64(7),
		}
		onto = append(onto, m)
	}
	return onto, st.Reset()
}