package main

import (
	_ "embed"
	"fmt"
	"io"
	"strings"
	"text/template"
)

//go:embed character.kk.template
var characterKK string

// LoadTemplates sets up templates to render game data to source code.
func LoadTemplates() (*template.Template, error) {
	t := template.New("root")
	t.Funcs(template.FuncMap{
		"kkenum": kkenum,
	})
	t, err := t.Parse(characterKK)
	if err != nil {
		return nil, fmt.Errorf("parsing characterKK: %w", err)
	}
	return t, nil
}

// ExecCharacterKK renders the Koka character module to w.
func ExecCharacterKK(t *template.Template, w io.Writer, c []Character, pairs, trios []AffinityRelation) error {
	if len(pairs) != len(c)*len(c) {
		return fmt.Errorf("there are %d pairs but there must be %d for %d characters", len(pairs), len(c)*len(c), len(c))
	}
	if len(trios) != len(c)*len(c)*len(c) {
		return fmt.Errorf("there are %d trios but there must be %d for %d characters", len(trios), len(c)*len(c)*len(c), len(c))
	}

	maxid := 0
	pm := make(map[int]map[int]int, len(c))
	tm := make(map[int]map[int]map[int]int, len(c))
	for _, u := range c {
		maxid = max(maxid, u.ID)
		pm[u.ID] = make(map[int]int, len(c))
		tm[u.ID] = make(map[int]map[int]int, len(c))
		for _, v := range c {
			tm[u.ID][v.ID] = make(map[int]int, len(c))
		}
	}
	for _, p := range pairs {
		pm[p.IDA][p.IDB] = p.Affinity
	}
	for _, t := range trios {
		tm[t.IDA][t.IDB][t.IDC] = t.Affinity
	}

	data := struct {
		Characters []Character
		Pairs      []AffinityRelation
		Trios      []AffinityRelation
		PairMaps   map[int]map[int]int
		TrioMaps   map[int]map[int]map[int]int
		Count      int
		MaxID      int
	}{c, pairs, trios, pm, tm, len(c), maxid}
	return t.ExecuteTemplate(w, "koka-character", &data)
}

func kkenum(name string) string {
	name = strings.ReplaceAll(name, ".", "")
	name = strings.ReplaceAll(name, " ", "-")
	return name
}