//go:build integration

// MAG display order re ranker LIVE wiring integration. Proves that slateMATCH GenerateSlate actually APPLIES the
// champion display order re ranker to the member order in the product: under the prior only champion the order
// is the frozen engine order, and once a LEARNED re ranker is promoted the SAME slate comes back in the learned
// order, with the frozen engine total_score of every member UNCHANGED (the re ranker permutes the display order,
// never a score; a human still approves every member).
//
// Run: go test -tags=integration ./internal/integration/ -run MAGRerankerLive -v
// Env: MM_APP_DSN, MM_MIGRATOR_DSN.
package integration

import (
	"context"
	"testing"

	"github.com/missionworkforce/missionmatch/internal/modules/matching"
	"github.com/missionworkforce/missionmatch/internal/platform/database/dbgen"
	"github.com/missionworkforce/missionmatch/internal/platform/magstore"
)

func TestMAGRerankerLiveGenerateSlateAppliesTheChampionOrder(t *testing.T) {
	modelKey := magstore.RerankModelKey
	const priorOnlyVersion = 1
	ctx := context.Background()

	// Reset the re ranker champion to the prior only engine order v1, and restore it on cleanup.
	if _, err := magstore.PromoteChampion(ctx, migrator, modelKey, priorOnlyVersion); err != nil {
		t.Fatalf("reset reranker champion: %v", err)
	}
	t.Cleanup(func() {
		if _, cerr := magstore.PromoteChampion(ctx, migrator, modelKey, priorOnlyVersion); cerr != nil {
			t.Logf("cleanup: could not restore prior only reranker champion: %v", cerr)
		}
	})

	org := seedOrg(t)
	// A requirement at secret clearance. Two candidates identical except clearance: the high one exceeds (a 100
	// clearance sub score, so the higher engine total), the low one is below (a 0 clearance sub score). The
	// engine orders the high clearance candidate first.
	req, err := dbgen.New(migrator).CreateRequirement(ctx, dbgen.CreateRequirementParams{
		OrganizationID: org, Title: "Reranker Live Role", RequiredLevel: "secret", RequiredPoly: "none",
	})
	if err != nil {
		t.Fatalf("create requirement: %v", err)
	}
	high := seedCandidate(t, org, "ts_sci", "active", true)      // exceeds secret => clearance 100
	low := seedCandidate(t, org, "confidential", "active", true) // below secret => clearance 0

	svc := matching.NewService(appDB, nil, nil)

	// Under the prior only champion the display order is the engine order: the high clearance candidate first.
	base, err := svc.GenerateSlate(ctxOrg(org), matching.GenerateSlateInput{RequirementID: req.ID, Name: "base"})
	if err != nil {
		t.Fatalf("generate base slate: %v", err)
	}
	if len(base.Members) != 2 {
		t.Fatalf("expected 2 members, got %d", len(base.Members))
	}
	if base.Members[0].CandidateID != high.ID.String() {
		t.Fatalf("the engine order must rank the high clearance candidate first, got %s", base.Members[0].CandidateID)
	}
	baseTotals := map[string]string{}
	for _, m := range base.Members {
		baseTotals[m.CandidateID] = m.Total
	}
	t.Logf("engine order: 1=%s 2=%s", base.Members[0].CandidateID, base.Members[1].CandidateID)

	// Promote a LEARNED re ranker that inverts clearance (weight minus one on clearance, zero elsewhere), so its
	// utility ranks the LOW clearance candidate first, the opposite of the engine.
	version, err := magstore.WriteChallenger(ctx, migrator, modelKey, magstore.Challenger{
		Family:       "pairwise_logistic",
		OutputKind:   "display_order",
		FeatureNames: magstore.RerankFeatureOrder,
		Intercept:    0,
		Coeffs:       []float64{-1, 0, 0, 0, 0, 0}, // minus one on clearance_score, the rest zero
		Notes:        "test: clearance inverting re ranker for the live wiring proof",
	})
	if err != nil {
		t.Fatalf("write learned challenger: %v", err)
	}
	if _, err := magstore.PromoteChampion(ctx, migrator, modelKey, version); err != nil {
		t.Fatalf("promote learned reranker: %v", err)
	}

	// Under the learned champion the SAME slate comes back in the learned order: the low clearance candidate now
	// surfaces first, the display order flipped.
	learned, err := svc.GenerateSlate(ctxOrg(org), matching.GenerateSlateInput{RequirementID: req.ID, Name: "learned"})
	if err != nil {
		t.Fatalf("generate learned slate: %v", err)
	}
	if learned.Members[0].CandidateID != low.ID.String() {
		t.Fatalf("the learned re ranker must surface the low clearance candidate first, got %s", learned.Members[0].CandidateID)
	}
	if learned.Members[0].Rank != 1 {
		t.Fatalf("the top member must carry display rank 1, got %d", learned.Members[0].Rank)
	}
	t.Logf("learned order: 1=%s 2=%s (the display order flipped)", learned.Members[0].CandidateID, learned.Members[1].CandidateID)

	// The frozen engine total_score of every member is UNCHANGED between the two orders: the re ranker permuted
	// the display order only, never a score.
	for _, m := range learned.Members {
		if base := baseTotals[m.CandidateID]; base != m.Total {
			t.Errorf("candidate %s total changed from %s to %s; the re ranker must never change the engine score", m.CandidateID, base, m.Total)
		}
	}
}