import { describe, expect, it, vi } from "vitest";
import { runAssistantCoverageGroundingPipeline } from "../src/services/assistantOrchestrationRuntimeAdapter";

describe("assistant orchestration runtime adapter", () => {
  it("runs requirement -> coverage -> grounding pipeline in order", () => {
    const requirementExtraction = {
      requirements: [
        {
          requirement_id: "R1",
          source_fragment_id: "F1",
          requirement_text: "req",
          subject_tokens: ["account_60"],
          status: "covered" as const,
          route: "hybrid_store_plus_live"
        }
      ],
      byFragment: new Map<string, string[]>([["F1", ["R1"]]])
    };
    const coverageEvaluation = {
      requirements: requirementExtraction.requirements,
      coverage: {
        requirements_total: 1,
        requirements_covered: 1,
        requirements_uncovered: [],
        requirements_partially_covered: [],
        clarification_needed_for: [],
        out_of_scope_requirements: []
      }
    };
    const groundingCheck = {
      status: "grounded" as const,
      route_subject_match: true,
      missing_requirements: [],
      reasons: [],
      why_included_summary: ["why"],
      selection_reason_summary: ["selection"]
    };

    const extractRequirements = vi.fn(() => requirementExtraction);
    const evaluateCoverage = vi.fn(() => coverageEvaluation);
    const checkGrounding = vi.fn(() => groundingCheck);

    const output = runAssistantCoverageGroundingPipeline({
      routeSummary: null,
      normalized: null,
      userMessage: "test",
      retrievalResults: [],
      extractRequirements,
      evaluateCoverage,
      checkGrounding
    });

    expect(extractRequirements).toHaveBeenCalledTimes(1);
    expect(evaluateCoverage).toHaveBeenCalledTimes(1);
    expect(checkGrounding).toHaveBeenCalledTimes(1);
    expect(output.requirementExtraction).toBe(requirementExtraction);
    expect(output.coverageEvaluation).toBe(coverageEvaluation);
    expect(output.groundingCheckBase).toBe(groundingCheck);
  });

  it("reuses precomputed requirement extraction when provided", () => {
    const precomputed = {
      requirements: [],
      byFragment: new Map<string, string[]>()
    };
    const extractRequirements = vi.fn(() => {
      throw new Error("extractRequirements should not be called");
    });
    const evaluateCoverage = vi.fn(() => ({
      requirements: [],
      coverage: {
        requirements_total: 0,
        requirements_covered: 0,
        requirements_uncovered: [],
        requirements_partially_covered: [],
        clarification_needed_for: [],
        out_of_scope_requirements: []
      }
    }));
    const checkGrounding = vi.fn(() => ({
      status: "no_grounded_answer" as const,
      route_subject_match: true,
      missing_requirements: [],
      reasons: [],
      why_included_summary: [],
      selection_reason_summary: []
    }));

    const output = runAssistantCoverageGroundingPipeline({
      routeSummary: null,
      normalized: null,
      userMessage: "test",
      retrievalResults: [],
      requirementExtraction: precomputed,
      extractRequirements,
      evaluateCoverage,
      checkGrounding
    });

    expect(extractRequirements).not.toHaveBeenCalled();
    expect(evaluateCoverage).toHaveBeenCalledWith(precomputed.requirements, []);
    expect(output.requirementExtraction).toBe(precomputed);
  });
});