import { describe, expect, it } from "vitest";
import { resolveAddressCapabilityRouteDecision } from "../src/services/addressCapabilityPolicy";
import {
  getAssistantCapabilityContract,
  getAssistantCapabilityContractByIntent,
  getAssistantTransitionContract,
  listAssistantTransitionContracts,
  listInventoryCapabilityContracts
} from "../src/services/assistantRuntimeContractRegistry";
import { resolveAssistantRuntimeContractShadow } from "../src/services/assistantRuntimeContractResolver";

describe("assistant runtime contract registry", () => {
  it("declares the architecture turnaround transition set T1-T10", () => {
    const transitions = listAssistantTransitionContracts();
    expect(transitions.map((item) => item.transition_id)).toEqual(["T1", "T2", "T3", "T4", "T5", "T6", "T7", "T8", "T9", "T10"]);

    const ids = new Set(transitions.map((item) => item.transition_id));
    expect(ids.size).toBe(10);
    expect(transitions.every((item) => item.schema_version === "assistant_runtime_contracts_v1")).toBe(true);
  });

  it("keeps selected-object action follow-ups object-scoped instead of generic-chat scoped", () => {
    const transition = getAssistantTransitionContract("T4");
    expect(transition).not.toBeNull();
    expect(transition?.required_prior_state).toContain("selected_object_frame_state");
    expect(transition?.allowed_carryover_depth).toBe("object_only");
    expect(transition?.forbidden_carryover).toContain("generic_chat_fallback");
    expect(transition?.forbidden_carryover).toContain("object_focus_reset");
  });

  it("declares meta follow-up as answer-object reuse, not blind exact-route replay", () => {
    const transition = getAssistantTransitionContract("T8");
    expect(transition).not.toBeNull();
    expect(transition?.required_prior_state).toEqual(["answer_context_state", "coverage_gate_state"]);
    expect(transition?.allowed_carryover_depth).toBe("meta_only");
    expect(transition?.state_mutations).toContain("reuse_answer_object_without_blind_replay");
    expect(transition?.forbidden_carryover).toContain("blind_exact_route_replay");
    expect(transition?.expected_answer_mode).toBe("meta");
  });

  it("keeps pilot inventory capability ids aligned with the current address capability policy", () => {
    for (const contract of listInventoryCapabilityContracts()) {
      for (const intent of contract.intent_ids) {
        const decision = resolveAddressCapabilityRouteDecision(intent);
        expect(decision.capability_id).toBe(contract.capability_id);
        expect(decision.capability_route_mode).toBe("exact");
      }
    }
  });

  it("declares root inventory snapshot as root-capable and focus-object-free", () => {
    const contract = getAssistantCapabilityContract("confirmed_inventory_on_hand_as_of_date");
    expect(contract).not.toBeNull();
    expect(contract?.entry_modes).toEqual(["root_entry", "root_followup", "clarification_resume"]);
    expect(contract?.supported_transition_classes).toEqual(["T1", "T2", "T7"]);
    expect(contract?.requires_focus_object).toBe(false);
    expect(contract?.result_shape).toBe("item_list_with_quantity_cost_warehouse_organization");
    expect(contract?.required_scenario_families).toContain("colloquial");
  });

  it("declares selected-item provenance as focus-object and bundle-aware", () => {
    const contract = getAssistantCapabilityContractByIntent("inventory_purchase_provenance_for_item");
    expect(contract?.capability_id).toBe("inventory_inventory_purchase_provenance_for_item");
    expect(contract?.requires_focus_object).toBe(true);
    expect(contract?.accepted_focus_object_kinds).toEqual(["inventory_item", "item"]);
    expect(contract?.supported_transition_classes).toEqual(["T3", "T4", "T5", "T7"]);
    expect(contract?.required_anchors).toEqual(["item"]);
    expect(contract?.bundle_reuse_policy).toBe("provenance_bundle_preferred");
    expect(contract?.anchor_admissibility_rules).toContain("confirmed_focus_object_beats_semantic_hint");
    expect(contract?.required_scenario_families).toContain("ui_selected_object_colloquial");
    expect(contract?.required_scenario_families).toContain("pronoun_followup");
  });

  it("keeps truth semantics outside answer wording for every pilot inventory capability", () => {
    for (const contract of listInventoryCapabilityContracts()) {
      expect(contract.coverage_gate_behavior).toBe("partial_or_blocked_if_evidence_insufficient");
      expect(contract.truth_mode_fallbacks).toEqual(["limited", "clarification_required", "unsupported"]);
      expect(contract.blocked_reason_codes).toEqual(
        expect.arrayContaining(["missing_anchor", "route_expectation_failure", "execution_error", "insufficient_evidence"])
      );
      expect(contract.route_expectation_failure_behavior).toBe("blocked_route_expectation_failure");
      expect(contract.execution_error_behavior).toBe("blocked_execution_error");
    }
  });

  it("resolves shadow contract ids for selected-object provenance debug", () => {
    const decision = resolveAssistantRuntimeContractShadow({
      addressDebug: {
        detected_intent: "inventory_purchase_provenance_for_item",
        capability_id: "inventory_inventory_purchase_provenance_for_item",
        rows_matched: 1,
        route_expectation_status: "matched"
      },
      addressRuntimeMeta: {
        dialogContinuationContract: {
          decision: "continue_previous",
          target_intent: "inventory_purchase_provenance_for_item"
        }
      },
      groundingStatus: "grounded"
    });

    expect(decision.transition_contract_id).toBe("T4");
    expect(decision.capability_contract_id).toBe("inventory_inventory_purchase_provenance_for_item");
    expect(decision.truth_gate_contract_status).toBe("full_confirmed");
    expect(decision.carryover_eligibility).toBe("object_only");
  });

  it("resolves meta follow-up and blocked route expectation in shadow mode", () => {
    const metaDecision = resolveAssistantRuntimeContractShadow({
      addressRuntimeMeta: {
        toolGateReason: "assistant_capability_query_detected",
        orchestrationContract: {
          hard_meta_mode: "capability",
          address_intent: "inventory_on_hand_as_of_date"
        }
      }
    });
    expect(metaDecision.transition_contract_id).toBe("T8");
    expect(metaDecision.capability_contract_id).toBe("confirmed_inventory_on_hand_as_of_date");
    expect(metaDecision.carryover_eligibility).toBe("meta_only");

    const blockedDecision = resolveAssistantRuntimeContractShadow({
      addressDebug: {
        capability_id: "confirmed_inventory_on_hand_as_of_date",
        route_expectation_status: "mismatch"
      },
      groundingStatus: "route_mismatch_blocked"
    });
    expect(blockedDecision.transition_contract_id).toBe("T10");
    expect(blockedDecision.truth_gate_contract_status).toBe("blocked_route_expectation_failure");
    expect(blockedDecision.carryover_eligibility).toBe("none");
  });

  it("classifies temporal limitations as a distinct truth gate status", () => {
    const decision = resolveAssistantRuntimeContractShadow({
      addressDebug: {
        capability_id: "confirmed_inventory_on_hand_as_of_date",
        temporal_guard_outcome: "ambiguous_limited"
      },
      groundingStatus: "partial"
    });

    expect(decision.truth_gate_contract_status).toBe("limited_temporal_or_contextual");
  });
});