import { test } from "node:test";
import assert from "node:assert/strict";
import {
  matchAliases,
  mergeAliases,
  coerceAliasConfig,
  tokenizeQuery,
  slugifyAliasId,
  DEFAULT_ALIASES,
  type SearchAlias,
} from "./searchAliases";

const loli: SearchAlias = {
  id: "loli",
  label: "loli",
  triggers: ["loli", "lolly", "loly"],
  suggestion: "\\blol(i|ly)",
  useRegex: true,
};

test("tokenizeQuery splits on non-word chars and lowercases", () => {
  assert.deepEqual(tokenizeQuery("Loli Clips!"), ["loli", "clips"]);
  assert.deepEqual(tokenizeQuery("  "), []);
});

test("matchAliases fires on a whole-token match, any spelling", () => {
  assert.deepEqual(matchAliases("loli", "transcripts", [loli]), [loli]);
  assert.deepEqual(matchAliases("lolly", "transcripts", [loli]), [loli]);
  // Fires when the trigger is one token among several.
  assert.deepEqual(matchAliases("loli clips", "transcripts", [loli]), [loli]);
  // Case-insensitive.
  assert.deepEqual(matchAliases("LOLI", "transcripts", [loli]), [loli]);
});

test("matchAliases does NOT fire on a substring (whole-token only)", () => {
  assert.deepEqual(matchAliases("lolight", "transcripts", [loli]), []);
  assert.deepEqual(matchAliases("deloli", "transcripts", [loli]), []);
});

const platner: SearchAlias = {
  id: "platner",
  label: "Graham Platner",
  triggers: ["graham platner"],
  suggestion: "graham\\s+platner",
  useRegex: true,
};

test("matchAliases fires on a multi-word (phrase) trigger", () => {
  assert.deepEqual(
    matchAliases("graham platner", "transcripts", [platner]),
    [platner],
  );
  // Case-insensitive and whitespace-normalized.
  assert.deepEqual(
    matchAliases("Graham  Platner", "transcripts", [platner]),
    [platner],
  );
  // Fires when the phrase is a run of tokens among others (in order).
  assert.deepEqual(
    matchAliases("the graham platner interview", "transcripts", [platner]),
    [platner],
  );
});

test("matchAliases phrase trigger needs the whole phrase, in order", () => {
  // A single word of the phrase is not enough.
  assert.deepEqual(matchAliases("graham", "transcripts", [platner]), []);
  assert.deepEqual(matchAliases("platner", "transcripts", [platner]), []);
  // Wrong order does not match (contiguous, ordered).
  assert.deepEqual(matchAliases("platner graham", "transcripts", [platner]), []);
});

test("matchAliases in regexMode fires only on a bare-literal trigger", () => {
  // A plain typed literal equal to a trigger still gets upgraded.
  assert.deepEqual(
    matchAliases("graham platner", "transcripts", [platner], { regexMode: true }),
    [platner],
  );
  assert.deepEqual(
    matchAliases("loli", "transcripts", [loli], { regexMode: true }),
    [loli],
  );
  // A hand-written pattern or extra tokens is left alone.
  assert.deepEqual(
    matchAliases("graham\\s+platner", "transcripts", [platner], {
      regexMode: true,
    }),
    [],
  );
  assert.deepEqual(
    matchAliases("graham platner clips", "transcripts", [platner], {
      regexMode: true,
    }),
    [],
  );
  // An already-applied suggestion does not re-offer.
  assert.deepEqual(
    matchAliases("\\blol(i|ly)", "transcripts", [loli], { regexMode: true }),
    [],
  );
});

test("matchAliases respects the enabled flag", () => {
  const off = { ...loli, enabled: false };
  assert.deepEqual(matchAliases("loli", "transcripts", [off]), []);
});

test("matchAliases respects an optional scope restriction", () => {
  const scoped = { ...loli, scopes: ["transcripts" as const] };
  assert.deepEqual(matchAliases("loli", "transcripts", [scoped]), [scoped]);
  assert.deepEqual(matchAliases("loli", "tags", [scoped]), []);
  // Absent scopes = every scope.
  assert.deepEqual(matchAliases("loli", "tags", [loli]), [loli]);
});

test("matchAliases returns nothing for an empty query", () => {
  assert.deepEqual(matchAliases("", "transcripts", [loli]), []);
});

test("mergeAliases: per-site shadows global by id, else appends", () => {
  const global = [loli, { ...loli, id: "youtube", label: "YouTube" }];
  const override = { ...loli, suggestion: "OVERRIDDEN" };
  const extra = { ...loli, id: "extra", label: "extra" };
  const merged = mergeAliases(global, [override, extra]);
  assert.equal(merged.length, 3);
  assert.equal(merged.find((a) => a.id === "loli")?.suggestion, "OVERRIDDEN");
  assert.ok(merged.some((a) => a.id === "extra"));
  assert.ok(merged.some((a) => a.id === "youtube"));
});

test("mergeAliases: a per-site disable hides a global alias", () => {
  const merged = mergeAliases([loli], [{ ...loli, enabled: false }]);
  assert.equal(matchAliases("loli", "transcripts", merged).length, 0);
});

test("coerceAliasConfig drops malformed entries and defaults flags", () => {
  const cfg = coerceAliasConfig({
    aliases: [
      { label: "ok", triggers: ["a"], suggestion: "x" }, // valid, id derived
      { label: "no triggers", triggers: [], suggestion: "x" }, // dropped
      { label: "no suggestion", triggers: ["a"] }, // dropped
      "garbage",
      null,
    ],
  });
  assert.equal(cfg.aliases.length, 1);
  const a = cfg.aliases[0];
  assert.equal(a.id, "ok"); // slugified from label
  assert.equal(a.useRegex, true); // default
  assert.equal(a.enabled, true); // default
});

test("coerceAliasConfig preserves explicit useRegex:false and enabled:false", () => {
  const cfg = coerceAliasConfig({
    aliases: [
      {
        label: "x",
        triggers: ["a"],
        suggestion: "s",
        useRegex: false,
        enabled: false,
      },
    ],
  });
  assert.equal(cfg.aliases[0].useRegex, false);
  assert.equal(cfg.aliases[0].enabled, false);
});

test("coerceAliasConfig on non-object input yields an empty list", () => {
  assert.deepEqual(coerceAliasConfig(null), { aliases: [] });
  assert.deepEqual(coerceAliasConfig("nope"), { aliases: [] });
  assert.deepEqual(coerceAliasConfig({}), { aliases: [] });
});

test("slugifyAliasId produces a stable slug", () => {
  assert.equal(slugifyAliasId("Hello World!"), "hello-world");
  assert.equal(slugifyAliasId("  "), "alias");
});

test("DEFAULT_ALIASES include the canonical loli concept and are well-formed", () => {
  const coerced = coerceAliasConfig({ aliases: DEFAULT_ALIASES });
  assert.equal(coerced.aliases.length, DEFAULT_ALIASES.length);
  assert.ok(DEFAULT_ALIASES.some((a) => a.id === "loli"));
  assert.deepEqual(
    matchAliases("lolly", "transcripts", DEFAULT_ALIASES).map((a) => a.id),
    ["loli"],
  );
});