import { beforeEach, describe, expect, it, vi } from "vitest";
import type { GatewayClientOptions } from "../gateway/client.js";
import { createNodeHostGatewayCandidateConnection } from "./gateway-candidate-connection.js";

const mocks = vi.hoisted(() => ({
  options: [] as GatewayClientOptions[],
  clients: [] as Array<{
    request: ReturnType<typeof vi.fn>;
    start: ReturnType<typeof vi.fn>;
    stop: ReturnType<typeof vi.fn>;
    updateNodeManifest: ReturnType<typeof vi.fn>;
  }>,
}));

vi.mock("../gateway/client.js", () => ({
  GatewayClient: function GatewayClient(options: GatewayClientOptions) {
    const client = {
      request: vi.fn(async () => ({ url: options.url })),
      start: vi.fn(),
      stop: vi.fn(),
      updateNodeManifest: vi.fn(),
    };
    mocks.options.push(options);
    mocks.clients.push(client);
    return client;
  },
}));

const candidates = [
  { host: "192.168.1.20", port: 18789, contextPath: "/openclaw-gw", tls: false },
  { host: "gateway.tailnet.example", port: 443, tls: true },
];

function createConnection(
  cloudflareAccessByCandidate?: Parameters<
    typeof createNodeHostGatewayCandidateConnection
  >[0]["cloudflareAccessByCandidate"],
) {
  const callbacks = {
    onEvent: vi.fn(),
    onHelloOk: vi.fn(),
    onConnectError: vi.fn(),
    onReconnectPaused: vi.fn(),
    onClose: vi.fn(),
    onWinningCandidate: vi.fn(),
  };
  return {
    callbacks,
    connection: createNodeHostGatewayCandidateConnection({
      candidates,
      clientOptions: {},
      cloudflareAccessByCandidate,
      ...callbacks,
    }),
  };
}

describe("gateway candidate connection", () => {
  beforeEach(() => {
    mocks.options.length = 0;
    mocks.clients.length = 0;
    vi.clearAllMocks();
  });

  it("rotates only before hello, fences stale callbacks, and forwards through the winner", async () => {
    const { callbacks, connection } = createConnection();
    connection.start();

    expect(mocks.options[0]?.url).toBe("ws://192.168.1.20:18789/openclaw-gw");
    expect(mocks.clients[0]?.start).toHaveBeenCalledOnce();
    mocks.options[0]?.onClose?.(1006, "transport unavailable", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    await vi.waitFor(() => expect(mocks.clients).toHaveLength(2));

    expect(mocks.clients[0]?.stop).toHaveBeenCalledOnce();
    expect(mocks.options[1]?.url).toBe("wss://gateway.tailnet.example:443");
    expect(mocks.clients[1]?.start).toHaveBeenCalledOnce();

    mocks.options[0]?.onEvent?.({ type: "event", event: "stale" });
    mocks.options[0]?.onHelloOk?.({} as never);
    mocks.options[0]?.onClose?.(1006, "stale close", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    expect(callbacks.onEvent).not.toHaveBeenCalled();
    expect(callbacks.onHelloOk).not.toHaveBeenCalled();
    expect(callbacks.onWinningCandidate).not.toHaveBeenCalled();
    expect(mocks.clients).toHaveLength(2);

    const activeEvent = { type: "event", event: "active" } as const;
    mocks.options[1]?.onEvent?.(activeEvent);
    mocks.options[1]?.onHelloOk?.({} as never);
    mocks.options[1]?.onHelloOk?.({} as never);
    expect(callbacks.onEvent).toHaveBeenCalledWith(activeEvent);
    expect(callbacks.onWinningCandidate).toHaveBeenCalledOnce();
    expect(callbacks.onWinningCandidate).toHaveBeenCalledWith(candidates[1]);

    await connection.request("node.test", { active: true }, undefined);
    connection.updateNodeManifest({ caps: ["mcp"], commands: ["mcp.tools.call.v1"] });
    expect(mocks.clients[0]?.request).not.toHaveBeenCalled();
    expect(mocks.clients[1]?.request).toHaveBeenCalledWith(
      "node.test",
      { active: true },
      undefined,
    );
    expect(mocks.clients[1]?.updateNodeManifest).toHaveBeenCalledWith({
      caps: ["mcp"],
      commands: ["mcp.tools.call.v1"],
    });
  });

  it("does not rotate after the connect request was sent", async () => {
    createConnection();

    mocks.options[0]?.onClose?.(1008, "connect failed", {
      phase: "pre-hello",
      socketOpened: true,
      transportValidated: true,
      connectRequestSent: true,
      transientPreHelloCleanClose: false,
    });
    await Promise.resolve();

    expect(mocks.clients).toHaveLength(1);
  });

  it("promotes a candidate after hello instead of replaying setup auth on another endpoint", async () => {
    const { callbacks } = createConnection();

    mocks.options[0]?.onHelloOk?.({} as never);
    mocks.options[0]?.onClose?.(1006, "later reconnect transport failure", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    await Promise.resolve();

    expect(callbacks.onWinningCandidate).toHaveBeenCalledWith(candidates[0]);
    expect(mocks.clients).toHaveLength(1);
  });

  it("carries a pre-hello manifest update into the next candidate", async () => {
    const { connection } = createConnection();
    const manifest = { caps: ["mcp"], commands: ["mcp.tools.call.v1"] };

    connection.updateNodeManifest(manifest);
    mocks.options[0]?.onClose?.(1006, "transport unavailable", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    await vi.waitFor(() => expect(mocks.clients).toHaveLength(2));

    expect(mocks.clients[1]?.updateNodeManifest).toHaveBeenCalledWith(manifest);
  });

  it("does not create the queued candidate after stop", async () => {
    const { connection } = createConnection();

    mocks.options[0]?.onClose?.(1006, "transport unavailable", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    connection.stop();
    await Promise.resolve();

    expect(mocks.clients).toHaveLength(1);
  });

  it("never carries origin-bound Access credentials to another candidate host", async () => {
    const credentials = { clientId: "test-key", clientSecret: "test-secret" };
    createConnection(new Map([[candidates[0]!, credentials]]));

    expect(mocks.options[0]?.edgeAuthHeaders).toEqual({
      "CF-Access-Client-Id": credentials.clientId,
      "CF-Access-Client-Secret": credentials.clientSecret,
    });
    mocks.options[0]?.onClose?.(1006, "transport unavailable", {
      phase: "pre-hello",
      socketOpened: false,
      transportValidated: false,
      connectRequestSent: false,
      transientPreHelloCleanClose: false,
    });
    await vi.waitFor(() => expect(mocks.clients).toHaveLength(2));

    expect(mocks.options[1]?.url).toBe("wss://gateway.tailnet.example:443");
    expect(mocks.options[1]?.edgeAuthHeaders).toBeUndefined();
  });
});