// Fake `codex app-server` fixture for appserver-connector.test.ts, spawned as
// a child process with `bun run <this file>`. Speaks the app-server JSON-RPC
// protocol over newline-delimited stdio with the same shapes the real binary
// uses (verified against codex-rs/app-server-protocol v2), including:
//
//   - handshake ordering: `thread/start` is refused until the `initialized`
//     notification has arrived, so the bridge's sequence is asserted here;
//   - a paginated `mcpServerStatus/list` whose FIRST page holds a different
//     server, so the bridge must follow `nextCursor`;
//   - a `needs_approval` tool that emits a server→client
//     `mcpServer/elicitation/request` and only succeeds when the answer is
//     an accept — the round trip through executor's elicitation bridge.
import * as readline from "node:readline";

import { Option, Schema } from "effect";

const decodeMessage = Schema.decodeUnknownOption(
  Schema.fromJsonString(
    Schema.Struct({
      id: Schema.optional(Schema.Union([Schema.Number, Schema.String])),
      method: Schema.optional(Schema.String),
      params: Schema.optional(Schema.Unknown),
      result: Schema.optional(Schema.Unknown),
    }),
  ),
);

const decodeInitializeParams = Schema.decodeUnknownOption(
  Schema.Struct({ clientInfo: Schema.Struct({ name: Schema.String }) }),
);

const decodeThreadStartParams = Schema.decodeUnknownOption(
  Schema.Struct({ approvalPolicy: Schema.optional(Schema.String) }),
);

const decodeThreadParams = Schema.decodeUnknownOption(
  Schema.Struct({
    threadId: Schema.optional(Schema.String),
    cursor: Schema.optional(Schema.String),
  }),
);

const decodeToolCallParams = Schema.decodeUnknownOption(
  Schema.Struct({
    threadId: Schema.String,
    server: Schema.String,
    tool: Schema.String,
    arguments: Schema.optional(Schema.Unknown),
    _meta: Schema.optional(Schema.Unknown),
  }),
);

const decodeElicitAnswer = Schema.decodeUnknownOption(
  Schema.Struct({ action: Schema.String, content: Schema.optional(Schema.Unknown) }),
);

const THREAD_ID = "thread-fixture-1";

const TOOLS = {
  echo: {
    name: "echo",
    description: "Echo the arguments back",
    inputSchema: { type: "object", properties: { text: { type: "string" } } },
  },
  announce_restart: {
    name: "announce_restart",
    description: "Emit server status notifications",
    inputSchema: { type: "object", properties: {} },
  },
  needs_approval: {
    name: "needs_approval",
    description: "Succeeds only after an accepted elicitation",
    inputSchema: { type: "object", properties: {} },
  },
};

const write = (message: object): void => {
  process.stdout.write(`${JSON.stringify(message)}\n`);
};

const reply = (id: number | string, result: unknown): void => {
  write({ jsonrpc: "2.0", id, result });
};

const replyError = (id: number | string, code: number, message: string): void => {
  write({ jsonrpc: "2.0", id, error: { code, message } });
};

let initializedSeen = false;
let elicitationsAllowed = false;
let nextServerRequestId = 1000;
/** Elicitation request id → the pending tool call's request id. */
const pendingApprovals = new Map<number | string, number | string>();

/** The `node_repl` server, as Codex exposes it: one raw `js` REPL tool. The
 *  sky surface is projected onto this by the bridge, so the fixture only has
 *  to echo back the program it was asked to run. */
const NODE_REPL_TOOLS = {
  js: {
    name: "js",
    description: "JavaScript code to execute with top-level await.",
    inputSchema: { type: "object", properties: { code: { type: "string" } } },
  },
};

const serverStatusPage = (cursor: string | undefined): object =>
  cursor === undefined
    ? {
        data: [
          {
            name: "decoy",
            runtimeStatus: "connected",
            pluginId: null,
            serverInfo: null,
            tools: {},
            resources: [],
            resourceTemplates: [],
            authStatus: "unsupported",
          },
        ],
        nextCursor: "page-2",
      }
    : {
        data: [
          {
            name: "messages",
            runtimeStatus: "connected",
            pluginId: "messages",
            serverInfo: null,
            tools: TOOLS,
            resources: [],
            resourceTemplates: [],
            authStatus: "unsupported",
          },
          {
            name: "node_repl",
            runtimeStatus: "connected",
            pluginId: null,
            serverInfo: null,
            tools: NODE_REPL_TOOLS,
            resources: [],
            resourceTemplates: [],
            authStatus: "unsupported",
          },
        ],
        nextCursor: null,
      };

const handleToolCall = (id: number | string, params: unknown): void => {
  const decoded = decodeToolCallParams(params);
  if (Option.isNone(decoded)) {
    replyError(id, -32602, "malformed mcpServer/tool/call params");
    return;
  }
  const call = decoded.value;
  // `node_repl` echoes the program it was handed, so a test can assert what
  // the sky surface compiled without needing a real REPL.
  if (call.server === "node_repl") {
    const args = call.arguments as { code?: string } | undefined;
    // A Chrome-shaped per-site approval: no schema to fill in, and the terms
    // of the grant (`persist`, `origin`) carried in `_meta`.
    if (args?.code?.includes("__needs_site_approval")) {
      const elicitationId = nextServerRequestId++;
      pendingApprovals.set(elicitationId, id);
      write({
        jsonrpc: "2.0",
        id: elicitationId,
        method: "mcpServer/elicitation/request",
        params: {
          threadId: THREAD_ID,
          turnId: null,
          serverName: "node_repl",
          mode: "form",
          message: "Allow Browser use to access https://example.com?",
          requestedSchema: { type: "object", properties: {} },
          _meta: {
            connector_id: "browser-use",
            connector_name: "Browser use",
            origin: "https://example.com",
            persist: "always",
          },
        },
      });
      return;
    }
    reply(id, {
      content: [{ type: "text", text: args?.code ?? "" }],
      // Echoed so a test can assert the turn metadata the Chrome client
      // requires, without needing a real browser.
      structuredContent: { meta: call._meta ?? null },
    });
    return;
  }
  if (call.threadId !== THREAD_ID || call.server !== "messages") {
    replyError(id, -32602, `unknown thread or server: ${call.threadId}/${call.server}`);
    return;
  }
  if (call.tool === "announce_restart") {
    // Codex reports a server's startup transitions; it names every server it
    // runs, so the fixture emits a decoy alongside the real one.
    write({
      jsonrpc: "2.0",
      method: "mcpServer/startupStatus/updated",
      params: { threadId: THREAD_ID, name: "someone-else", status: "ready", error: null },
    });
    write({
      jsonrpc: "2.0",
      method: "mcpServer/startupStatus/updated",
      params: { threadId: THREAD_ID, name: "messages", status: "starting", error: null },
    });
    write({
      jsonrpc: "2.0",
      method: "mcpServer/startupStatus/updated",
      params: { threadId: THREAD_ID, name: "messages", status: "ready", error: null },
    });
    reply(id, { content: [{ type: "text", text: "announced" }] });
    return;
  }
  if (call.tool === "echo") {
    reply(id, {
      content: [{ type: "text", text: JSON.stringify(call.arguments ?? {}) }],
      structuredContent: { codexHome: process.env["CODEX_HOME"] ?? null },
      isError: null,
    });
    return;
  }
  if (call.tool === "needs_approval") {
    if (!elicitationsAllowed) {
      // Exactly what Codex returns when it declines the elicitation for the
      // client: an error result, no prompt, no explanation.
      reply(id, {
        content: [{ type: "text", text: "access was not approved" }],
        isError: true,
      });
      return;
    }
    const elicitationId = nextServerRequestId++;
    pendingApprovals.set(elicitationId, id);
    write({
      jsonrpc: "2.0",
      id: elicitationId,
      method: "mcpServer/elicitation/request",
      params: {
        threadId: THREAD_ID,
        turnId: null,
        serverName: "messages",
        mode: "form",
        _meta: null,
        message: "Allow the fixture to proceed?",
        requestedSchema: { type: "object", properties: {} },
      },
    });
    return;
  }
  replyError(id, -32602, `unknown tool: ${call.tool}`);
};

const handleElicitationAnswer = (id: number | string, result: unknown): void => {
  const callId = pendingApprovals.get(id);
  if (callId === undefined) return;
  pendingApprovals.delete(id);
  const answer = Option.getOrUndefined(decodeElicitAnswer(result));
  if (answer?.action === "accept") {
    reply(callId, { content: [{ type: "text", text: "approved" }] });
    return;
  }
  reply(callId, {
    content: [{ type: "text", text: `denied: ${answer?.action ?? "unreadable"}` }],
    isError: true,
  });
};

readline.createInterface({ input: process.stdin }).on("line", (line) => {
  const decoded = decodeMessage(line);
  if (Option.isNone(decoded)) return;
  const message = decoded.value;

  if (message.method === undefined) {
    // A response from the bridge — only elicitation answers flow this way.
    if (message.id !== undefined) handleElicitationAnswer(message.id, message.result);
    return;
  }
  if (message.method === "initialized") {
    initializedSeen = true;
    return;
  }
  if (message.id === undefined) return;

  if (message.method === "initialize") {
    const params = decodeInitializeParams(message.params);
    if (Option.isNone(params)) {
      replyError(message.id, -32602, "initialize requires clientInfo");
      return;
    }
    reply(message.id, { userAgent: "codex-fixture/0.0.0" });
    return;
  }
  if (message.method === "thread/start") {
    if (!initializedSeen) {
      replyError(message.id, -32600, "thread/start before the initialized notification");
      return;
    }
    // Codex DECLINES every MCP elicitation itself on a thread whose approval
    // policy does not allow them, so a thread started without one can never
    // receive an approval prompt. The fixture models that: it only elicits
    // when the bridge asked for a policy that permits elicitations.
    const params = Option.getOrUndefined(decodeThreadStartParams(message.params));
    elicitationsAllowed = params?.approvalPolicy === "on-request";
    reply(message.id, { thread: { id: THREAD_ID } });
    return;
  }
  if (message.method === "mcpServerStatus/list") {
    const params = Option.getOrUndefined(decodeThreadParams(message.params));
    if (params?.threadId !== THREAD_ID) {
      replyError(message.id, -32602, "mcpServerStatus/list requires the started threadId");
      return;
    }
    reply(message.id, serverStatusPage(params.cursor));
    return;
  }
  if (message.method === "mcpServer/tool/call") {
    handleToolCall(message.id, message.params);
    return;
  }
  replyError(message.id, -32601, `fixture does not implement ${message.method}`);
});