import { describe, expect, it } from "vitest";
import {
  createMcpPermissionTargets,
  McpTargetList,
  parseQualifiedMcpToolName,
} from "#src/access-intent/mcp-targets";

describe("parseQualifiedMcpToolName", () => {
  it("returns server and tool for a valid qualified name", () => {
    expect(parseQualifiedMcpToolName("exa:search")).toEqual({
      server: "exa",
      tool: "search",
    });
  });

  it("returns server and tool with surrounding whitespace trimmed", () => {
    expect(parseQualifiedMcpToolName("  exa : search  ")).toEqual({
      server: "exa",
      tool: "search",
    });
  });

  it("returns null for empty or whitespace-only string", () => {
    expect(parseQualifiedMcpToolName("")).toBeNull();
    expect(parseQualifiedMcpToolName("   ")).toBeNull();
  });

  it("returns null when colon is the first character", () => {
    expect(parseQualifiedMcpToolName(":search")).toBeNull();
  });

  it("returns null when colon is the last character", () => {
    expect(parseQualifiedMcpToolName("exa:")).toBeNull();
  });

  it("returns null for a plain tool name with no colon", () => {
    expect(parseQualifiedMcpToolName("exa_search")).toBeNull();
  });

  it("returns null when either part is empty after trimming", () => {
    expect(parseQualifiedMcpToolName(" :search")).toBeNull();
    expect(parseQualifiedMcpToolName("exa: ")).toBeNull();
  });
});

describe("createMcpPermissionTargets", () => {
  describe("tool call (input.tool)", () => {
    it("produces targets for a bare tool name with no configured servers", () => {
      const targets = createMcpPermissionTargets({ tool: "exa_search" }, []);
      expect(targets).toContain("exa_search");
      expect(targets).toContain("mcp_call");
    });

    it("produces targets for a qualified tool name (server:tool)", () => {
      const targets = createMcpPermissionTargets({ tool: "exa:search" }, []);
      expect(targets).toContain("exa_search");
      expect(targets).toContain("exa:search");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_call");
    });

    it("produces targets for a tool call with explicit server field", () => {
      const targets = createMcpPermissionTargets(
        { tool: "search", server: "exa" },
        [],
      );
      expect(targets).toContain("exa_search");
      expect(targets).toContain("exa:search");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_call");
    });

    it("derives server targets from configured server names when tool name ends with _<server>", () => {
      const targets = createMcpPermissionTargets({ tool: "search_exa" }, [
        "exa",
      ]);
      expect(targets).toContain("exa_search_exa");
      expect(targets).toContain("exa:search_exa");
      expect(targets).toContain("exa");
    });

    it("does not derive server targets for names not ending in _<server>", () => {
      const targets = createMcpPermissionTargets({ tool: "exa_search" }, [
        "exa",
      ]);
      expect(targets).toContain("exa_search");
      expect(targets).not.toContain("exa");
      expect(targets).not.toContain("exa:exa_search");
    });
  });

  describe("connect call (input.connect)", () => {
    it("produces targets for a connect operation", () => {
      const targets = createMcpPermissionTargets({ connect: "exa" }, []);
      expect(targets).toContain("mcp_connect_exa");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_connect");
    });

    it("does not include mcp_call for connect operations", () => {
      const targets = createMcpPermissionTargets({ connect: "exa" }, []);
      expect(targets).not.toContain("mcp_call");
    });
  });

  describe("describe operation (input.describe)", () => {
    it("produces targets for a describe operation on a qualified tool", () => {
      const targets = createMcpPermissionTargets(
        { describe: "exa:search" },
        [],
      );
      expect(targets).toContain("exa_search");
      expect(targets).toContain("exa:search");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_describe");
    });
  });

  describe("search operation (input.search)", () => {
    it("produces mcp_search and the search string as targets", () => {
      const targets = createMcpPermissionTargets({ search: "weather" }, []);
      expect(targets).toContain("weather");
      expect(targets).toContain("mcp_search");
    });

    it("includes server targets when server is provided alongside search", () => {
      const targets = createMcpPermissionTargets(
        { search: "weather", server: "exa" },
        [],
      );
      expect(targets).toContain("mcp_server_exa");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_search");
    });
  });

  describe("server listing (input.server only)", () => {
    it("produces mcp_list and server-specific targets", () => {
      const targets = createMcpPermissionTargets({ server: "exa" }, []);
      expect(targets).toContain("mcp_server_exa");
      expect(targets).toContain("exa");
      expect(targets).toContain("mcp_list");
    });
  });

  describe("status (no meaningful input)", () => {
    it("produces mcp_status for empty input", () => {
      const targets = createMcpPermissionTargets({}, []);
      expect(targets).toContain("mcp_status");
    });

    it("produces mcp_status for null or unrecognized input", () => {
      expect(createMcpPermissionTargets(null, [])).toContain("mcp_status");
      expect(
        createMcpPermissionTargets({ unrelated: "value" }, ["exa"]),
      ).toContain("mcp_status");
    });
  });

  describe("priority ordering", () => {
    it("tool targets appear before mcp_call", () => {
      const targets = createMcpPermissionTargets({ tool: "exa:search" }, []);
      const mcpCallIdx = targets.indexOf("mcp_call");
      const exaSearchIdx = targets.indexOf("exa_search");
      expect(exaSearchIdx).toBeGreaterThanOrEqual(0);
      expect(mcpCallIdx).toBeGreaterThan(exaSearchIdx);
    });
  });
});

describe("McpTargetList", () => {
  describe("add", () => {
    it("ignores null", () => {
      const list = new McpTargetList();
      list.add(null);
      expect(list.toArray()).toEqual([]);
    });

    it("ignores empty string", () => {
      const list = new McpTargetList();
      list.add("");
      expect(list.toArray()).toEqual([]);
    });

    it("appends a new value", () => {
      const list = new McpTargetList();
      list.add("exa");
      expect(list.toArray()).toEqual(["exa"]);
    });

    it("dedups repeated values", () => {
      const list = new McpTargetList();
      list.add("exa");
      list.add("exa");
      expect(list.toArray()).toEqual(["exa"]);
    });

    it("preserves first-insertion order across a mix of values", () => {
      const list = new McpTargetList();
      list.add("exa_search");
      list.add("exa:search");
      list.add("exa");
      list.add("exa_search"); // duplicate — must not change order
      list.add("mcp_call");
      expect(list.toArray()).toEqual([
        "exa_search",
        "exa:search",
        "exa",
        "mcp_call",
      ]);
    });
  });

  describe("toArray", () => {
    it("returns an independent copy that does not mutate the list", () => {
      const list = new McpTargetList();
      list.add("exa");
      const first = list.toArray();
      first.push("mutated");
      expect(list.toArray()).toEqual(["exa"]);
    });
  });
});