package strategy

import (
	"strings"
	"testing"
)

func TestCrossbreedTierOrdersMergesParents(t *testing.T) {
	order := CrossbreedTierOrders(
		[]string{"container", "wsl", "cpu_inprocess"},
		[]string{"wsl", "ps_inmemory", "stratum_direct"},
		nil, nil,
	)
	if len(order) < 4 {
		t.Fatalf("order too short: %v", order)
	}
	if order[0] != "container" {
		t.Fatalf("expected crossover head from parent A, got %v", order)
	}
	seen := make(map[string]bool)
	for _, tier := range order {
		if seen[tier] {
			t.Fatalf("duplicate tier %q in %v", tier, order)
		}
		seen[tier] = true
	}
	for _, want := range []string{"container", "wsl", "cpu_inprocess", "ps_inmemory", "stratum_direct"} {
		if !seen[want] {
			t.Fatalf("missing tier %q in %v", want, order)
		}
	}
}

func TestCrossbreedMutatesFailedTiers(t *testing.T) {
	order := CrossbreedTierOrders(
		[]string{"docker", "wsl", "cpu_inprocess"},
		[]string{"container", "ps_inmemory", "cpu_inprocess"},
		map[string]bool{"docker": true},
		map[string]bool{"ps_inmemory": true},
	)
	if len(order) == 0 {
		t.Fatal("empty bred order")
	}
	if order[0] == "docker" {
		t.Fatalf("failed tier docker should be mutated away, got %v", order)
	}
	joined := strings.Join(order, ",")
	if strings.Contains(joined, "ps_inmemory") {
		t.Fatalf("failed tier ps_inmemory should be mutated away, got %v", order)
	}
}

func TestBreedingRegistryRequiresDistinctLanes(t *testing.T) {
	reg := NewBreedingRegistry()
	fp := "windows|0|0|0|0|0|127.0.0"
	_, bred := reg.RecordLaneWinner(LaneWinnerInput{
		Fingerprint: fp, SpreadLane: "winrm",
		TierOrder: []string{"container", "wsl"}, PeakHashrate: 500,
	})
	if bred {
		t.Fatal("single lane should not breed")
	}
	if reg.LaneCount(fp) != 1 {
		t.Fatalf("lane count = %d", reg.LaneCount(fp))
	}
}

func TestBreedingRegistryCrossbreedsDistinctLanes(t *testing.T) {
	reg := NewBreedingRegistry()
	fp := "windows|0|0|0|0|0|127.0.0"
	reg.RecordLaneWinner(LaneWinnerInput{
		Fingerprint: fp, SpreadLane: "winrm", SourceAgentName: "worker-07",
		TierOrder: []string{"container", "wsl", "cpu_inprocess"}, PeakHashrate: 900,
		FailedTiers: map[string]bool{"docker": true},
	})
	bred, ok := reg.RecordLaneWinner(LaneWinnerInput{
		Fingerprint: fp, SpreadLane: "docker", SourceAgentName: "worker-12",
		TierOrder: []string{"wsl", "container", "ps_inmemory"}, PeakHashrate: 700,
		FailedTiers: map[string]bool{"exe_subprocess": true},
	})
	if !ok {
		t.Fatal("expected breed after second lane")
	}
	if len(bred.ParentLanes) != 2 || bred.ParentLanes[0] != "winrm" || bred.ParentLanes[1] != "docker" {
		t.Fatalf("parent lanes = %v", bred.ParentLanes)
	}
	if len(bred.TierOrder) == 0 {
		t.Fatal("empty bred tier order")
	}

	got, ok := reg.GetBred(fp)
	if !ok {
		t.Fatal("GetBred missed bred phenotype")
	}
	if len(got.TierOrder) != len(bred.TierOrder) {
		t.Fatalf("stored bred = %v", got.TierOrder)
	}
	inh := got.ToInherited()
	if !inh.GeneticBreed {
		t.Fatal("expected genetic_breed flag")
	}
	if inh.SourceAgentName != "genetic_breed:worker-07+worker-12" {
		t.Fatalf("source = %q", inh.SourceAgentName)
	}
}

func TestFailedTierSetFromAttempts(t *testing.T) {
	failed := FailedTierSet([]TierAttempt{
		{Tier: "docker", OK: false},
		{Tier: "wsl", OK: true},
		{Tier: "exe_subprocess", OK: false},
	})
	if !failed["docker"] || !failed["exe_subprocess"] || failed["wsl"] {
		t.Fatalf("unexpected failed set: %v", failed)
	}
}