import { describe, expect, it } from "@effect/vitest";
import { ConnectionName, IntegrationSlug, type ArtifactBinding } from "@executor-js/sdk";

import {
  extractArtifactRoles,
  oldStyleAddressRejection,
  resolveArtifactBindings,
  resolveCallAddress,
  type BindableConnection,
} from "./artifact-bindings";

const connection = (
  integration: string,
  owner: "user" | "org",
  name: string,
): BindableConnection => ({ integration, owner, name });

const binding = (integration: string, owner: "user" | "org", name: string): ArtifactBinding => ({
  integration: IntegrationSlug.make(integration),
  owner,
  connection: ConnectionName.make(name),
});

describe("extractArtifactRoles", () => {
  it("reads the implicit role from a bare integration reference", () => {
    const roles = extractArtifactRoles(
      `function App(){ const q = useQuery(tools.vercel.domains.getDomains.queryOptions({ limit: 100 })); return null; }`,
    );
    expect(roles).toEqual([{ role: "vercel", integration: "vercel" }]);
  });

  it("collapses repeated references to one role", () => {
    const roles = extractArtifactRoles(
      `useQuery(tools.linear.issues.list.queryOptions({}));
       useMutation(tools.linear.issues.create.mutationOptions({}));
       queryClient.invalidateQueries(tools.linear.issues.list.queryFilter({}));`,
    );
    expect(roles).toEqual([{ role: "linear", integration: "linear" }]);
  });

  it("reads explicit roles from the call form, both quote flavours", () => {
    const roles = extractArtifactRoles(
      `useQuery(tools.linear("prod").issues.list.queryOptions({}));
       useQuery(tools.linear('staging').issues.list.queryOptions({}));`,
    );
    expect(roles).toEqual([
      { role: "prod", integration: "linear" },
      { role: "staging", integration: "linear" },
    ]);
  });

  it("mixes implicit and explicit roles across integrations", () => {
    const roles = extractArtifactRoles(
      `useQuery(tools.vercel.domains.getDomains.queryOptions({}));
       useQuery(tools.linear("prod").issues.list.queryOptions({}));
       useQuery(tools.github.issues.list.queryOptions({}));`,
    );
    expect(roles).toEqual([
      { role: "vercel", integration: "vercel" },
      { role: "prod", integration: "linear" },
      { role: "github", integration: "github" },
    ]);
  });

  it("ignores executor's own system tool roots", () => {
    const roles = extractArtifactRoles(
      `tools.search({ query: "x" }); tools.describe.tool({ path: "y" });
       tools.executor.coreTools.connections.list({});
       useQuery(tools.stripe.charges.list.queryOptions({}));`,
    );
    expect(roles).toEqual([{ role: "stripe", integration: "stripe" }]);
  });

  it("ignores references inside comments", () => {
    const roles = extractArtifactRoles(
      `// useQuery(tools.github.issues.list.queryOptions({}))
       /* tools.slack.chat.post */
       useQuery(tools.vercel.domains.getDomains.queryOptions({}));`,
    );
    expect(roles).toEqual([{ role: "vercel", integration: "vercel" }]);
  });

  it("does not read a property access that merely ends in tools", () => {
    expect(extractArtifactRoles(`const x = myTools.github.list();`)).toEqual([]);
    expect(extractArtifactRoles(`const x = a.tools.github.list();`)).toEqual([]);
  });

  it("finds nothing in code that calls no integration", () => {
    expect(extractArtifactRoles(`function App(){ return <div>hi</div>; }`)).toEqual([]);
  });
});

describe("oldStyleAddressRejection", () => {
  it("rejects a user-tier address and explains the short form", () => {
    const message = oldStyleAddressRejection(
      `useQuery(tools.vercel.user.personalVercel.domains.getDomains.queryOptions({}));`,
    );
    expect(message).toContain("tools.vercel.user.");
    expect(message).toContain("tools.vercel.<tool>(args)");
    expect(message).toContain("connections:");
  });

  it("rejects an org-tier address", () => {
    expect(
      oldStyleAddressRejection(`useQuery(tools.inventory.org.main.listItems.queryOptions({}));`),
    ).toContain("tools.inventory.org.");
  });

  it("accepts the short form", () => {
    expect(
      oldStyleAddressRejection(`useQuery(tools.vercel.domains.getDomains.queryOptions({}));`),
    ).toBeNull();
  });

  it("accepts the role form", () => {
    expect(
      oldStyleAddressRejection(`useQuery(tools.linear("prod").issues.list.queryOptions({}));`),
    ).toBeNull();
  });

  it("accepts a tool path whose later segments happen to be user or org", () => {
    expect(
      oldStyleAddressRejection(`useQuery(tools.acme.admin.user.get.queryOptions({}));`),
    ).toBeNull();
  });

  it("ignores an old-style address left in a comment", () => {
    expect(
      oldStyleAddressRejection(`// old: tools.vercel.user.personalVercel.domains.getDomains`),
    ).toBeNull();
  });
});

describe("resolveArtifactBindings", () => {
  it("binds a role silently when the author has exactly one connection", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "vercel", integration: "vercel" }],
      available: [connection("vercel", "user", "personalVercel")],
    });
    expect(result).toEqual({
      ok: true,
      bindings: { vercel: { integration: "vercel", owner: "user", connection: "personalVercel" } },
    });
  });

  it("infers each integration independently", () => {
    const result = resolveArtifactBindings({
      roles: [
        { role: "vercel", integration: "vercel" },
        { role: "linear", integration: "linear" },
      ],
      available: [
        connection("vercel", "user", "personalVercel"),
        connection("linear", "org", "workspaceLinear"),
      ],
    });
    expect(result.ok).toBe(true);
    if (!result.ok) return;
    expect(result.bindings.linear).toEqual({
      integration: "linear",
      owner: "org",
      connection: "workspaceLinear",
    });
  });

  it("refuses an ambiguous integration and lists the candidates", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "linear", integration: "linear" }],
      available: [
        connection("linear", "org", "linearProd"),
        connection("linear", "org", "linearStaging"),
      ],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("linear.org.linearProd");
    expect(result.message).toContain("linear.org.linearStaging");
    expect(result.message).toContain("connections");
  });

  it("refuses when the integration has no connection at all", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "stripe", integration: "stripe" }],
      available: [connection("vercel", "user", "personalVercel")],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("No stripe connection");
  });

  it("takes a supplied connection over inference", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "linear", integration: "linear" }],
      connections: { linear: "linear.org.linearStaging" },
      available: [
        connection("linear", "org", "linearProd"),
        connection("linear", "org", "linearStaging"),
      ],
    });
    expect(result.ok).toBe(true);
    if (!result.ok) return;
    expect(result.bindings.linear).toEqual({
      integration: "linear",
      owner: "org",
      connection: "linearStaging",
    });
  });

  it("accepts a supplied address that carries the tools. prefix", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "linear", integration: "linear" }],
      connections: { linear: "tools.linear.org.linearProd" },
      available: [connection("linear", "org", "linearProd")],
    });
    expect(result.ok).toBe(true);
  });

  it("binds two roles of one integration to different connections", () => {
    const result = resolveArtifactBindings({
      roles: [
        { role: "prod", integration: "linear" },
        { role: "staging", integration: "linear" },
      ],
      connections: { prod: "linear.org.linearProd", staging: "linear.user.myLinear" },
      available: [
        connection("linear", "org", "linearProd"),
        connection("linear", "user", "myLinear"),
      ],
    });
    expect(result).toEqual({
      ok: true,
      bindings: {
        prod: { integration: "linear", owner: "org", connection: "linearProd" },
        staging: { integration: "linear", owner: "user", connection: "myLinear" },
      },
    });
  });

  it("refuses a connections key that names no role in the code", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "vercel", integration: "vercel" }],
      connections: { linear: "linear.org.linearProd" },
      available: [connection("vercel", "user", "personalVercel")],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain('role "linear"');
    expect(result.message).toContain('"vercel"');
  });

  it("refuses a supplied connection that does not exist, with candidates", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "linear", integration: "linear" }],
      connections: { linear: "linear.org.gone" },
      available: [connection("linear", "org", "linearProd")],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("linear.org.gone");
    expect(result.message).toContain("linear.org.linearProd");
  });

  it("refuses a supplied connection belonging to another integration", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "prod", integration: "linear" }],
      connections: { prod: "vercel.user.personalVercel" },
      available: [
        connection("vercel", "user", "personalVercel"),
        connection("linear", "org", "linearProd"),
      ],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("vercel");
  });

  it("refuses a malformed connection address", () => {
    const result = resolveArtifactBindings({
      roles: [{ role: "linear", integration: "linear" }],
      connections: { linear: "linearProd" },
      available: [connection("linear", "org", "linearProd")],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("not a connection address");
  });

  it("refuses one role used for two integrations", () => {
    const result = resolveArtifactBindings({
      roles: [
        { role: "prod", integration: "linear" },
        { role: "prod", integration: "vercel" },
      ],
      available: [],
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.message).toContain("two different integrations");
  });

  it("binds nothing for code that calls no integration", () => {
    expect(resolveArtifactBindings({ roles: [], available: [] })).toEqual({
      ok: true,
      bindings: {},
    });
  });
});

describe("resolveCallAddress", () => {
  const bindings = {
    vercel: binding("vercel", "user", "personalVercel"),
    prod: binding("linear", "org", "linearProd"),
    staging: binding("linear", "user", "myLinear"),
  };

  it("expands a short path through the implicit role", () => {
    const result = resolveCallAddress({
      path: ["vercel", "domains", "getDomains"],
      bindings,
    });
    expect(result).toEqual({
      ok: true,
      path: ["vercel", "user", "personalVercel", "domains", "getDomains"],
    });
  });

  it("routes each explicit role to its own connection", () => {
    expect(
      resolveCallAddress({ path: ["linear", "issues", "list"], role: "prod", bindings }),
    ).toEqual({ ok: true, path: ["linear", "org", "linearProd", "issues", "list"] });
    expect(
      resolveCallAddress({ path: ["linear", "issues", "list"], role: "staging", bindings }),
    ).toEqual({ ok: true, path: ["linear", "user", "myLinear", "issues", "list"] });
  });

  it("passes system tools through untouched", () => {
    expect(resolveCallAddress({ path: ["search"], bindings })).toEqual({
      ok: true,
      path: ["search"],
    });
    expect(resolveCallAddress({ path: ["describe", "tool"], bindings })).toEqual({
      ok: true,
      path: ["describe", "tool"],
    });
  });

  it("fails with binding_unresolved when the role is not bound", () => {
    const result = resolveCallAddress({ path: ["stripe", "charges", "list"], bindings });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.error).toBe("binding_unresolved");
    expect(result.role).toBe("stripe");
    expect(result.integration).toBe("stripe");
    expect(result.message).toContain('"vercel"');
  });

  it("fails when a tagged role was never bound", () => {
    const result = resolveCallAddress({ path: ["linear", "issues", "list"], role: "qa", bindings });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.role).toBe("qa");
  });

  // Grandfather path: artifacts saved before bindings existed stored
  // five-segment paths and carry `bindings: null`.
  it("executes an old five-segment path when the artifact has no bindings", () => {
    expect(
      resolveCallAddress({
        path: ["inventory", "org", "main", "listItems"],
        bindings: null,
      }),
    ).toEqual({ ok: true, path: ["inventory", "org", "main", "listItems"] });
  });

  it("does not grandfather a short path", () => {
    const result = resolveCallAddress({ path: ["vercel", "getDomains"], bindings: null });
    expect(result.ok).toBe(false);
  });

  it("does not grandfather once the artifact has bindings", () => {
    const result = resolveCallAddress({
      path: ["inventory", "org", "main", "listItems"],
      bindings: { vercel: binding("vercel", "user", "personalVercel") },
    });
    expect(result.ok).toBe(false);
    if (result.ok) return;
    expect(result.error).toBe("binding_unresolved");
  });

  it("does not grandfather a role-tagged call", () => {
    const result = resolveCallAddress({
      path: ["inventory", "org", "main", "listItems"],
      role: "inv",
      bindings: null,
    });
    expect(result.ok).toBe(false);
  });
});