import { extname, join, normalize } from "jsr:@std/path@1.1.4";

// Synthetic authority, real production shell and protocol transport. No UI overrides.
const port = Number(Deno.args[0]);
const buildRoot = Deno.args[1] ?? Deno.env.get("WEB_UX_BUILD_ROOT");
if (!Number.isInteger(port) || !buildRoot) {
  throw new Error("usage: console_live_fixture_server.ts <port> <build-root>");
}
const workspaceId = "console-live-review";
const runtimeId = "runtime-a";
const workerId = "worker-a";
const workerPath = `/api/w/${workspaceId}/runtimes/${runtimeId}/workers/${workerId}`;
const json = (value: unknown, status = 200) =>
  new Response(JSON.stringify(value), {
    status,
    headers: { "content-type": "application/json; charset=utf-8" },
  });
const invocations:
  import("../../../web/workspace/src/lib/generated/protocol.ts").FeatureInvocationDescriptor[] = [
    {
      identity: "fixture.review",
      name: "review",
      aliases: ["rv"],
      display_name: "Review",
      description: "Review a synthetic document without running a real Worker.",
      syntax: "parenthesized",
      arguments: [
        {
          name: "mode",
          position: 0,
          required: true,
          value_type: { kind: "enum", values: ["brief", "thorough"] },
          completion: { kind: "static", values: ["brief", "thorough"] },
          description: "Review detail",
        },
        {
          name: "count",
          position: 1,
          required: false,
          value_type: { kind: "integer" },
          completion: { kind: "none" },
          description: "Number of examples",
        },
        {
          name: "enabled",
          position: 2,
          required: false,
          value_type: { kind: "boolean" },
          completion: { kind: "static", values: ["true", "false"] },
          description: "Enable review",
        },
        {
          name: "path",
          position: 3,
          required: false,
          value_type: { kind: "worker_file" },
          completion: { kind: "worker_file" },
          description: "Worker document",
        },
      ],
    },
    {
      identity: "fixture.attach",
      name: "attach",
      aliases: [],
      display_name: "Attach file",
      description: "Stage a client file using the attachment adapter.",
      syntax: "parenthesized",
      arguments: [{
        name: "file",
        position: 0,
        required: true,
        value_type: { kind: "client_file" },
        completion: { kind: "client_file" },
      }],
      client_adapter: "attachment",
    },
  ];
const entries = [
  {
    kind: "message",
    entry_id: "user-1",
    timestamp: 1,
    provenance: "human_input",
    role: "user",
    content: [{ kind: "text", text: "Review the release notes before sending." }],
  },
  {
    kind: "message",
    entry_id: "assistant-1",
    timestamp: 2,
    provenance: "model_output",
    role: "assistant",
    content: [{
      kind: "text",
      text:
        "Ready. Choose a Feature and inspect its arguments, or attach a document. Nothing runs until Submit.",
    }],
  },
];
const session = {
  pending_submissions: { notification_count: 0, head_id: null, submissions: [] },
  entries,
};
const state = { last_command_id: 0, state: { kind: "idle" } };
const worker = {
  worker_id: workerId,
  runtime_id: runtimeId,
  resource_key: "W-901",
  display_name: "Console Live Fixture",
  label: "Console Live Fixture",
  availability: "observed",
  state: "idle",
  worker_state: state,
  retention_state: "active",
  host_id: "fixture-host",
  profile: "default",
  tags: [],
  diagnostics: [],
  workspace: { workspace_id: workspaceId, visibility: "workspace", identity: workspaceId },
  implementation: { kind: "builtin", display_hint: "fixture" },
  workdir_attachments: [],
};
const snapshot = {
  event: "snapshot",
  data: {
    session,
    state,
    greeting: {
      worker_name: worker.label,
      cwd: "/synthetic/workdir",
      provider: "fixture",
      model: "synthetic",
      scope_summary: "synthetic read-only files",
      tools: [],
      context_window: 200000,
      context_tokens: 2400,
    },
  },
};
const methods: unknown[] = [];
const requests: { method: string; path: string }[] = [];
const events: unknown[] = [];
let submitMode: "accept" | "reject" | "hold" = "accept";
let uploadMode: "normal" | "fail" | "hold" = "normal";
const pendingAcceptances: (() => void)[] = [];
let rewindMode: "accept" | "reject" | "hold" = "accept";
const pendingRewinds: (() => void)[] = [];
const cancelledUploads = new Set<string>();
const heldUploads = new Map<string, (response: Response) => void>();
const releaseHeldUploads = new Map<string, () => void>();
const grants = new Map<string, { file_name: string; media_type: string }>();
const uploads: string[] = [];
const uploadAttempts: string[] = [];
const deletes: string[] = [];
let historyRequests = 0;
let nextSubscription = 0;
const mime: Record<string, string> = {
  ".html": "text/html; charset=utf-8",
  ".js": "text/javascript; charset=utf-8",
  ".css": "text/css; charset=utf-8",
  ".json": "application/json",
  ".svg": "image/svg+xml",
  ".png": "image/png",
  ".woff2": "font/woff2",
  ".wasm": "application/wasm",
};
async function staticResponse(pathname: string): Promise<Response> {
  const relative = normalize(pathname.replace(/^\/+/, "") || "index.html");
  if (relative.startsWith("..")) return new Response("not found", { status: 404 });
  let path = join(buildRoot, relative);
  try {
    if ((await Deno.stat(path)).isDirectory) path = join(path, "index.html");
    return new Response(await Deno.readFile(path), {
      headers: { "content-type": mime[extname(path)] ?? "application/octet-stream" },
    });
  } catch {
    return new Response(await Deno.readFile(join(buildRoot, "index.html")), {
      headers: { "content-type": mime[".html"] },
    });
  }
}
Deno.serve({ hostname: "127.0.0.1", port }, async (request) => {
  const url = new URL(request.url);
  if (url.pathname === "/health") return new Response("ok");
  if (url.pathname === "/fixture-state") {
    return json({
      methods,
      events,
      requests,
      uploads,
      upload_attempts: uploadAttempts,
      deletes,
      held_uploads: [...heldUploads.keys()],
      history_requests: historyRequests,
    });
  }
  if (url.pathname === "/fixture-control" && request.method === "POST") {
    const control = await request.json();
    if (["accept", "reject", "hold"].includes(control.submit)) submitMode = control.submit;
    if (["normal", "fail", "hold"].includes(control.upload)) uploadMode = control.upload;
    if (["accept", "reject", "hold"].includes(control.rewind)) rewindMode = control.rewind;
    if (control.seed_rewind_history) {
      entries.unshift({ ...entries[0], entry_id: "user-older", content: [{ kind: "text", text: "Earlier rewind input" }] },
        { ...entries[1], entry_id: "assistant-older", content: [{ kind: "text", text: "Earlier reply" }] });
    }
    if (control.apply_rewind) { for (const apply of pendingRewinds.splice(0)) apply(); }
    if (control.accept_pending) { for (const accept of pendingAcceptances.splice(0)) accept(); }
    if (control.release_uploads) {
      for (const release of [...releaseHeldUploads.values()]) release();
    }
    return json({ submitMode, uploadMode });
  }
  if (url.pathname.startsWith("/api/")) {
    requests.push({ method: request.method, path: url.pathname });
  }
  if (url.pathname === "/api/workspaces") {
    return json([{
      workspace_id: workspaceId,
      owner_account_id: "owner",
      display_name: "Console Live Review",
      state: "active",
      created_at: "2026-01-01T00:00:00Z",
      updated_at: "2026-01-02T00:00:00Z",
    }]);
  }
  if (url.pathname === `/api/w/${workspaceId}/workspace`) {
    return json({
      workspace_id: workspaceId,
      display_name: "Console Live Review",
      record_authority: "fixture",
      schema_version: 1,
      auth: {
        Passkey: {
          rp_id: "127.0.0.1",
          origin: url.origin,
          public_base_url: url.origin,
          cookie_name: "fixture",
        },
      },
      permissions: {
        manage_repositories: false,
        manage_secrets: false,
        manage_runtimes: false,
        delete_workspace: false,
      },
      extension_points: {
        store: "fixture",
        event_stream: { status: "ready", note: "fixture", diagnostics: [] },
        host_worker_bridge: { status: "ready", note: "fixture", diagnostics: [] },
        companion_console: { status: "ready", note: "fixture", diagnostics: [] },
      },
    });
  }
  if (url.pathname === `/api/w/${workspaceId}/repositories`) {
    return json({ workspace_id: workspaceId, items: [], source: "fixture", diagnostics: [] });
  }
  if (url.pathname === `/api/w/${workspaceId}/working-directories`) {
    return json({ workspace_id: workspaceId, items: [], diagnostics: [] });
  }
  if (url.pathname === `/api/w/${workspaceId}/workers`) {
    return json({ workspace_id: workspaceId, limit: 200, items: [worker], source: "fixture", diagnostics: [] });
  }
  if (url.pathname === `/api/w/${workspaceId}/workers/W-901` || url.pathname === workerPath) {
    return json(worker);
  }
  if (url.pathname === `${workerPath}/session`) return json({ availability: "live_protocol" });
  if (url.pathname === `${workerPath}/session/history`) {
    historyRequests++;
    return json({
      availability: "page",
      page: {
        session_id: "session-a",
        lineage_id: "lineage-a",
        compact_ancestor_lineage_ids: [],
        turns: [{ turn_id: "user-1", entries }],
        next_cursor: null,
        has_more: false,
      },
    });
  }
  if (url.pathname === `${workerPath}/attachment-upload-grants` && request.method === "POST") {
    const id = url.searchParams.get("upload_id")!;
    grants.set(id, {
      file_name: url.searchParams.get("file_name")!,
      media_type: url.searchParams.get("media_type")!,
    });
    return json({ upload_id: id, expires_at_ms: Date.now() + 60000 });
  }
  if (url.pathname.startsWith(`${workerPath}/attachment-uploads/`)) {
    const id = url.pathname.split("/").at(-1)!;
    if (request.method === "DELETE") {
      deletes.push(id);
      grants.delete(id);
      cancelledUploads.add(id);
      heldUploads.get(id)?.(new Response(null, { status: 204 }));
      heldUploads.delete(id);
      releaseHeldUploads.delete(id);
      return new Response(null, { status: 204 });
    }
    const grant = grants.get(id);
    if (!grant || request.method !== "PUT") return json({ error: "unknown_upload" }, 404);
    uploadAttempts.push(id);
    if (uploadMode === "fail") {
      await request.body?.cancel();
      return json({ error: "synthetic_upload_failure" }, 503);
    }
    const bytes = await request.arrayBuffer();
    const hash = Array.from(
      new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)),
      (byte) => byte.toString(16).padStart(2, "0"),
    ).join("");
    const complete = () => {
      uploads.push(id);
      return json({
        file: {
          artifact_id: id,
          ...grant,
          created_at_ms: Date.now(),
          availability: "available",
          byte_len: bytes.byteLength,
          sha256: hash,
        },
      });
    };
    if (uploadMode === "hold") {
      if (cancelledUploads.has(id)) return new Response(null, { status: 204 });
      return await new Promise<Response>((resolve) => {
        heldUploads.set(id, resolve);
        releaseHeldUploads.set(id, () => {
          heldUploads.delete(id);
          releaseHeldUploads.delete(id);
          resolve(complete());
        });
      });
    }
    return complete();
  }
  if (url.pathname.startsWith(`${workerPath}/attachments/`) && request.method === "DELETE") {
    deletes.push(url.pathname.split("/").at(-1)!);
    return new Response(null, { status: 204 });
  }
  if (
    url.pathname === `/api/w/${workspaceId}/protocol/ws` &&
    request.headers.get("upgrade") === "websocket"
  ) {
    const { socket, response } = Deno.upgradeWebSocket(request);
    const subscriptions = new Map<string, string>();
    const send = (frame: unknown) => socket.send(JSON.stringify(frame));
    socket.onmessage = (event) => {
      const frame = JSON.parse(String(event.data));
      if (frame.frame === "request" && frame.message.method === "subscribe_events") {
        const { request_id, selector } = frame.message.params;
        const subscription_id = `fixture-${++nextSubscription}`;
        subscriptions.set(subscription_id, selector.topic);
        send({
          protocol_version: 2,
          frame: "response",
          message: {
            result: "subscribed",
            payload: {
              request_id,
              subscription_id,
              selector,
              snapshot: selector.topic === "worker_protocol"
                ? { topic: "worker_protocol", data: { worker_id: workerId, events: [snapshot] } }
                : { topic: "workers", data: { workers: [] } },
            },
          },
        });
      } else if (frame.frame === "worker_protocol") {
        const method = frame.message.method;
        methods.push(method);
        const subscription_id = frame.message.subscription_id;
        if (subscriptions.get(subscription_id) !== "worker_protocol") return;
        const emit = (event: unknown) => {
          events.push(event);
          if (socket.readyState !== WebSocket.OPEN) return;
          send({
            protocol_version: 2,
            frame: "event",
            message: {
              event: "event",
              data: {
                subscription_id,
                payload: { event: "worker_protocol", data: { worker_id: workerId, event } },
              },
            },
          });
        };
        if (method.method === "list_completions") {
          const { kind, prefix, request_id, context } = method.params;
          let candidates: unknown[] = [];
          if (kind === "feature") {
            candidates = invocations.filter((descriptor) =>
              descriptor.name.startsWith(prefix) ||
              descriptor.aliases.some((alias) => alias.startsWith(prefix))
            ).map((invocation) => ({
              value: invocation.name,
              is_dir: false,
              description: invocation.description,
              invocation,
            }));
          } else if (kind === "file") {
            candidates = ["docs/", "docs/release-notes.md"].filter((value) =>
              value.startsWith(prefix)
            ).map((value) => ({ value, is_dir: value.endsWith("/") }));
          } else if (context?.invocation === "fixture.review") {
            const descriptor = invocations[0].arguments.find((argument) =>
              argument.name === context.argument
            );
            const values = !context.argument
              ? invocations[0].arguments.map((argument) => argument.name + "=")
              : descriptor?.completion.kind === "static"
              ? descriptor.completion.values ?? []
              : context.argument === "path"
              ? ["docs/release-notes.md", "docs/long-release-notes-for-responsive-validation.md"]
              : [];
            candidates = values.filter((value) => value.startsWith(prefix)).map((value) => ({
              value,
              is_dir: false,
            }));
          }
          send({
            protocol_version: 2,
            frame: "event",
            message: {
              event: "event",
              data: {
                subscription_id,
                payload: {
                  event: "worker_protocol",
                  data: {
                    worker_id: workerId,
                    event: {
                      event: "completions",
                      data: {
                        kind,
                        prefix,
                        ...(request_id ? { request_id } : {}),
                        ...(context ? { context } : {}),
                        entries: candidates,
                      },
                    },
                  },
                },
              },
            },
          });
        } else if (method.method === "rewind_to") {
          const index = entries.findIndex((entry) => entry.entry_id === method.params.entry_id && entry.role === "user");
          if (rewindMode === "reject" || index < 0) {
            emit({ event: "error", data: { code: "invalid_request", message: "Synthetic rewind rejection" } });
          } else {
            const apply = () => {
              const input = entries[index].content.map((part) => ({ kind: "text", content: part.text }));
              const discarded_entries = entries.length - index;
              entries.splice(index);
              emit({ event: "rewind_applied", data: { session, input, summary: {
                truncated_to_entries: index, discarded_entries, tool_side_effect_warning: true,
              } } });
            };
            if (rewindMode === "hold") pendingRewinds.push(apply); else apply();
          }
        } else if (method.method === "submit") {
          const submission_request_id = method.params.submission_request_id;
          const accept = () => {
            emit({
              event: "submission_accepted",
              data: {
                submission_request_id,
                submission_id: `accepted-${submission_request_id}`,
                disposition: "started",
              },
            });
            // A held admission models an in-flight run; immediate fixture runs
            // finish synchronously. Publish authoritative state, not only an ack.
            emit({
              event: "worker_state",
              data: {
                snapshot: {
                  last_command_id: 0,
                  state: submitMode === "hold"
                    ? { kind: "busy", state: { kind: "run", state: "running" } }
                    : { kind: "idle" },
                },
              },
            });
          };
          if (submitMode === "reject") {
            emit({
              event: "submission_rejected",
              data: {
                submission_request_id,
                message: "Synthetic admission rejection; draft was not accepted.",
              },
            });
          } else if (submitMode === "hold") pendingAcceptances.push(accept);
          else accept();
        }
        // Admission responses are synthetic authority only. Never execute a Feature or Worker.
      }
    };
    return response;
  }
  if (url.pathname.startsWith("/api/")) {
    return json({ error: "unhandled_fixture_request", path: url.pathname }, 404);
  }
  return await staticResponse(url.pathname);
});