// Command bootstrap is the minimal self-reproducing kernel.
// It executes the full lifecycle: read spore, nucleate, grow,
// govern, sporulate, emit, evaluate. Nothing more.
//
// Usage:
//
//	bootstrap                          abiogenesis + stdin input
//	bootstrap -spore F                 germinate from spore file
//	bootstrap -spore F input.txt       germinate + file input
//	bootstrap < input.txt              abiogenesis + piped input
//	bootstrap -strategy                abiogenesis with Art of War DNA
package main

import (
	"bytes"
	"context"
	_ "embed"
	"flag"
	"fmt"
	"io"
	"os"
	"time"

	"git.mleku.dev/mleku/dendrite/pkg/axiom"
	"git.mleku.dev/mleku/dendrite/pkg/emit"
	"git.mleku.dev/mleku/dendrite/pkg/enzyme"
	"git.mleku.dev/mleku/dendrite/pkg/fitness"
	"git.mleku.dev/mleku/dendrite/pkg/grow"
	"git.mleku.dev/mleku/dendrite/pkg/hexagram"
	"git.mleku.dev/mleku/dendrite/pkg/lattice"
	"git.mleku.dev/mleku/dendrite/pkg/spore"
	"git.mleku.dev/mleku/dendrite/pkg/strategy"
)

//go:embed main.go
var ownSource string

// tagConstraint is the simplest constraint: admits elements with matching type.
type tagConstraint struct{ tag string }

func (c tagConstraint) Tag() string                 { return c.tag }
func (c tagConstraint) Admits(e axiom.Element) bool  { return e.Type() == c.tag }
func constraintFactory(tag string) axiom.Constraint  { return tagConstraint{tag} }

var goRoot string

func init() {
	goRoot = os.Getenv("GOROOT")
	if goRoot == "" {
		goRoot = "/usr/local/go"
	}
}

func main() {
	sporeFile := flag.String("spore", "", "spore file to germinate from")
	outDir := flag.String("out", ".", "output directory for emitted files")
	strategyMode := flag.Bool("strategy", false, "embed Art of War strategy layer")
	flag.Parse()

	os.MkdirAll(*outDir, 0755)

	// 1. READ SPORE
	var parent *spore.Spore
	if *sporeFile != "" {
		f, err := os.Open(*sporeFile)
		if err != nil {
			fatal("open spore: %v", err)
		}
		parent, err = spore.ReadSpore(f)
		f.Close()
		if err != nil {
			fatal("read spore: %v", err)
		}
		fmt.Printf("germinate: gen=%d nodes=%d\n", parent.Generation, parent.TotalNodes)
	}

	// 2. NUCLEATE
	var l *lattice.Lattice
	if parent != nil {
		size := parent.TotalNodes
		if size < 64 {
			size = 64
		}
		l = parent.Nucleate(size, constraintFactory)
	} else {
		l = abiogenesis()
	}
	fmt.Printf("lattice: %d nodes\n", l.Size())

	// 3. STRATEGY LAYER
	if *strategyMode {
		strategy.Seed(l)
	}

	// 4. ACCEPT INPUT
	solution := make(chan axiom.Element, 512)
	go func() {
		defer close(solution)
		var r io.Reader
		if len(flag.Args()) > 0 {
			f, err := os.Open(flag.Arg(0))
			if err != nil {
				fmt.Fprintf(os.Stderr, "input: %v\n", err)
				return
			}
			defer f.Close()
			r = f
		} else {
			r = os.Stdin
		}
		for e := range (enzyme.Text{}).Digest(r) {
			if e.Type() != "space" {
				solution <- e
			}
		}
	}()

	// 5. GROW
	growCtx, growCancel := context.WithTimeout(context.Background(), 3*time.Second)
	growEv := make(chan grow.Event, 256)
	go func() {
		grow.Run(growCtx, l, solution, grow.Config{MaxSteps: 500, Workers: 4}, growEv)
		close(growEv)
	}()
	bonded := 0
	for ev := range growEv {
		if ev.Type == grow.EventBonded {
			bonded++
		}
	}
	growCancel()
	fmt.Printf("growth: %d bonded\n", bonded)

	// 6. HEXAGRAM ENGINE
	engSolution := make(chan axiom.Element, 128)
	engCtx, engCancel := context.WithTimeout(context.Background(), 2*time.Second)
	engEv := make(chan hexagram.Event, 256)
	go func() {
		hexagram.RunEngine(engCtx, l, hexagram.EngineConfig{
			Interval:    16 * time.Millisecond, // 2^4 ms — epoch-aligns with dissolve at 10^2 ms
			Solution:    engSolution,
			MaxNewSites: 4,
		}, engEv)
		close(engEv)
	}()
	ops := make(map[hexagram.Op]int)
	for ev := range engEv {
		ops[ev.Op]++
	}
	engCancel()
	close(engSolution)
	fmt.Printf("engine: %d operations\n", sumOps(ops))

	// 7. SPORULATE
	seed := spore.Extract(l, parent)
	sporeOut := fmt.Sprintf("%s/bootstrap.gen%d.spore", *outDir, seed.Generation)
	if sf, err := os.Create(sporeOut); err == nil {
		seed.WriteTo(sf)
		sf.Close()
	}

	// 8. EMIT GO SOURCE
	files := emit.Harvest(l)
	emitFile := ""
	if len(files) > 0 {
		var biggest string
		var bc int
		for k, v := range files {
			if len(v) > bc {
				biggest = k
				bc = len(v)
			}
		}
		emitFile = fmt.Sprintf("%s/bootstrap.gen%d.go", *outDir, seed.Generation)
		var buf bytes.Buffer
		emit.EmitGo(files[biggest], &buf)

		// Apply polymorphic transformation.
		polymorphed := Polymorph(buf.Bytes())
		if f, err := os.Create(emitFile); err == nil {
			f.Write(polymorphed)
			f.Close()
			fmt.Printf("emit: %s (%d fragments, polymorphed)\n", emitFile, bc)
		}
	}

	// 9. EVALUATE FITNESS
	if emitFile != "" {
		emitted := readFile(emitFile)
		score := fitness.Score{}
		score.Source = fitness.SourceSimilarity(ownSource, emitted)
		score.Compute()
		seed.Fitness = &spore.FitnessScore{
			Source:  score.Source,
			Binary:  score.Binary,
			Behav:   score.Behav,
			Overall: score.Overall,
		}
		fmt.Printf("fitness: src=%.3f overall=%.3f\n", score.Source.Float64(), score.Overall.Float64())
	}

	// Write final spore with fitness.
	if sf, err := os.Create(sporeOut); err == nil {
		seed.WriteTo(sf)
		sf.Close()
	}
	fmt.Printf("spore: %s (gen=%d)\n", sporeOut, seed.Generation)
}

func abiogenesis() *lattice.Lattice {
	l := lattice.New()
	var all []*lattice.Node

	// 48 word sites + 8 punct sites.
	for range 48 {
		n := l.AddNode([]axiom.Constraint{tagConstraint{"word"}})
		n.SetEnergy(true)
		all = append(all, n)
	}
	for range 8 {
		n := l.AddNode([]axiom.Constraint{tagConstraint{"punct"}})
		n.SetEnergy(true)
		all = append(all, n)
	}
	for i, n := range all {
		l.Connect(n, all[(i+1)%len(all)])
	}
	return l
}

func readFile(path string) string {
	data, _ := os.ReadFile(path)
	return string(data)
}

func fatal(f string, args ...any) {
	fmt.Fprintf(os.Stderr, f+"\n", args...)
	os.Exit(1)
}

func sumOps(m map[hexagram.Op]int) int {
	n := 0
	for _, v := range m {
		n += v
	}
	return n
}