import { describe, expect, it } from "vitest";
import { buildAssistantDeepTurnExecutionPlan } from "../src/services/assistantDeepTurnPlanRuntimeAdapter";

describe("assistant deep turn plan runtime adapter", () => {
  it("builds execution plan through extraction, enforcement and guard hints in stable order", () => {
    const callOrder: string[] = [];
    const byFragment = new Map<string, string[]>([["F1", ["R1"]]]);
    const planInitial = [{ fragment_id: "F1", route: "store_canonical" }] as any[];
    const planAfterRbp = [{ fragment_id: "F1", route: "hybrid_store_plus_live" }] as any[];
    const planAfterFa = [{ fragment_id: "F1", route: "hybrid_store_plus_live", fa: true }] as any[];
    const planAfterTemporal = [{ fragment_id: "F1", route: "hybrid_store_plus_live", temporal: true }] as any[];
    const planAfterPolarity = [{ fragment_id: "F1", route: "hybrid_store_plus_live", temporal: true, polarity: true }] as any[];

    const output = buildAssistantDeepTurnExecutionPlan({
      routeSummary: { mode: "deterministic_v2", decisions: [] } as any,
      normalizedPayload: { schema_version: "normalized_query_v2_0_2" } as any,
      userMessage: "check tails",
      claimType: "prove_settlement_closure_state",
      temporalGuard: { temporal_guard_outcome: "passed" } as any,
      domainPolarityGuardInitial: { polarity: "supplier_payable" } as any,
      extractRequirements: () => {
        callOrder.push("extract");
        return {
          requirements: [{ requirement_id: "R1" }] as any[],
          byFragment
        };
      },
      toExecutionPlan: (_routeSummary, _normalizedPayload, _userMessage, requirementByFragment) => {
        callOrder.push("plan");
        expect(requirementByFragment).toBe(byFragment);
        return planInitial as any;
      },
      enforceRbpLiveRoutePlan: ({ executionPlan }) => {
        callOrder.push("rbp");
        expect(executionPlan).toBe(planInitial);
        return {
          executionPlan: planAfterRbp as any,
          audit: { rbp: true }
        };
      },
      enforceFaLiveRoutePlan: ({ executionPlan }) => {
        callOrder.push("fa");
        expect(executionPlan).toBe(planAfterRbp);
        return {
          executionPlan: planAfterFa as any,
          audit: { fa: true }
        };
      },
      applyTemporalHintToExecutionPlan: (executionPlan) => {
        callOrder.push("temporal");
        expect(executionPlan).toBe(planAfterFa);
        return planAfterTemporal as any;
      },
      applyPolarityHintToExecutionPlan: (executionPlan) => {
        callOrder.push("polarity");
        expect(executionPlan).toBe(planAfterTemporal);
        return planAfterPolarity as any;
      }
    });

    expect(callOrder).toEqual(["extract", "plan", "rbp", "fa", "temporal", "polarity"]);
    expect(output.requirementExtraction.byFragment).toBe(byFragment);
    expect(output.executionPlan).toBe(planAfterPolarity);
    expect(output.rbpRoutePlanEnforcement.audit).toEqual({ rbp: true });
    expect(output.faRoutePlanEnforcement.audit).toEqual({ fa: true });
  });

  it("preserves empty execution plan end-to-end", () => {
    const output = buildAssistantDeepTurnExecutionPlan({
      routeSummary: null,
      normalizedPayload: null as any,
      userMessage: "noop",
      claimType: "unknown",
      temporalGuard: null,
      domainPolarityGuardInitial: null,
      extractRequirements: () => ({
        requirements: [],
        byFragment: new Map()
      }),
      toExecutionPlan: () => [],
      enforceRbpLiveRoutePlan: ({ executionPlan }) => ({
        executionPlan,
        audit: { rbp: false }
      }),
      enforceFaLiveRoutePlan: ({ executionPlan }) => ({
        executionPlan,
        audit: { fa: false }
      }),
      applyTemporalHintToExecutionPlan: (executionPlan) => executionPlan,
      applyPolarityHintToExecutionPlan: (executionPlan) => executionPlan
    });

    expect(output.executionPlan).toEqual([]);
    expect(output.requirementExtraction.requirements).toEqual([]);
  });
});