// The console artifact page's transport. It has no MCP client, so it answers the
// shell's two tool calls over the executions HTTP API — which is exactly the
// path that used to surface a raw `ExecutionNotFoundError` to the user when an
// approval arrived after the pause was gone.
import { describe, expect, it } from "@effect/vitest";
import { Schema } from "effect";

import { APPROVAL_EXPIRED_MESSAGE, createHttpShellHost } from "./shell-host";

/** The adapter's request body, read back off the wire. */
const decodeRequestBody = Schema.decodeUnknownSync(
  Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)),
);

const jsonResponse = (body: unknown, status = 200): Response =>
  new Response(JSON.stringify(body), {
    status,
    headers: { "content-type": "application/json" },
  });

/** Records what the adapter put on the wire, so the assertions are about the
 *  request the server actually receives rather than the adapter's internals. */
const recordingFetch = (respond: (url: string) => Response) => {
  const calls: Array<{ url: string; body: unknown }> = [];
  const fetch: typeof globalThis.fetch = async (input, init) => {
    const url = String(input);
    calls.push({
      url,
      body: typeof init?.body === "string" ? decodeRequestBody(init.body) : undefined,
    });
    return respond(url);
  };
  return { calls, fetch };
};

describe("createHttpShellHost", () => {
  it("maps execute-action onto POST /executions, carrying the artifact id", async () => {
    const { calls, fetch } = recordingFetch(() =>
      jsonResponse({ status: "completed", text: "ok", structured: { result: 1 }, isError: false }),
    );
    const host = createHttpShellHost({ fetch });

    const result = await host.callServerTool({
      name: "execute-action",
      arguments: { code: "return await tools.a.b()", artifactId: "art_1" },
    });

    expect(calls).toHaveLength(1);
    expect(calls[0]?.url).toContain("/executions");
    expect(calls[0]?.body).toStrictEqual({ code: "return await tools.a.b()", artifactId: "art_1" });
    expect(result.isError).toBeUndefined();
  });

  it("maps execute-action-resume onto the execution's resume route", async () => {
    const { calls, fetch } = recordingFetch(() =>
      jsonResponse({ status: "completed", text: "ok", structured: {}, isError: false }),
    );
    const host = createHttpShellHost({ fetch });

    await host.callServerTool({
      name: "execute-action-resume",
      arguments: { executionId: "exec_1", action: "accept", content: '{"note":"hi"}' },
    });

    expect(calls[0]?.url).toContain("/executions/exec_1/resume");
    expect(calls[0]?.body).toStrictEqual({ action: "accept", content: { note: "hi" } });
  });

  // The reported bug's user-visible half: the approval failed and the person
  // clicking Approve got a JSON-RPC envelope wrapping an internal error tag.
  it("reports an expired approval as a next action, not a raw server error", async () => {
    const { fetch } = recordingFetch(() =>
      jsonResponse({ _tag: "ApprovalExpiredError", executionId: "exec_1" }, 410),
    );
    const host = createHttpShellHost({ fetch });

    await expect(
      host.callServerTool({
        name: "execute-action-resume",
        arguments: { executionId: "exec_1", action: "accept", content: "{}" },
      }),
    ).rejects.toThrow(APPROVAL_EXPIRED_MESSAGE);
  });

  it("does not disguise other failures as an expired approval", async () => {
    const { fetch } = recordingFetch(() => new Response("upstream exploded", { status: 500 }));
    const host = createHttpShellHost({ fetch });

    await expect(
      host.callServerTool({ name: "execute-action", arguments: { code: "return 1" } }),
    ).rejects.toThrow("upstream exploded");
  });

  // A malformed body must not lose the user's decision — the action still has to
  // reach the server so the paused execution gets an answer.
  it("still sends the decision when the resume content will not parse", async () => {
    const { calls, fetch } = recordingFetch(() =>
      jsonResponse({ status: "completed", text: "ok", structured: {}, isError: false }),
    );
    const host = createHttpShellHost({ fetch });

    await host.callServerTool({
      name: "execute-action-resume",
      arguments: { executionId: "exec_1", action: "decline", content: "{not json" },
    });

    // `content` is absent rather than null: an unparseable body is dropped, but
    // the decision still travels.
    expect(calls[0]?.body).toStrictEqual({ action: "decline" });
  });
});