package strategy

import (
	"fmt"
	"strings"

	"git.mleku.dev/mleku/dendrite/pkg/axiom"
	"git.mleku.dev/mleku/dendrite/pkg/lattice"
)

// Seed injects The Art of War into a lattice. Creates strategy-constrained
// sites and bonds strategy elements to them. Returns the number of elements
// bonded.
func Seed(l *lattice.Lattice) int {
	// Sites per level per category.
	sitesPerLevel := map[Level]int{
		LevelChapter:   2,  // 13×2 = 26 coarse sites
		LevelPrinciple: 4,  // 13×4 = 52 principle sites
		LevelMaxim:     8,  // 13×8 = 104 maxim sites
		LevelTactic:    6,  // 13×6 = 78 tactic sites
	}
	// Total: 260 strategy sites.

	// Create strategy region: sites grouped by category.
	type catNodes struct {
		cat   Category
		nodes []*lattice.Node
	}
	var regions []catNodes

	for cat := CatAssessment; cat <= CatIntelligence; cat++ {
		cn := catNodes{cat: cat}
		for lvl := LevelChapter; lvl <= LevelTactic; lvl++ {
			count := sitesPerLevel[lvl]
			for range count {
				n := l.AddNode([]axiom.Constraint{
					StrategyConstraint{Cat: cat, MinLevel: lvl},
				})
				n.SetEnergy(true)
				cn.nodes = append(cn.nodes, n)
			}
		}
		regions = append(regions, cn)
	}

	// Ring topology within each category.
	for _, cn := range regions {
		for i := range cn.nodes {
			l.Connect(cn.nodes[i], cn.nodes[(i+1)%len(cn.nodes)])
		}
	}

	// Cross-category bridges: connect every 5th node between adjacent categories.
	for i := 0; i < len(regions)-1; i++ {
		a := regions[i].nodes
		b := regions[i+1].nodes
		step := max(1, min(len(a), len(b))/4)
		for k := 0; k < min(len(a), len(b)); k += step {
			l.Connect(a[k], b[k])
		}
	}
	// Close the ring: connect last category to first.
	if len(regions) > 1 {
		a := regions[len(regions)-1].nodes
		b := regions[0].nodes
		step := max(1, min(len(a), len(b))/4)
		for k := 0; k < min(len(a), len(b)); k += step {
			l.Connect(a[k], b[k])
		}
	}

	// Digest the embedded text and bond elements to strategy sites.
	elements := DigestEmbedded()
	bonded := 0
	for elem := range elements {
		// Try to bond at a matching site.
		for _, cn := range regions {
			found := false
			for _, n := range cn.nodes {
				if !n.Occupied() && n.Admits(elem) {
					if n.Bond(elem) {
						bonded++
						found = true
						break
					}
				}
			}
			if found {
				break
			}
		}
	}

	totalSites := 0
	for _, cn := range regions {
		totalSites += len(cn.nodes)
	}

	fmt.Printf("strategy: %d elements bonded to %d sites (13 chapters)\n", bonded, totalSites)
	return bonded
}

// SeedFromText injects custom strategic text (in the same format as
// artofwar.txt) into a lattice.
func SeedFromText(l *lattice.Lattice, text string) int {
	elements := (Enzyme{}).Digest(strings.NewReader(text))
	bonded := 0
	for elem := range elements {
		// Find any strategy-typed vacant node.
		for _, n := range l.Nodes() {
			if !n.Occupied() && n.Admits(elem) {
				if n.Bond(elem) {
					bonded++
					break
				}
			}
		}
	}
	return bonded
}