package main

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

	"zombiezen.com/go/sqlite/sqlitex"
)

//go:embed character.sql
var characterSQL string

//go:embed character.affinity2.sql
var characterAffinity2SQL string

//go:embed character.affinity3.sql
var characterAffinity3SQL string

type Character struct {
	ID   int
	Name string
}

func Characters(ctx context.Context, db *sqlitex.Pool) ([]Character, error) {
	conn, err := db.Take(ctx)
	defer db.Put(conn)
	if err != nil {
		return nil, fmt.Errorf("couldn't get connection for characters: %w", err)
	}
	stmt, _, err := conn.PrepareTransient(characterSQL)
	if err != nil {
		return nil, fmt.Errorf("couldn't prepare statement for characters: %w", err)
	}
	defer stmt.Finalize()

	var r []Character
	for {
		ok, err := stmt.Step()
		if err != nil {
			return nil, fmt.Errorf("error stepping characters: %w", err)
		}
		if !ok {
			break
		}
		c := Character{
			ID:   stmt.ColumnInt(0),
			Name: stmt.ColumnText(1),
		}
		r = append(r, c)
	}
	return r, nil
}

type AffinityRelation struct {
	IDA      int
	NameA    string
	IDB      int
	NameB    string
	IDC      int
	NameC    string
	Affinity int
}

func CharacterPairs(ctx context.Context, db *sqlitex.Pool) ([]AffinityRelation, error) {
	conn, err := db.Take(ctx)
	defer db.Put(conn)
	if err != nil {
		return nil, fmt.Errorf("couldn't get connection for character pairs: %w", err)
	}
	stmt, _, err := conn.PrepareTransient(characterAffinity2SQL)
	if err != nil {
		return nil, fmt.Errorf("couldn't prepare statement for character pairs: %w", err)
	}
	defer stmt.Finalize()

	var r []AffinityRelation
	for {
		ok, err := stmt.Step()
		if err != nil {
			return nil, fmt.Errorf("error stepping character pairs: %w", err)
		}
		if !ok {
			break
		}
		p := AffinityRelation{
			IDA:      stmt.ColumnInt(0),
			NameA:    stmt.ColumnText(1),
			IDB:      stmt.ColumnInt(2),
			NameB:    stmt.ColumnText(3),
			Affinity: stmt.ColumnInt(4),
		}
		r = append(r, p)
	}
	return r, nil
}

func CharacterTrios(ctx context.Context, db *sqlitex.Pool) ([]AffinityRelation, error) {
	conn, err := db.Take(ctx)
	defer db.Put(conn)
	if err != nil {
		return nil, fmt.Errorf("couldn't get connection for character trios: %w", err)
	}
	stmt, _, err := conn.PrepareTransient(characterAffinity3SQL)
	if err != nil {
		return nil, fmt.Errorf("couldn't prepare statement for character trios: %w", err)
	}
	defer stmt.Finalize()

	var r []AffinityRelation
	for {
		ok, err := stmt.Step()
		if err != nil {
			return nil, fmt.Errorf("error stepping character trios: %w", err)
		}
		if !ok {
			break
		}
		p := AffinityRelation{
			IDA:      stmt.ColumnInt(0),
			NameA:    stmt.ColumnText(1),
			IDB:      stmt.ColumnInt(2),
			NameB:    stmt.ColumnText(3),
			IDC:      stmt.ColumnInt(4),
			NameC:    stmt.ColumnText(5),
			Affinity: stmt.ColumnInt(6),
		}
		r = append(r, p)
	}
	return r, nil
}