import { describe, expect, it } from "vitest";
import {
  applyAssistantDeepTurnGroundingEligibility,
  applyAssistantDeepTurnRetrievalGuards
} from "../src/services/assistantDeepTurnGuardRuntimeAdapter";

describe("assistant deep turn guard runtime adapter", () => {
  it("runs retrieval guards in expected order and threads outputs", () => {
    const callOrder: string[] = [];
    const seedResults = [{ fragment_id: "F1" }] as any[];
    const afterPolarity = [{ fragment_id: "P1" }] as any[];
    const afterTargeted = [{ fragment_id: "T1" }] as any[];
    const afterGate = [{ fragment_id: "G1" }] as any[];

    const output = applyAssistantDeepTurnRetrievalGuards({
      retrievalResults: seedResults as any,
      domainPolarityGuardInitial: { applied: true, polarity: "supplier_payable" } as any,
      claimAnchorAudit: { claim_type: "prove_settlement_closure_state" } as any,
      temporalGuard: { temporal_guard_outcome: "passed", temporal_guard_basis: "none" } as any,
      focusDomainForGuards: "settlements_60_62" as any,
      companyAnchors: { accounts: ["60.01"] } as any,
      userMessage: "check settlements",
      applyDomainPolarityGuardFn: ((input: Record<string, unknown>) => {
        callOrder.push("polarity");
        expect(input.retrievalResults).toBe(seedResults);
        return {
          retrievalResults: afterPolarity,
          audit: {
            applied: true,
            polarity: "supplier_payable",
            outcome: "passed",
            reason_codes: []
          }
        };
      }) as any,
      applyTargetedEvidenceFn: ((input: Record<string, unknown>) => {
        callOrder.push("targeted");
        expect(input.retrievalResults).toBe(afterPolarity);
        return {
          retrievalResults: afterTargeted,
          audit: {
            targeted_evidence_hit_rate: 0.5,
            reason_codes: []
          }
        };
      }) as any,
      applyEvidenceAdmissibilityGateFn: ((input: Record<string, unknown>) => {
        callOrder.push("gate");
        expect(input.retrievalResults).toBe(afterTargeted);
        expect(input.polarity).toBe("supplier_payable");
        expect(input.userMessage).toBe("check settlements");
        return {
          retrievalResults: afterGate,
          audit: {
            admissible_evidence_count: 2,
            reason_codes: []
          }
        };
      }) as any
    });

    expect(callOrder).toEqual(["polarity", "targeted", "gate"]);
    expect(output.retrievalResults).toBe(afterGate);
    expect(output.polarityGuardResult.retrievalResults).toBe(afterPolarity);
    expect(output.targetedEvidenceResult.retrievalResults).toBe(afterTargeted);
    expect(output.evidenceGateResult.retrievalResults).toBe(afterGate);
  });

  it("evaluates grounding eligibility and applies status overlay", () => {
    const callOrder: string[] = [];
    const groundingCheckBase = {
      status: "grounded_positive",
      reasons: ["base"],
      route_subject_match: true
    };

    const output = applyAssistantDeepTurnGroundingEligibility({
      groundingCheckBase,
      temporalGuard: { temporal_guard_outcome: "passed", temporal_guard_basis: "none" } as any,
      polarityAudit: { applied: true, outcome: "passed", polarity: "supplier_payable" } as any,
      evidenceAudit: { admissible_evidence_count: 0 } as any,
      claimAnchorAudit: { claim_anchor_resolution_rate: 1, missing_anchors: [], required_anchors: [] } as any,
      targetedEvidenceHitRate: 0,
      businessScopeResolved: ["company_specific_accounting"],
      evaluateGroundedAnswerEligibilityFn: ((input: Record<string, unknown>) => {
        callOrder.push("eligibility");
        expect(input.targetedEvidenceHitRate).toBe(0);
        return {
          eligible: false,
          temporal_passed: true,
          eligibility_time_basis: "none",
          business_scope_passed: true,
          polarity_passed: true,
          claim_anchors_passed: true,
          claim_anchor_resolution_rate: 1,
          missing_required_anchors: 0,
          admissible_evidence_count: 0,
          critical_contradiction: false,
          outcome: "limited_or_insufficient_evidence",
          grounding_mode: "limited_or_insufficient_evidence",
          reason_codes: ["admissible_evidence_count_zero"]
        };
      }) as any,
      applyEligibilityToGroundingCheckFn: ((check: Record<string, unknown>, eligibility: Record<string, unknown>) => {
        callOrder.push("overlay");
        expect(check.status).toBe("grounded_positive");
        expect(eligibility.eligible).toBe(false);
        return {
          ...check,
          status: "no_grounded_answer",
          reasons: ["base", "not_enough_evidence"]
        };
      }) as any
    });

    expect(callOrder).toEqual(["eligibility", "overlay"]);
    expect(output.groundedAnswerEligibilityGuard.eligible).toBe(false);
    expect(output.groundingCheck.status).toBe("no_grounded_answer");
    expect(output.groundingCheck.reasons).toEqual(["base", "not_enough_evidence"]);
  });
});