// Cross-target: downstream MCP session continuity — the "an agent can use a
// stateful MCP server" promise. Servers like Render's MCP key state by
// Mcp-Session-Id (select_workspace, then every later call reads the
// selection). If executor dials a fresh downstream connection per tool call,
// every call lands in a brand-new session: select_workspace succeeds, and the
// very next call reports no workspace selected. This scenario drives that
// journey against a session-stateful MCP fixture and asserts state set by one
// tool call is visible to the next call in the same execution.
import { randomBytes } from "node:crypto";

import { expect } from "@effect/vitest";
import { Effect, Predicate } from "effect";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { composePluginApi } from "@executor-js/api/server";
import { mcpHttpPlugin } from "@executor-js/plugin-mcp/api";
import { serveMcpServer } from "@executor-js/plugin-mcp/testing";
import { AuthTemplateSlug, ConnectionName, IntegrationSlug } from "@executor-js/sdk/shared";

import { scenario } from "../src/scenario";
import { Api, Target } from "../src/services";

const api = composePluginApi([mcpHttpPlugin()] as const);

const freshSlug = (prefix: string): string => `${prefix}_${randomBytes(4).toString("hex")}`;

// A session-stateful MCP server, shaped like Render's workspace selection:
// `select_workspace` stores the choice in the session (each MCP session gets
// its own server instance from the factory, exactly like state keyed by
// Mcp-Session-Id), and `get_workspace` answers from that same session state.
const makeSessionStatefulMcpServer = () => () => {
  const server = new McpServer(
    { name: "session-stateful-test-server", version: "1.0.0" },
    { capabilities: {} },
  );
  // Per-session: lives in this server instance, created per MCP session.
  let selected: string | null = null;

  server.registerTool(
    "select_workspace",
    {
      description: "Selects the workspace for this MCP session",
      inputSchema: {},
    },
    async () => {
      selected = "ws-e2e";
      return { content: [{ type: "text" as const, text: "selected:ws-e2e" }] };
    },
  );

  server.registerTool(
    "get_workspace",
    {
      description: "Returns the workspace selected earlier in this MCP session",
      inputSchema: {},
    },
    async () => ({
      content: [
        {
          type: "text" as const,
          text: selected === null ? "no workspace selected" : `workspace:${selected}`,
        },
      ],
    }),
  );

  return server;
};

// One sandbox execution, two dependent tool calls — the smallest agent journey
// that relies on downstream session state.
const selectThenReadCode = (slug: string) => `
const selected = await tools.${slug}.org.main.select_workspace({});
const read = await tools.${slug}.org.main.get_workspace({});
return JSON.stringify({ selected, read });
`;

scenario(
  "MCP · session state set by one tool call is visible to the next call",
  {},
  Effect.scoped(
    Effect.gen(function* () {
      const target = yield* Target;
      const { client: makeApiClient } = yield* Api;
      const identity = yield* target.newIdentity();
      const client = yield* makeApiClient(api, identity);
      const slug = freshSlug("mcp_state");

      const server = yield* serveMcpServer(makeSessionStatefulMcpServer());

      yield* client.mcp.addServer({
        payload: {
          transport: "remote",
          name: "Session-stateful MCP",
          endpoint: server.url,
          slug,
          remoteTransport: "streamable-http",
        },
      });

      yield* Effect.gen(function* () {
        yield* client.connections.create({
          payload: {
            owner: "org",
            name: ConnectionName.make("main"),
            integration: IntegrationSlug.make(slug),
            template: AuthTemplateSlug.make("none"),
            value: "",
          },
        });

        // Only observe the execution's own traffic, not discovery's.
        yield* server.clearRequests;

        const executed = yield* client.executions.execute({
          payload: { code: selectThenReadCode(slug), autoApprove: true },
        });
        expect(executed.status, "the two-call execution completed").toBe("completed");

        // THE promise: the selection made by the first call is what the second
        // call reads. A per-call connection lands the second call in a fresh
        // downstream session, which answers "no workspace selected".
        expect(executed.text, "the first call selected the workspace").toContain("selected:ws-e2e");
        expect(executed.text, "the second call sees the same session's selection").toContain(
          "workspace:ws-e2e",
        );

        // Wire-level corroboration from the fixture's request ledger: every
        // session-bound request of this execution carried ONE Mcp-Session-Id.
        const sessionIds = new Set(
          (yield* server.requests)
            .map((request) => request.sessionId)
            .filter(Predicate.isNotUndefined),
        );
        expect([...sessionIds].length, "both tool calls rode a single downstream MCP session").toBe(
          1,
        );
      }).pipe(
        Effect.ensuring(
          Effect.gen(function* () {
            yield* client.connections
              .remove({
                params: {
                  owner: "org",
                  integration: IntegrationSlug.make(slug),
                  name: ConnectionName.make("main"),
                },
              })
              .pipe(Effect.ignore);
            yield* client.mcp
              .removeServer({ params: { slug: IntegrationSlug.make(slug) } })
              .pipe(Effect.ignore);
          }),
        ),
      );
    }),
  ),
);