import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";

import { setOperatorCredential, clearOperatorCredential } from "../lib/api";
import { CapabilityWorkspace } from "./CapabilityWorkspace";
import type { CapabilityDeployment, SchedulerBudget } from "../types";

const deployment: CapabilityDeployment = {
  id: "deployment-1", capability: "rag.embedding", contract_version: 1,
  deployment_candidate_id: "candidate-1", production_approval_id: "approval-1",
  artifact_set_id: "artifact-set-1", runtime_profile_id: "profile-1",
  compute_node_id: "node-1", accelerator_id: "gpu-1",
  embedding_space: { id: "space-1", identity_digest: "a".repeat(64), dimension: 1024, normalized: true, migration_class: "requires_reindex", identity_facts: {}, created_at: "2026-08-25T12:00:00Z" },
  resource_envelope: { id: "envelope-1", runtime_probe_id: "probe-1", accelerator_kind: "NVIDIA RTX 4080 SUPER", accelerator_uuid: "GPU-test", environment_fingerprint: "b".repeat(64), concurrency: 1, batch_size: 8, max_sequence_length: 8192, baseline_vram_bytes: 1_100_000_000, resident_vram_bytes: 1_500_000_000, peak_vram_bytes: 2_700_000_000, required_vram_bytes: 1_600_000_000, cold_load_time_ms: 3690, inference_latency_ms: 1203, stale: false },
  residency: { id: "residency-1", state: "warm", worker_instance_id: "worker-1", load_count: 1, active_requests: 0, measured_resident_vram_bytes: 1_500_000_000, external_baseline_vram_bytes: 636_000_000, health: { functional: true }, resident_since: "2026-08-25T12:00:00Z", last_used_at: "2026-08-25T12:01:00Z" },
  channel: "stable", status: "stable", production: true, health_status: "healthy",
  routing_weight: 100, fallback_policy: {}, residency_policy: "keep_warm",
  keep_warm_seconds: 900, max_concurrency: 1, max_queue_depth: 16,
  config_fingerprint: "c".repeat(64), provenance: { runtime_probe_id: "probe-1", compatibility_assessment_id: "assessment-1" },
  rollback_policy: { mode: "drain_to_unavailable" }, promoted_at: "2026-08-25T12:00:00Z", created_at: "2026-08-25T12:00:00Z",
};

const budget: SchedulerBudget = {
  compute_node_id: "node-1", node_name: "GPU Node", accelerator_id: "gpu-1",
  accelerator_uuid: "GPU-test", accelerator_name: "NVIDIA RTX 4080 SUPER",
  total_vram_bytes: 17_171_480_576, observed_used_vram_bytes: 2_200_000_000,
  external_vram_bytes: 700_000_000, resident_vram_bytes: 1_500_000_000,
  leased_vram_bytes: 0, safety_reserve_bytes: 1_073_741_824,
  schedulable_free_vram_bytes: 13_897_738_752, pressure: false, observed_at: "2026-08-25T12:00:00Z",
  pressure_state: "NORMAL", attribution_confidence: "KNOWN", invariant_delta_bytes: 0,
  policy_revision: "m10-v1",
};

function mockServing(options: { deployments?: CapabilityDeployment[]; invokeError?: boolean; calls?: string[] } = {}): void {
  vi.stubGlobal("fetch", vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
    const url = String(input);
    let payload: unknown = [];
    let status = 200;
    if (url.endsWith("/api/v1/capabilities")) payload = [{ key: "rag.embedding", version: 1, description: "Local retrieval", stable_deployment: null, contract: { capability: "rag.embedding", version: 1, description: "Local retrieval", modalities: { input: ["text"], output: ["vector"] }, upgrade_class: "requires_reindex", vector: { dimensionality: 1024, normalized: true, cross_deployment_compatible: false }, slo: {}, privacy: { classification: "confidential", allow_persistence: false, allow_logging_payloads: false, allow_network_egress: false }, resources: { accelerator_required: true, cpu_fallback_allowed: false }, fallback: { allowed: false, mode: "hard_fail" }, production_priority: "production", default_residency: "keep_warm", estate: { category: "RAG", purpose: "Local retrieval", stability: "stable", resource_class: "MEDIUM", evaluation_type: "retrieval", consumers: [] } } }];
    if (url.endsWith("/api/v1/capability-deployments")) payload = options.deployments ?? [deployment];
    if (url.endsWith("/api/v1/capability-estate")) payload = [
      { capability: "rag.embedding", version: 1, category: "RAG", purpose: "Local retrieval", declared_stability: "stable", operational_state: options.deployments?.length === 0 ? "not_deployed" : "stable", current_deployment_id: "deployment-1", model: "Nomic", revision: "a".repeat(40), runtime: "sentence_transformers", node: "node-1", resource_class: "MEDIUM", measured_required_vram_bytes: 1_600_000_000, consumers: ["examplerag"], privacy_class: "confidential", evaluation_type: "retrieval", evaluation_state: "completed" },
      { capability: "document.ocr", version: 1, category: "DOCUMENT", purpose: "Local OCR", declared_stability: "experimental", operational_state: "not_deployed", resource_class: "MEDIUM", consumers: ["examplerag"], privacy_class: "restricted", evaluation_type: "ocr", evaluation_state: "not_evaluated" },
      { capability: "vision.embedding", version: 1, category: "VISION", purpose: "Visual retrieval", declared_stability: "experimental", operational_state: "not_deployed", resource_class: "HEAVY", consumers: ["examplevision"], privacy_class: "confidential", evaluation_type: "visual-retrieval", evaluation_state: "not_evaluated" },
      { capability: "speech.transcription", version: 1, category: "AUDIO", purpose: "Local transcription", declared_stability: "experimental", operational_state: "not_deployed", resource_class: "HEAVY", consumers: [], privacy_class: "restricted", evaluation_type: "asr", evaluation_state: "not_evaluated" },
    ];
    if (url.endsWith("/api/v1/scheduler")) payload = [budget];
    if (url.endsWith("/api/v1/deployment-candidates")) payload = [];
    if (url.includes("/api/v1/gateway/requests")) payload = [{ request_id: "request-1", capability: "rag.embedding@1", client: "acceptance", status: "completed", cold: false, queue_time_ms: 1, total_latency_ms: 20, created_at: "2026-08-25T12:00:00Z" }];
    if (url.endsWith("/api/v1/admin/production-approvals")) payload = [];
    if (url.includes("/api/v1/admin/scheduler/placements")) payload = [];
    if (url.endsWith("/api/v1/admin/scheduler/policy")) payload = { revision: "m10-v1", active: true, configuration: { lab_paused: false }, created_at: "2026-08-25T12:00:00Z" };
    if (url.includes("/unload")) { options.calls?.push(url); payload = { unloaded: true }; }
    if (url.endsWith("/api/v1/admin/service-clients") && init?.method !== "POST") payload = [];
    if (url.endsWith("/api/v1/admin/service-clients") && init?.method === "POST") payload = { id: "client-1", name: "modelforge-m5-acceptance", status: "active", allowed_capabilities: ["rag.embedding@1"], requests_per_minute: 60, max_concurrent_requests: 1, credential_prefix: "mf_test", created_at: "2026-08-25T12:00:00Z", credential: "mf_test_one_time_secret" };
    if (url.endsWith("/api/v1/capabilities/rag.embedding@1/invoke")) {
      if (options.invokeError) { status = 429; payload = { error: { message: "rate limit exceeded", details: { failure_code: "RATE_LIMITED" } } }; }
      else payload = { capability: "rag.embedding@1", dimension: 1024, normalized: true, embedding_space_id: "space-1", data: [Array(1024).fill(0.03125)], request_id: "request-2", execution: { cold: false, node: "GPU Node", residency: "warm", load_count: 1, timings: { gateway_ms: 1, queue_ms: 0, load_ms: 0, inference_ms: 12, total_ms: 14 } }, usage: { input_count: 1, input_tokens: 4 } };
    }
    return Promise.resolve(new Response(JSON.stringify(payload), { status }));
  }));
}

afterEach(() => { clearOperatorCredential(); cleanup(); vi.unstubAllGlobals(); vi.restoreAllMocks(); });

describe("M5 capability operations UI", () => {
  it("shows the healthy stable capability and warm residency", async () => {
    mockServing(); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    expect(await screen.findByText("rag.embedding@1")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Inspect rag.embedding@1" }));
    fireEvent.click(screen.getByRole("button", { name: "Inspect deployment deployment-1" }));
    expect(screen.getByText("healthy")).toBeInTheDocument();
    expect(screen.getAllByText("warm").length).toBeGreaterThan(0);
    expect(screen.getAllByText("requires_reindex").length).toBeGreaterThan(0);
  });

  it("shows unavailable honestly when promotion has not happened", async () => {
    mockServing({ deployments: [] }); render(<CapabilityWorkspace onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("button", { name: "Inspect rag.embedding@1" }));
    expect(screen.getByText(/No deployment records exist/)).toBeInTheDocument();
  });

  it("renders real scheduler budget categories including external usage", async () => {
    mockServing(); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "scheduler" }));
    expect(screen.getByText(/GPU SCHEDULING COCKPIT · GPU Node/)).toBeInTheDocument();
    expect(screen.getByText("External / unmanaged")).toBeInTheDocument();
    expect(screen.getByText("Safety reserve")).toBeInTheDocument();
    expect(screen.getByText("Schedulable free")).toBeInTheDocument();
  });

  it("shows a newly created credential exactly in the one-time result", async () => {
    mockServing(); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "clients" }));
    fireEvent.click(await screen.findByRole("button", { name: /Create one-time credential/ }));
    expect(await screen.findByText("mf_test_one_time_secret")).toBeInTheDocument();
    expect(screen.getByText(/Only its hash is stored/)).toBeInTheDocument();
  });

  it("invokes by capability without asking for a concrete model name", async () => {
    mockServing(); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "playground" }));
    expect(screen.queryByLabelText(/model name/i)).not.toBeInTheDocument();
    expect(screen.getByRole("option", { name: "document.ocr@1" })).toBeInTheDocument();
    expect(screen.getByRole("option", { name: "vision.embedding@1" })).toBeInTheDocument();
    expect(screen.getByRole("option", { name: "speech.transcription@1" })).toBeInTheDocument();
    fireEvent.change(screen.getByLabelText("Service credential"), { target: { value: "client-secret" } });
    fireEvent.click(screen.getByRole("button", { name: "Invoke capability" }));
    expect(await screen.findByText("1 × 1024 finite values")).toBeInTheDocument();
  });

  it("surfaces typed gateway failures", async () => {
    mockServing({ invokeError: true }); render(<CapabilityWorkspace onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "playground" }));
    fireEvent.change(screen.getByLabelText("Service credential"), { target: { value: "client-secret" } });
    fireEvent.click(screen.getByRole("button", { name: "Invoke capability" }));
    expect(await screen.findByText("rate limit exceeded (RATE_LIMITED)")).toBeInTheDocument();
  });
});

describe("Capability state read semantics", () => {
  it("shows a typed initial failure and retries instead of displaying an empty estate", async () => {
    mockServing();
    const normalFetch = fetch;
    let failFirstRead = true;
    vi.stubGlobal("fetch", vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
      if (failFirstRead && String(input).endsWith("/api/v1/capability-estate")) {
        failFirstRead = false;
        return Promise.resolve(new Response(JSON.stringify({ error: {
          code: "SERVICE_UNAVAILABLE", message: "Capability estate read failed", correlation_id: "corr-capability-123",
          details: { failure_code: "CAPABILITY_READ_UNAVAILABLE" },
        } }), { status: 503 }));
      }
      return normalFetch(input, init);
    }));

    const onError = vi.fn();
    render(<CapabilityWorkspace onError={onError} />);
    expect(await screen.findByRole("alert")).toHaveTextContent("Capability serving state is unavailable");
    expect(screen.getByText(/No authoritative snapshot was loaded/)).toBeInTheDocument();
    expect(screen.getByText("CAPABILITY_READ_UNAVAILABLE")).toBeInTheDocument();
    expect(screen.getByText("corr-capability-123")).toBeInTheDocument();
    expect(screen.getByText("Yes")).toBeInTheDocument();
    expect(screen.queryByText(/0 declared contracts/)).not.toBeInTheDocument();
    expect(screen.queryByText(/0 deployment records/)).not.toBeInTheDocument();
    expect(onError).not.toHaveBeenCalled();

    fireEvent.click(screen.getByRole("button", { name: "Retry capability state" }));
    expect(await screen.findByRole("heading", { name: "1 declared contracts" })).toBeInTheDocument();
    expect(screen.getByText("1 deployment records")).toBeInTheDocument();
  });

  it("discloses an offline polling failure with its stale snapshot and recovers on retry", async () => {
    mockServing();
    const pollCallbacks: Array<() => void> = [];
    vi.spyOn(window, "setInterval").mockImplementation(((callback: TimerHandler) => {
      if (typeof callback === "function") pollCallbacks.push(callback as () => void);
      return 1;
    }) as typeof window.setInterval);
    vi.spyOn(window, "clearInterval").mockImplementation(() => undefined);
    const onError = vi.fn();
    render(<CapabilityWorkspace onError={onError} />);
    expect(await screen.findByRole("heading", { name: "1 declared contracts" })).toBeInTheDocument();
    expect(pollCallbacks.length).toBeGreaterThan(0);

    const normalFetch = fetch;
    let failNextRead = true;
    let offlineRequestAttempted = false;
    vi.stubGlobal("fetch", vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
      if (failNextRead && String(input).endsWith("/api/v1/capability-estate")) {
        failNextRead = false;
        offlineRequestAttempted = true;
        return Promise.reject(new TypeError("Failed to fetch"));
      }
      return normalFetch(input, init);
    }));
    await act(async () => { pollCallbacks.forEach(callback => callback()); });
    expect(offlineRequestAttempted).toBe(true);
    expect(await screen.findByText("Capability data may be out of date")).toBeInTheDocument();
    expect(screen.getByText("OFFLINE")).toBeInTheDocument();
    expect(screen.getByText("NETWORK_UNAVAILABLE")).toBeInTheDocument();
    expect(screen.getByText("Retryable").parentElement).toHaveTextContent("Yes");
    expect(screen.getByRole("heading", { name: "1 declared contracts" })).toBeInTheDocument();
    expect(screen.getByText("1 deployment records")).toBeInTheDocument();
    expect(onError).not.toHaveBeenCalled();

    fireEvent.click(screen.getByRole("button", { name: "Retry capability state" }));
    await waitFor(() => expect(screen.queryByText("Capability data may be out of date")).not.toBeInTheDocument());
    expect(screen.getByRole("heading", { name: "1 declared contracts" })).toBeInTheDocument();
  });

  it("keeps manual refresh inside the public boundary when an admin-role session is inactive", async () => {
    mockServing();
    setOperatorCredential("viewer-session");
    const normalFetch = fetch;
    const requestedUrls: string[] = [];
    vi.stubGlobal("fetch", vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
      requestedUrls.push(String(input));
      return normalFetch(input, init);
    }));
    render(<CapabilityWorkspace role="viewer" onError={vi.fn()} />);
    expect(await screen.findByRole("heading", { name: "1 declared contracts" })).toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Refresh capability state" }));
    await waitFor(() => expect(requestedUrls.filter(url => url.endsWith("/api/v1/capability-deployments")).length).toBe(2));
    expect(requestedUrls.some(url => url.includes("/api/v1/admin/"))).toBe(false);
  });
});

describe("M18 closure · capability tabs and guarded residency unload", () => {
  async function openScheduler(calls: string[]) {
    mockServing({ calls });
    setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "scheduler" }));
    return await screen.findByRole("button", { name: "Unload idle" });
  }

  it("pairs each capability tab with the panel it controls", async () => {
    mockServing(); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    await screen.findByRole("tablist", { name: "Capability operations" });
    const selected = screen.getByRole("tab", { selected: true });
    const panel = screen.getByRole("tabpanel");
    expect(selected.getAttribute("aria-controls")).toBe(panel.getAttribute("id"));
    expect(panel.getAttribute("aria-labelledby")).toBe(selected.getAttribute("id"));
    const ids = screen.getAllByRole("tab").map((tab) => tab.getAttribute("id"));
    expect(new Set(ids).size).toBe(ids.length);
  });

  it("guards residency unload with the console safety dialog instead of a native confirm", async () => {
    const confirmSpy = vi.spyOn(window, "confirm");
    const calls: string[] = [];
    fireEvent.click(await openScheduler(calls));
    const dialog = await screen.findByRole("alertdialog", { name: "Unload idle residency?" });
    expect(dialog).toBeInTheDocument();
    // The native dialog is gone for good: it cannot carry this impact evidence.
    expect(confirmSpy).not.toHaveBeenCalled();
    expect(screen.getByText("rag.embedding@1")).toBeInTheDocument();
    expect(screen.getByText("Resident VRAM released")).toBeInTheDocument();
    expect(calls).toHaveLength(0);
    confirmSpy.mockRestore();
  });

  it("performs no mutation when the guarded unload is cancelled", async () => {
    const calls: string[] = [];
    fireEvent.click(await openScheduler(calls));
    await screen.findByRole("alertdialog", { name: "Unload idle residency?" });
    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
    await waitFor(() => expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument());
    expect(calls).toHaveLength(0);
  });

  it("requires acknowledgement and then unloads exactly once", async () => {
    const calls: string[] = [];
    fireEvent.click(await openScheduler(calls));
    await screen.findByRole("alertdialog", { name: "Unload idle residency?" });
    const confirm = screen.getByRole("button", { name: "Unload residency" });
    expect(confirm).toBeDisabled();
    fireEvent.click(screen.getByRole("checkbox", { name: /cold-load cost/ }));
    expect(confirm).toBeEnabled();
    fireEvent.click(confirm);
    fireEvent.click(confirm);
    expect(await screen.findByRole("status")).toHaveTextContent(/was unloaded/);
    // Exactly one mutation, even though confirm was clicked twice.
    expect(calls).toHaveLength(1);
  });

  it("dismisses the guarded unload with Escape", async () => {
    const calls: string[] = [];
    fireEvent.click(await openScheduler(calls));
    await screen.findByRole("alertdialog", { name: "Unload idle residency?" });
    fireEvent.keyDown(window, { key: "Escape" });
    await waitFor(() => expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument());
    expect(calls).toHaveLength(0);
  });
});


describe("Capability administrative role boundary", () => {
  it.each(["viewer", "operator"] as const)("does not fetch admin data or offer another credential for %s", async role => {
    mockServing(); setOperatorCredential("test-read-session"); render(<CapabilityWorkspace role={role} onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "promotion" }));
    expect(screen.getByText(/Read-only access/)).toBeInTheDocument();
    expect(screen.queryByLabelText("Operator API key")).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: /Record reviewed/ })).not.toBeInTheDocument();
    expect(vi.mocked(fetch).mock.calls.some(([url]) => String(url).includes("/admin/"))).toBe(false);
  });
  it("keeps a locked admin session read-only", async () => {
    mockServing(); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "promotion" }));
    expect(screen.getByText(/Read-only access/)).toBeInTheDocument();
    expect(vi.mocked(fetch).mock.calls.some(([url]) => String(url).includes("/admin/"))).toBe(false);
  });
  it("renders nullable embedding metadata without blocking access to promotion", async () => {
    mockServing({ deployments: [{ ...deployment, embedding_space: null }] }); setOperatorCredential("test-admin"); render(<CapabilityWorkspace role="admin" onError={vi.fn()} />);
    fireEvent.click(await screen.findByRole("tab", { name: "promotion" }));
    expect(screen.getByRole("heading", { name: "Promotion evidence" })).toBeInTheDocument();
  });
});


describe("Capability declaration refresh ordering", () => {
  async function pendingRefreshes() {
    mockServing();
    const onError = vi.fn();
    render(<CapabilityWorkspace onError={onError} />);
    fireEvent.click(await screen.findByRole("button", { name: "Inspect rag.embedding@1" }));
    await screen.findByRole("region", { name: "Details for rag.embedding@1" });
    const originalFetch = fetch;
    const pending: Array<(response: Response) => void> = [];
    vi.stubGlobal("fetch", vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
      if (String(input).endsWith("/api/v1/capabilities")) return new Promise<Response>(resolve => pending.push(resolve));
      return originalFetch(input, init);
    }));
    const refresh = () => fireEvent.click(screen.getByRole("button", { name: "Refresh capability state" }));
    const finish = async (index: number, success: boolean) => {
      await act(async () => {
        const response = success ? await originalFetch("/api/v1/capabilities") : new Response(JSON.stringify({ detail: "Declarations unavailable" }), { status: 503 });
        pending[index](response);
      });
    };
    return { refresh, finish, onError };
  }

  it("keeps the last good snapshot disclosed after a newer refresh failed", async () => {
    const { refresh, finish } = await pendingRefreshes();
    refresh(); refresh();
    await finish(1, false);
    expect(screen.getByText("Capability data may be out of date")).toBeInTheDocument();
    expect(screen.getByRole("region", { name: "Details for rag.embedding@1" })).toBeInTheDocument();
    await finish(0, true);
    expect(screen.getByText("Capability data may be out of date")).toBeInTheDocument();
    expect(screen.getByRole("region", { name: "Details for rag.embedding@1" })).toBeInTheDocument();
  });

  it("does not clear newer declarations or report an older refresh failure", async () => {
    const { refresh, finish, onError } = await pendingRefreshes();
    refresh(); refresh();
    await finish(1, true);
    onError.mockClear();
    await finish(0, false);
    expect(screen.getByRole("region", { name: "Details for rag.embedding@1" })).toBeInTheDocument();
    expect(onError).not.toHaveBeenCalled();
  });

  it("ignores a pending contract failure after the operator session changes", async () => {
    const { refresh, finish, onError } = await pendingRefreshes();
    refresh();
    setOperatorCredential("replacement-viewer-session");
    onError.mockClear();
    await finish(0, false);
    expect(onError).not.toHaveBeenCalled();
    expect(screen.getByRole("region", { name: "Details for rag.embedding@1" })).toBeInTheDocument();
  });
});