package beads

import (
	"os"
	"path/filepath"
	"strings"
	"testing"
)

// TestChristmasOrnamentPattern tests the dynamic bonding pattern used by mol-witness-patrol.
// This pattern allows a parent molecule step to dynamically spawn child molecules
// at runtime, with a fanout gate (WaitsFor: all-children) for aggregation.
func TestChristmasOrnamentPattern(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	// Find beads repo
	workDir := findBeadsDir(t)
	if workDir == "" {
		t.Skip("no .beads directory found")
	}

	b := New(workDir)

	// Test 1: Verify mol-witness-patrol has correct structure
	t.Run("WitnessPatrolStructure", func(t *testing.T) {
		mol := WitnessPatrolMolecule()
		steps, err := ParseMoleculeSteps(mol.Description)
		if err != nil {
			t.Fatalf("failed to parse mol-witness-patrol: %v", err)
		}

		// Find aggregate step
		var aggregateStep *MoleculeStep
		for i := range steps {
			if steps[i].Ref == "aggregate" {
				aggregateStep = &steps[i]
				break
			}
		}

		if aggregateStep == nil {
			t.Fatal("aggregate step not found in mol-witness-patrol")
		}

		// Verify WaitsFor: all-children
		hasAllChildren := false
		for _, cond := range aggregateStep.WaitsFor {
			if strings.ToLower(cond) == "all-children" {
				hasAllChildren = true
				break
			}
		}
		if !hasAllChildren {
			t.Errorf("aggregate step should have WaitsFor: all-children, got %v", aggregateStep.WaitsFor)
		}

		// Verify aggregate needs survey-workers
		needsSurvey := false
		for _, dep := range aggregateStep.Needs {
			if dep == "survey-workers" {
				needsSurvey = true
				break
			}
		}
		if !needsSurvey {
			t.Errorf("aggregate step should need survey-workers, got %v", aggregateStep.Needs)
		}
	})

	// Test 2: Verify mol-polecat-arm has correct structure
	t.Run("PolecatArmStructure", func(t *testing.T) {
		mol := PolecatArmMolecule()
		steps, err := ParseMoleculeSteps(mol.Description)
		if err != nil {
			t.Fatalf("failed to parse mol-polecat-arm: %v", err)
		}

		// Should have 5 steps in order: capture, assess, load-history, decide, execute
		expectedRefs := []string{"capture", "assess", "load-history", "decide", "execute"}
		if len(steps) != len(expectedRefs) {
			t.Errorf("expected %d steps, got %d", len(expectedRefs), len(steps))
		}

		for i, expected := range expectedRefs {
			if i < len(steps) && steps[i].Ref != expected {
				t.Errorf("step %d: expected %q, got %q", i, expected, steps[i].Ref)
			}
		}

		// Verify template variables are present in description
		if !strings.Contains(mol.Description, "{{polecat_name}}") {
			t.Error("mol-polecat-arm should have {{polecat_name}} template variable")
		}
		if !strings.Contains(mol.Description, "{{rig}}") {
			t.Error("mol-polecat-arm should have {{rig}} template variable")
		}
	})

	// Test 3: Template variable expansion
	t.Run("TemplateVariableExpansion", func(t *testing.T) {
		mol := PolecatArmMolecule()

		ctx := map[string]string{
			"polecat_name": "toast",
			"rig":          "gastown",
		}

		expanded := ExpandTemplateVars(mol.Description, ctx)

		// Template variables should be expanded
		if strings.Contains(expanded, "{{polecat_name}}") {
			t.Error("{{polecat_name}} was not expanded")
		}
		if strings.Contains(expanded, "{{rig}}") {
			t.Error("{{rig}} was not expanded")
		}

		// Values should be present
		if !strings.Contains(expanded, "toast") {
			t.Error("polecat_name value 'toast' not found in expanded description")
		}
		if !strings.Contains(expanded, "gastown") {
			t.Error("rig value 'gastown' not found in expanded description")
		}
	})

	// Test 4: Create parent and verify bonding metadata parsing
	t.Run("BondingMetadataParsing", func(t *testing.T) {
		// Create a test issue with bonding metadata (simulating what mol bond creates)
		bondingDesc := `Polecat Arm (arm-toast)

---
bonded_from: mol-polecat-arm
bonded_to: patrol-x7k
bonded_ref: arm-toast
bonded_at: 2025-12-23T10:00:00Z
`
		// Verify we can parse the bonding metadata
		if !strings.Contains(bondingDesc, "bonded_from:") {
			t.Error("bonding metadata should contain bonded_from")
		}
		if !strings.Contains(bondingDesc, "bonded_to:") {
			t.Error("bonding metadata should contain bonded_to")
		}
		if !strings.Contains(bondingDesc, "bonded_ref:") {
			t.Error("bonding metadata should contain bonded_ref")
		}
	})

	// Test 5: Verify issue creation with parent relationship works
	t.Run("ParentChildRelationship", func(t *testing.T) {
		// Create a test parent issue
		parent, err := b.Create(CreateOptions{
			Title:       "Test Patrol Parent",
			Type:        "task",
			Priority:    2,
			Description: "Test parent for Christmas Ornament pattern",
		})
		if err != nil {
			t.Fatalf("failed to create parent issue: %v", err)
		}
		defer func() {
			_ = b.Close(parent.ID)
		}()

		// Create a child issue under the parent
		child, err := b.Create(CreateOptions{
			Title:       "Test Polecat Arm",
			Type:        "task",
			Priority:    parent.Priority,
			Parent:      parent.ID,
			Description: "Test child for bonding pattern",
		})
		if err != nil {
			t.Fatalf("failed to create child issue: %v", err)
		}
		defer func() {
			_ = b.Close(child.ID)
		}()

		// Verify parent-child relationship exists
		// The child should have a dependency on the parent
		t.Logf("Created parent %s and child %s", parent.ID, child.ID)
	})
}

// TestEmptyPatrol tests the scenario where witness patrol runs with 0 polecats.
func TestEmptyPatrol(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	mol := WitnessPatrolMolecule()
	steps, err := ParseMoleculeSteps(mol.Description)
	if err != nil {
		t.Fatalf("failed to parse mol-witness-patrol: %v", err)
	}

	// Find survey-workers step
	var surveyStep *MoleculeStep
	for i := range steps {
		if steps[i].Ref == "survey-workers" {
			surveyStep = &steps[i]
			break
		}
	}

	if surveyStep == nil {
		t.Fatal("survey-workers step not found")
	}

	// Verify the step description mentions handling 0 polecats
	if !strings.Contains(surveyStep.Instructions, "no polecats") &&
		!strings.Contains(surveyStep.Instructions, "If no polecats") {
		t.Log("Note: survey-workers step should document handling of 0 polecats case")
	}

	// With 0 polecats:
	// - survey-workers bonds no children
	// - aggregate step with WaitsFor: all-children should complete immediately
	// This is correct behavior - an empty set of children is vacuously complete
}

// TestNudgeProgression tests the nudge matrix logic documented in mol-polecat-arm.
func TestNudgeProgression(t *testing.T) {
	mol := PolecatArmMolecule()
	steps, err := ParseMoleculeSteps(mol.Description)
	if err != nil {
		t.Fatalf("failed to parse mol-polecat-arm: %v", err)
	}

	// Find decide step (contains the nudge matrix)
	var decideStep *MoleculeStep
	for i := range steps {
		if steps[i].Ref == "decide" {
			decideStep = &steps[i]
			break
		}
	}

	if decideStep == nil {
		t.Fatal("decide step not found in mol-polecat-arm")
	}

	// Verify the nudge matrix is documented
	nudgeKeywords := []string{"nudge-1", "nudge-2", "nudge-3", "escalate"}
	for _, keyword := range nudgeKeywords {
		if !strings.Contains(decideStep.Instructions, keyword) {
			t.Errorf("decide step should document %s action", keyword)
		}
	}

	// Verify idle time thresholds are documented
	timeThresholds := []string{"10-15min", "15-20min", "20+min"}
	for _, threshold := range timeThresholds {
		if !strings.Contains(decideStep.Instructions, threshold) &&
			!strings.Contains(decideStep.Instructions, strings.ReplaceAll(threshold, "-", " ")) {
			t.Logf("Note: decide step should document %s threshold", threshold)
		}
	}
}

// TestPreKillVerification tests that the execute step documents pre-kill verification.
func TestPreKillVerification(t *testing.T) {
	mol := PolecatArmMolecule()
	steps, err := ParseMoleculeSteps(mol.Description)
	if err != nil {
		t.Fatalf("failed to parse mol-polecat-arm: %v", err)
	}

	// Find execute step
	var executeStep *MoleculeStep
	for i := range steps {
		if steps[i].Ref == "execute" {
			executeStep = &steps[i]
			break
		}
	}

	if executeStep == nil {
		t.Fatal("execute step not found in mol-polecat-arm")
	}

	// Verify pre-kill verification is documented
	if !strings.Contains(executeStep.Instructions, "pre-kill") &&
		!strings.Contains(executeStep.Instructions, "git status") {
		t.Error("execute step should document pre-kill verification")
	}

	// Verify clean git state check
	if !strings.Contains(executeStep.Instructions, "clean") {
		t.Error("execute step should check for clean git state")
	}

	// Verify unpushed commits check
	if !strings.Contains(executeStep.Instructions, "unpushed") {
		t.Log("Note: execute step should document unpushed commits check")
	}
}

// TestWaitsForAllChildren tests the fanout gate semantics.
func TestWaitsForAllChildren(t *testing.T) {
	// Test the WaitsFor parsing
	desc := `## Step: survey
Discover items.

## Step: aggregate
Collect results.
WaitsFor: all-children
Needs: survey`

	steps, err := ParseMoleculeSteps(desc)
	if err != nil {
		t.Fatalf("failed to parse: %v", err)
	}

	if len(steps) != 2 {
		t.Fatalf("expected 2 steps, got %d", len(steps))
	}

	aggregate := steps[1]
	if aggregate.Ref != "aggregate" {
		t.Errorf("expected aggregate step, got %s", aggregate.Ref)
	}

	if len(aggregate.WaitsFor) != 1 || aggregate.WaitsFor[0] != "all-children" {
		t.Errorf("expected WaitsFor: [all-children], got %v", aggregate.WaitsFor)
	}
}

// TestMultipleWaitsForConditions tests parsing multiple WaitsFor conditions.
func TestMultipleWaitsForConditions(t *testing.T) {
	desc := `## Step: finalize
Complete the process.
WaitsFor: all-children, external-signal, timeout`

	steps, err := ParseMoleculeSteps(desc)
	if err != nil {
		t.Fatalf("failed to parse: %v", err)
	}

	if len(steps) != 1 {
		t.Fatalf("expected 1 step, got %d", len(steps))
	}

	expected := []string{"all-children", "external-signal", "timeout"}
	if len(steps[0].WaitsFor) != len(expected) {
		t.Errorf("expected %d WaitsFor conditions, got %d", len(expected), len(steps[0].WaitsFor))
	}

	for i, exp := range expected {
		if i < len(steps[0].WaitsFor) && steps[0].WaitsFor[i] != exp {
			t.Errorf("WaitsFor[%d]: expected %q, got %q", i, exp, steps[0].WaitsFor[i])
		}
	}
}

// TestMolBondCLI tests the mol bond command via CLI integration.
// This test requires the gt binary to be built and in PATH.
func TestMolBondCLI(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping CLI integration test in short mode")
	}

	workDir := findBeadsDir(t)
	if workDir == "" {
		t.Skip("no .beads directory found")
	}

	b := New(workDir)

	// Create a parent issue to bond to
	parent, err := b.Create(CreateOptions{
		Title:       "Test Patrol for Bonding",
		Type:        "task",
		Priority:    2,
		Description: "Parent issue for mol bond CLI test",
	})
	if err != nil {
		t.Fatalf("failed to create parent issue: %v", err)
	}
	defer func() {
		// Clean up: close parent (children are auto-closed as children)
		_ = b.Close(parent.ID)
	}()

	// Test bonding mol-polecat-arm to the parent
	t.Run("BondPolecatArm", func(t *testing.T) {
		// Use bd mol bond command (the underlying command)
		// gt mol bond mol-polecat-arm --parent=<id> --ref=arm-test --var polecat_name=toast --var rig=gastown
		args := []string{
			"mol", "bond", "mol-polecat-arm",
			"--parent", parent.ID,
			"--ref", "arm-toast",
			"--var", "polecat_name=toast",
			"--var", "rig=gastown",
		}

		// Execute via the beads wrapper
		// Since we can't easily call the cmd package from here,
		// we verify the bonding logic works by testing the building blocks

		// 1. Verify mol-polecat-arm exists in catalog
		catalog := BuiltinMolecules()

		var polecatArm *BuiltinMolecule
		for i := range catalog {
			if catalog[i].ID == "mol-polecat-arm" {
				polecatArm = &catalog[i]
				break
			}
		}
		if polecatArm == nil {
			t.Fatal("mol-polecat-arm not found in catalog")
		}

		// 2. Verify template expansion works
		ctx := map[string]string{
			"polecat_name": "toast",
			"rig":          "gastown",
		}
		expanded := ExpandTemplateVars(polecatArm.Description, ctx)
		if strings.Contains(expanded, "{{polecat_name}}") {
			t.Error("template variable polecat_name was not expanded")
		}
		if strings.Contains(expanded, "{{rig}}") {
			t.Error("template variable rig was not expanded")
		}

		// 3. Create a child issue manually to simulate what mol bond does
		childTitle := "Polecat Arm (arm-toast)"
		bondingMeta := `
---
bonded_from: mol-polecat-arm
bonded_to: ` + parent.ID + `
bonded_ref: arm-toast
bonded_at: 2025-12-23T10:00:00Z
`
		childDesc := expanded + bondingMeta

		child, err := b.Create(CreateOptions{
			Title:       childTitle,
			Type:        "task",
			Priority:    parent.Priority,
			Parent:      parent.ID,
			Description: childDesc,
		})
		if err != nil {
			t.Fatalf("failed to create bonded child: %v", err)
		}
		defer func() {
			_ = b.Close(child.ID)
		}()

		// 4. Verify the child was created with correct properties
		fetched, err := b.Show(child.ID)
		if err != nil {
			t.Fatalf("failed to fetch child: %v", err)
		}

		if !strings.Contains(fetched.Title, "arm-toast") {
			t.Errorf("child title should contain arm-toast, got %s", fetched.Title)
		}
		if !strings.Contains(fetched.Description, "bonded_from: mol-polecat-arm") {
			t.Error("child description should contain bonding metadata")
		}
		if !strings.Contains(fetched.Description, "toast") {
			t.Error("child description should have expanded polecat_name")
		}

		t.Logf("Created bonded child: %s (%s)", child.ID, childTitle)
		t.Logf("Args that would be used: %v", args)
	})
}

// TestActivityFeed tests the activity feed output from witness patrol.
func TestActivityFeed(t *testing.T) {
	// The activity feed should show:
	// - Polecats inspected
	// - Nudges sent
	// - Sessions killed
	// - Escalations

	mol := WitnessPatrolMolecule()
	steps, err := ParseMoleculeSteps(mol.Description)
	if err != nil {
		t.Fatalf("failed to parse mol-witness-patrol: %v", err)
	}

	// Find generate-summary step (produces activity feed)
	var summaryStep *MoleculeStep
	for i := range steps {
		if steps[i].Ref == "generate-summary" {
			summaryStep = &steps[i]
			break
		}
	}

	if summaryStep == nil {
		t.Fatal("generate-summary step not found in mol-witness-patrol")
	}

	// Verify the step documents key metrics
	expectedMetrics := []string{
		"Workers inspected",
		"Nudges sent",
		"Sessions killed",
		"Escalations",
	}

	for _, metric := range expectedMetrics {
		if !strings.Contains(strings.ToLower(summaryStep.Instructions), strings.ToLower(metric)) {
			t.Logf("Note: generate-summary should document %q metric", metric)
		}
	}

	// Verify it mentions digests (for squashing)
	if !strings.Contains(summaryStep.Instructions, "digest") {
		t.Log("Note: generate-summary should mention digest creation")
	}
}

// findBeadsDir walks up from current directory to find .beads
func findBeadsDir(t *testing.T) string {
	t.Helper()

	cwd, err := os.Getwd()
	if err != nil {
		t.Fatalf("failed to get cwd: %v", err)
	}

	dir := cwd
	for {
		if _, err := os.Stat(filepath.Join(dir, ".beads")); err == nil {
			return dir
		}
		parent := filepath.Dir(dir)
		if parent == dir {
			return ""
		}
		dir = parent
	}
}