import test from "node:test";
import assert from "node:assert/strict";
import {
  inferTransport,
  normalizeSharedMcpServer,
  toClaudeServerConfig,
  toCodexServerConfig,
} from "../src/mcp/converters.js";
import { parseMcpConfig } from "../src/mcp/types.js";

test("infers stdio transport when url is absent", () => {
  const transport = inferTransport({
    command: "npx",
    args: ["-y", "@modelcontextprotocol/server-memory"],
  });
  assert.equal(transport, "stdio");
});

test("infers http transport when url is present", () => {
  const transport = inferTransport({
    url: "http://localhost:3000/mcp",
  });
  assert.equal(transport, "http");
});

test("throws for stdio codex server without command", () => {
  assert.throws(
    () => toCodexServerConfig("bad-server", { type: "stdio" }),
    /requires "command" for stdio transport/,
  );
});

test("maps shared headers to codex http_headers", () => {
  const codexConfig = toCodexServerConfig("headers-server", {
    url: "http://localhost:3000/mcp",
    headers: {
      Authorization: "Bearer token",
    },
  });

  assert.deepEqual(codexConfig.http_headers, {
    Authorization: "Bearer token",
  });
});

test("normalizes headers into a single headers object", () => {
  const normalized = normalizeSharedMcpServer({
    url: "http://localhost:3000/mcp",
    headers: {
      Authorization: "Bearer token",
    },
  });

  assert.deepEqual(normalized.headers, {
    Authorization: "Bearer token",
  });
});

test("rejects legacy shared MCP header alias http_headers", () => {
  assert.throws(
    () =>
      parseMcpConfig({
        servers: {
          legacy: {
            type: "http",
            url: "http://localhost:3000/mcp",
            http_headers: {
              Authorization: "Bearer token",
            },
          },
        },
      }),
    /unrecognized key/i,
  );
});

test("throws for claude http server without url", () => {
  assert.throws(
    () => toClaudeServerConfig("bad-http", { type: "http" }),
    /requires "url" for http transport/,
  );
});

test("maps sdk transport for claude conversion", () => {
  const claudeConfig = toClaudeServerConfig("local-sdk", {
    type: "sdk",
    name: "local-sdk-server",
  });

  assert.deepEqual(claudeConfig, {
    type: "sdk",
    name: "local-sdk-server",
  });
});

test("throws when sdk transport is converted for codex", () => {
  assert.throws(
    () => toCodexServerConfig("sdk-server", { type: "sdk", name: "sdk-server" }),
    /not supported by Codex/,
  );
});

test("accepts sdk transport in strict MCP schema", () => {
  const parsed = parseMcpConfig({
    servers: {
      "sdk-server": {
        type: "sdk",
        name: "sdk-server",
      },
    },
  });

  assert.equal(parsed.servers?.["sdk-server"]?.type, "sdk");
});

test("rejects unknown fields in strict MCP schema", () => {
  assert.throws(
    () =>
      parseMcpConfig({
        servers: {
          broken: {
            type: "stdio",
            command: "node",
            extra: "nope",
          },
        },
      }),
    /unrecognized key/i,
  );
});