package staffing

import (
	"testing"

	"github.com/shopspring/decimal"

	"github.com/missionworkforce/missionmatch/internal/modules/matching/engine"
)

func bandFor(total decimal.Decimal) engine.Band {
	switch {
	case total.GreaterThanOrEqual(decimal.NewFromInt(90)):
		return engine.BandGreen
	case total.GreaterThanOrEqual(decimal.NewFromInt(75)):
		return engine.BandYellow
	default:
		return engine.BandRed
	}
}

func cand(id, total string, available, clearanceOK bool) ScoredCandidate {
	return ScoredCandidate{
		CandidateID:        id,
		Total:              dec(total),
		Band:               bandFor(dec(total)),
		Available:          available,
		ClearanceSatisfied: clearanceOK,
		Provenance:         "sponsor_verified",
		Completeness:       dec("1"),
	}
}

func gapCtx(openSlots int, priority string) GapContext {
	return GapContext{RequirementID: "req-gap", OpenSlots: openSlots, Priority: dec(priority)}
}

func countAction(recs []Recommendation, a Action) int {
	n := 0
	for _, r := range recs {
		if r.Action == a {
			n++
		}
	}
	return n
}

func TestClassifyAssignBasic(t *testing.T) {
	cfg := DefaultConfig()
	recs := ClassifyForGap(cfg, gapCtx(2, "1"), []ScoredCandidate{cand("c1", "92", true, true)})
	if len(recs) != 2 { // one assign, one source (2 slots, 1 assignable)
		t.Fatalf("want 2 recs (assign + source), got %d", len(recs))
	}
	if recs[0].Action != ActionAssign || recs[0].CandidateID != "c1" || recs[0].Rank != 1 {
		t.Fatalf("first rec must be the assign for c1 at rank 1: %+v", recs[0])
	}
	if recs[0].RequirementID != "req-gap" {
		t.Fatalf("recommendation must carry the gap requirement id, got %q", recs[0].RequirementID)
	}
}

func TestClassifyBandFloorBoundary(t *testing.T) {
	cfg := DefaultConfig() // floor 75
	// Exactly at the floor is qualified (>=).
	atFloor := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "75", true, true)})
	if countAction(atFloor, ActionAssign) != 1 {
		t.Fatalf("a candidate exactly at the floor must be assignable")
	}
	// Just below the floor with a reskill path is a reskill, not an assign.
	below := cand("c2", "74.9999", true, true)
	below.Reskill = &ReskillFact{HeldSkill: "SIGINT Tooling", MissingSkill: "Intelligence Analysis", Distance: dec("0.20")}
	belowRecs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{below})
	if countAction(belowRecs, ActionAssign) != 0 {
		t.Fatalf("a candidate below the floor must never be an assign")
	}
	if countAction(belowRecs, ActionReskill) != 1 {
		t.Fatalf("a below floor candidate with an adjacency path must be a reskill")
	}
	// Just below the floor with NO reskill path produces no row for that candidate (never auto rejected).
	bare := cand("c3", "74.9999", true, true)
	bareRecs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{bare})
	for _, r := range bareRecs {
		if r.CandidateID == "c3" {
			t.Fatalf("a below floor candidate with no reskill path must not appear as any recommendation, got %+v", r)
		}
	}
}

func TestClassifyReassign(t *testing.T) {
	cfg := DefaultConfig()
	// Committed to a lower priority requirement -> reassign with the delta.
	c := cand("c1", "95", true, true)
	c.CommittedRequirementID = "req-other"
	c.CommittedPriority = dec("1")
	recs := ClassifyForGap(cfg, gapCtx(1, "2.5"), []ScoredCandidate{c})
	if countAction(recs, ActionReassign) != 1 {
		t.Fatalf("a qualified candidate committed to a lower priority requirement must be a reassign")
	}
	var rr *Recommendation
	for i := range recs {
		if recs[i].Action == ActionReassign {
			rr = &recs[i]
		}
	}
	if rr.Evidence.Reassign == nil || rr.Evidence.Reassign.FromRequirementID != "req-other" {
		t.Fatalf("reassign evidence must name the source requirement: %+v", rr.Evidence)
	}
	if !rr.Evidence.Reassign.PriorityDelta.Equal(dec("1.5")) {
		t.Fatalf("priority delta must be 2.5 - 1 = 1.5, got %s", rr.Evidence.Reassign.PriorityDelta)
	}
	// Committed to an equal or higher priority requirement -> not recommended (leave them where they are).
	c.CommittedPriority = dec("2.5")
	none := ClassifyForGap(cfg, gapCtx(1, "2.5"), []ScoredCandidate{c})
	if countAction(none, ActionReassign) != 0 {
		t.Fatalf("a candidate committed at equal priority must not be reassigned")
	}
}

func TestClassifyCommittedToSameGapIsAssign(t *testing.T) {
	cfg := DefaultConfig()
	c := cand("c1", "95", true, true)
	c.CommittedRequirementID = "req-gap" // already committed to this very gap
	c.CommittedPriority = dec("1")
	recs := ClassifyForGap(cfg, gapCtx(1, "2"), []ScoredCandidate{c})
	if countAction(recs, ActionAssign) != 1 || countAction(recs, ActionReassign) != 0 {
		t.Fatalf("a candidate committed to the gap itself is an assign, not a reassign: %+v", recs)
	}
}

func TestClassifyReskillGating(t *testing.T) {
	cfg := DefaultConfig()
	base := cand("c1", "60", true, true)
	base.Reskill = &ReskillFact{HeldSkill: "Python", MissingSkill: "Go", Distance: dec("0.30")}
	if countAction(ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{base}), ActionReskill) != 1 {
		t.Fatalf("a below floor, clearance satisfied, available candidate with an adjacency path must reskill")
	}
	// No adjacency path -> no reskill.
	noAdj := cand("c2", "60", true, true)
	if len(ClassifyForGap(cfg, gapCtx(0, "1"), []ScoredCandidate{noAdj})) != 0 {
		t.Fatalf("no adjacency path means no reskill and no row")
	}
	// Clearance not satisfied -> no reskill even with an adjacency path (clearance is a hard gate).
	noClear := cand("c3", "60", true, false)
	noClear.Reskill = &ReskillFact{HeldSkill: "Python", MissingSkill: "Go", Distance: dec("0.30")}
	if countAction(ClassifyForGap(cfg, gapCtx(0, "1"), []ScoredCandidate{noClear}), ActionReskill) != 0 {
		t.Fatalf("a reskill must require the clearance gate to be satisfied")
	}
}

func TestClassifySource(t *testing.T) {
	cfg := DefaultConfig()
	// Three open slots, one assignable -> one source note for the remaining two.
	recs := ClassifyForGap(cfg, gapCtx(3, "1"), []ScoredCandidate{cand("c1", "92", true, true)})
	if countAction(recs, ActionSource) != 1 {
		t.Fatalf("an under filled gap must emit exactly one source note")
	}
	var src *Recommendation
	for i := range recs {
		if recs[i].Action == ActionSource {
			src = &recs[i]
		}
	}
	if src.CandidateID != "" {
		t.Fatalf("a source recommendation must name no candidate, got %q", src.CandidateID)
	}
	if src.Evidence.OpenSlots == nil || *src.Evidence.OpenSlots != 2 {
		t.Fatalf("source must record the remaining open slots (2), got %+v", src.Evidence.OpenSlots)
	}
	if !src.Confidence.Equal(decimal.NewFromInt(1)) {
		t.Fatalf("a source note is a deterministic fact, confidence 1, got %s", src.Confidence)
	}
	// Enough assignable for the slots -> no source.
	full := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "92", true, true), cand("c2", "88", true, true)})
	if countAction(full, ActionSource) != 0 {
		t.Fatalf("a fully coverable gap must not emit a source note")
	}
}

func TestClassifyRankingDeterministic(t *testing.T) {
	cfg := DefaultConfig()
	in := []ScoredCandidate{
		cand("c-low", "80", true, true),
		cand("c-hi", "95", true, true),
		cand("c-mid-b", "85", true, true),
		cand("c-mid-a", "85", true, true), // tie with c-mid-b, breaks by candidate id asc
	}
	recs := ClassifyForGap(cfg, gapCtx(4, "1"), in)
	wantOrder := []string{"c-hi", "c-mid-a", "c-mid-b", "c-low"}
	got := make([]string, 0, len(wantOrder))
	for _, r := range recs {
		if r.Action == ActionAssign {
			got = append(got, r.CandidateID)
		}
	}
	for i, w := range wantOrder {
		if got[i] != w {
			t.Fatalf("ranking not deterministic: got %v want %v", got, wantOrder)
		}
		if recs[i].Rank != i+1 {
			t.Fatalf("ranks must be 1 based sequential, got %d at index %d", recs[i].Rank, i)
		}
	}
}

func TestClassifyUnavailableQualifiedIsNotAssigned(t *testing.T) {
	cfg := DefaultConfig()
	recs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "95", false, true)})
	if countAction(recs, ActionAssign) != 0 {
		t.Fatalf("an unavailable candidate must not be assigned")
	}
	// The slot stays open, so a source note is emitted.
	if countAction(recs, ActionSource) != 1 {
		t.Fatalf("the unfilled slot must surface as a source note")
	}
}