// ---------------------------------------------------------------------------
// Regression coverage for the transient DO-relocation retry in the worker-side
// session-store dispatcher.
//
// Cloudflare may relocate a live Durable Object between machines; an in-flight
// `init` then throws "cannot access storage because object has moved to a
// different machine". Before the retry, that rejection became an unrecoverable
// defect the envelope rendered as a -32603 — exactly the prod incident on
// 2026-06-15 (one `mcp.do.init` failure a reconnect cleared). These tests inject
// that rejection at the `McpSessionDOStub` seam and pin the recovery behavior.
// ---------------------------------------------------------------------------

import { describe, expect, it } from "@effect/vitest";
import { Cause, Effect, Exit } from "effect";

import { McpSessionStore, type McpDispatchResult, type Principal } from "@executor-js/host-mcp";

import {
  DO_RELOCATION_MAX_RETRIES,
  makeDurableObjectMcpSessionStore,
  type McpSessionDOStub,
} from "./session-store";

const RELOCATION_ERROR = "cannot access storage because object has moved to a different machine";

const TEST_PRINCIPAL: Principal = {
  accountId: "user_test",
  organizationId: "org_test",
  organizationName: "Test Org",
  email: "test@example.com",
  name: "Test",
  avatarUrl: null,
  roles: ["user"],
};

/** A POST with no session id — routes dispatch through the create/init path. */
const initializeRequest = (): Request =>
  new Request("https://mcp.test/mcp", {
    method: "POST",
    headers: { authorization: "Bearer x", "content-type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize" }),
  });

/** The JSON-RPC body the faked DO returns once `init` succeeds. */
const okResponse = (): Response =>
  new Response(JSON.stringify({ jsonrpc: "2.0", id: 0, result: {} }), {
    status: 200,
    headers: { "content-type": "application/json" },
  });

/** Drive `dispatch` for a create over a store built from one fake stub. */
const dispatchCreate = (stub: McpSessionDOStub): Effect.Effect<McpDispatchResult> =>
  Effect.gen(function* () {
    const store = yield* McpSessionStore;
    return yield* store.dispatch({
      request: initializeRequest(),
      principal: TEST_PRINCIPAL,
      sessionId: null,
      method: "POST",
    });
  }).pipe(
    Effect.provide(makeDurableObjectMcpSessionStore({ newStub: () => stub, getStub: () => stub })),
  );

/** Rendered cause of a failed dispatch (empty for a success) — keeps the
 *  message assertion unconditional, off the `Exit.isFailure` branch. */
const failureText = (exit: Exit.Exit<McpDispatchResult>): string =>
  Exit.isFailure(exit) ? Cause.pretty(exit.cause) : "";

describe("makeDurableObjectMcpSessionStore — DO-relocation retry", () => {
  it.live("retries mcp.do.init past a relocation, then returns the DO response", () =>
    Effect.gen(function* () {
      let initCalls = 0;
      let handleCalls = 0;
      const stub: McpSessionDOStub = {
        init: () => {
          initCalls += 1;
          if (initCalls === 1) {
            // oxlint-disable-next-line executor/no-promise-reject, executor/no-error-constructor -- boundary: fake DO stub rejects to simulate a Cloudflare relocation throw
            return Promise.reject(new Error(RELOCATION_ERROR));
          }
          return Promise.resolve();
        },
        handleRequest: () => {
          handleCalls += 1;
          return Promise.resolve(okResponse());
        },
        clearSession: () => Promise.resolve(),
      };

      const result = yield* dispatchCreate(stub);

      expect(initCalls, "init retried once after the relocation").toBe(2);
      expect(handleCalls, "handleRequest runs once, after init recovers").toBe(1);
      expect(result).toBeInstanceOf(Response);
      expect((result as Response).status).toBe(200);
    }),
  );

  it.live("gives up after the retry budget when relocation never clears", () =>
    Effect.gen(function* () {
      let initCalls = 0;
      let handleCalls = 0;
      const stub: McpSessionDOStub = {
        init: () => {
          initCalls += 1;
          // oxlint-disable-next-line executor/no-promise-reject, executor/no-error-constructor -- boundary: fake DO stub rejects to simulate a Cloudflare relocation throw
          return Promise.reject(new Error(RELOCATION_ERROR));
        },
        handleRequest: () => {
          handleCalls += 1;
          return Promise.resolve(okResponse());
        },
        clearSession: () => Promise.resolve(),
      };

      const exit = yield* Effect.exit(dispatchCreate(stub));

      expect(Exit.isFailure(exit), "exhausted retries surface as a defect").toBe(true);
      expect(initCalls, "one initial attempt plus the full retry budget").toBe(
        1 + DO_RELOCATION_MAX_RETRIES,
      );
      expect(handleCalls, "handleRequest is never reached when init never succeeds").toBe(0);
      expect(failureText(exit), "the relocation cause is preserved").toContain(RELOCATION_ERROR);
    }),
  );

  it.live("does not retry a non-relocation failure — surfaces it immediately", () =>
    Effect.gen(function* () {
      let initCalls = 0;
      const stub: McpSessionDOStub = {
        init: () => {
          initCalls += 1;
          // oxlint-disable-next-line executor/no-promise-reject, executor/no-error-constructor -- boundary: fake DO stub rejects to simulate a non-transient init failure
          return Promise.reject(new Error("schema spread bug — not transient"));
        },
        handleRequest: () => Promise.resolve(okResponse()),
        clearSession: () => Promise.resolve(),
      };

      const exit = yield* Effect.exit(dispatchCreate(stub));

      expect(Exit.isFailure(exit), "a non-transient rejection still dies").toBe(true);
      expect(initCalls, "non-relocation errors are not retried").toBe(1);
      expect(failureText(exit), "the original failure is preserved").toContain("schema spread bug");
    }),
  );
});