// An opened agent card's allowed-domains editor: which entries one agent sees and
// the bodies it sends. Run by `npm test` with Node's type stripping.
import assert from "node:assert/strict";
import { test } from "node:test";
import {
  allowedSummary,
  entryGroups,
  swarmWideEntries,
  behindNote,
  entriesFor,
  entryBody,
} from "../src/agent/detail/allowed-domains.ts";

const all = [
  { domain: "crates.io", agent: "atlas" },
  { domain: "docs.rs", agent: "argus" },
  { domain: "github.com" },
  { domain: "pypi.org", agent: "atlas" },
];

test("an agent sees the swarm-wide entries first, then its own, and not another agent's", () => {
  assert.deepEqual(entriesFor(all, "atlas"), [
    { domain: "github.com" },
    { domain: "crates.io", agent: "atlas" },
    { domain: "pypi.org", agent: "atlas" },
  ]);
  // Control: the other agent's entry is there to be found.
  assert.deepEqual(entriesFor(all, "argus"), [
    { domain: "github.com" },
    { domain: "docs.rs", agent: "argus" },
  ]);
  assert.deepEqual(entriesFor(all, "iris"), [{ domain: "github.com" }]);
  assert.deepEqual(entriesFor([], "atlas"), []);
});

test("the summary counts each scope", () => {
  assert.equal(allowedSummary([]), "none added");
  assert.equal(
    allowedSummary(entriesFor(all, "atlas")),
    "1 swarm-wide, 2 for this agent",
  );
  assert.equal(allowedSummary(entriesFor(all, "iris")), "1 swarm-wide");
  assert.equal(
    allowedSummary([{ domain: "a.io", agent: "atlas" }]),
    "1 for this agent",
  );
});

test("the body is swarm-wide or for the agent, with the name trimmed", () => {
  assert.deepEqual(entryBody("  github.com ", true, "atlas"), {
    domain: "github.com",
  });
  assert.deepEqual(entryBody("github.com", false, "atlas"), {
    domain: "github.com",
    agent: "atlas",
  });
});

test("a derived entry is counted as automatic, not as the operator's own", () => {
  const derived = { domain: "llm.example.com", agent: "atlas", derived: true };
  assert.equal(
    allowedSummary([...entriesFor(all, "atlas"), derived]),
    "1 swarm-wide, 2 for this agent, 1 automatic",
  );
  assert.equal(allowedSummary([derived]), "1 automatic");
  assert.deepEqual(entriesFor([derived], "atlas"), [derived]);
});

test("entries are grouped by source, empty sources left out", () => {
  const derived = { domain: "auto.io", agent: "atlas", derived: true };
  const groups = entryGroups([
    { domain: "a.io" },
    { domain: "b.io", agent: "atlas" },
    derived,
  ]);
  assert.deepEqual(
    groups.map((g) => [g.source, g.entries.length]),
    [
      ["swarm-wide", 1],
      ["own", 1],
      ["automatic", 1],
    ],
  );
  assert.deepEqual(
    entryGroups([{ domain: "a.io" }]).map((g) => g.source),
    ["swarm-wide"],
  );
  assert.deepEqual(entryGroups([]), []);
});

test("the egress card lists only the entries that hold for every agent", () => {
  const entries = [
    { domain: "crates.io" },
    { domain: "docs.rs", agent: "iris" },
    { domain: "api.example.com", derived: true },
    { domain: "github.com" },
  ];
  assert.deepEqual(
    swarmWideEntries(entries).map((e) => e.domain),
    ["crates.io", "github.com"],
  );
  assert.deepEqual(swarmWideEntries([]), []);
});

test("an add from the swarm page, with no agent, is a swarm-wide entry", () => {
  assert.deepEqual(entryBody("github.com", true, ""), { domain: "github.com" });
});

test("the deny list names the hives that have not applied it, and says nothing when none is behind", () => {
  assert.equal(behindNote([]), null);
  assert.match(behindNote(["pr1ma"]), /^pr1ma has not applied this list yet/);
  assert.match(
    behindNote(["pr1ma", "mu3de"]),
    /^pr1ma, mu3de have not applied this list yet/,
  );
});