// tokens.css completeness and parity. The token sheet is hand-written CSS and
// lib/brand.ts is the palette as data; this test is what keeps the two equal,
// and what catches a base that forgets a token (which fails SILENTLY in a
// browser: it inherits the light block's value, since `:root` always matches).

import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import {
  ACCENTS,
  ACCENT_IDS,
  BASE_GROUND_IDS,
  BASE_GROUNDS,
  contrastRatio,
  type BaseGround,
} from "../lib/brand";
import { customAccentVars } from "../lib/accent";
import { REQUIRED_TOKENS } from "./themeConfig";

const CSS = readFileSync(
  fileURLToPath(new URL("../styles/tokens.css", import.meta.url)),
  "utf8",
);

type Rule = { selector: string; decls: Map<string, string>; index: number; body: string };

// Top-level rules only. An at-rule (`@theme inline`, the `@media` block) gets no
// declarations but keeps its raw `body`, which a test can parse again for the
// rules nested in it. Comments are stripped first.
function parseRules(css: string): Rule[] {
  const src = css.replace(/\/\*[\s\S]*?\*\//g, "");
  const rules: Rule[] = [];
  let i = 0;
  while (i < src.length) {
    const open = src.indexOf("{", i);
    if (open < 0) break;
    const selector = src.slice(i, open).replace(/^[\s;]*(@import[^;]*;|@custom-variant[^;]*;)?/g, "").trim();
    let depth = 1;
    let j = open + 1;
    while (j < src.length && depth > 0) {
      if (src[j] === "{") depth++;
      else if (src[j] === "}") depth--;
      j++;
    }
    const body = src.slice(open + 1, j - 1);
    const decls = new Map<string, string>();
    if (!selector.startsWith("@")) {
      for (const part of body.split(";")) {
        const k = part.indexOf(":");
        if (k < 0) continue;
        const name = part.slice(0, k).trim();
        if (name) decls.set(name, part.slice(k + 1).trim());
      }
    }
    rules.push({ selector: selector.replace(/\s+/g, " "), decls, index: rules.length, body });
    i = j;
  }
  return rules;
}

const RULES = parseRules(CSS);

function rule(selector: string): Rule {
  const r = RULES.find((x) => x.selector === selector);
  assert.ok(r, `tokens.css has no rule for ${selector}`);
  return r;
}

const BASE_SELECTOR: Record<BaseGround, string> = {
  light: ':root, html[data-base="light"]',
  dark: 'html[data-base="dark"]',
};

const ON: Record<BaseGround, "onLight" | "onDark"> = {
  light: "onLight",
  dark: "onDark",
};

test("two bases: tokens.css has a block for light and dark and none for any other", () => {
  const blocks = RULES.map((r) => r.selector.match(/html\[data-base="([^"]+)"\]/g) ?? [])
    .flat()
    .map((sel) => sel.slice('html[data-base="'.length, -2));
  assert.deepEqual([...new Set(blocks)].sort(), ["dark", "light"]);
  assert.deepEqual([...BASE_GROUND_IDS], ["light", "dark"]);
});

test("every base declares every required token, color-scheme and every swatch", () => {
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (const t of REQUIRED_TOKENS) {
      assert.ok(r.decls.has(t), `${base} is missing ${t}`);
      assert.notEqual(r.decls.get(t), "", `${base} declares ${t} empty`);
    }
    assert.equal(r.decls.get("color-scheme"), base === "dark" ? "dark" : "light");
    for (const id of ACCENT_IDS) assert.ok(r.decls.has(`--swatch-${id}`), `${base} is missing --swatch-${id}`);
    assert.ok(r.decls.has("--swatch-custom"), `${base} is missing --swatch-custom`);
  }
});

test("--base-light|dark are 1 on their own base and 0 on the other", () => {
  // lib/siteColor.ts perBaseColor multiplies each base's channel by these, so
  // exactly one may be 1 — two would add two colours' channels together.
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (const b of BASE_GROUND_IDS) {
      assert.equal(r.decls.get(`--base-${b}`), b === base ? "1" : "0", `${base} --base-${b}`);
    }
  }
});

test("REQUIRED_TOKENS is the 50 colour tokens, each once", () => {
  assert.equal(REQUIRED_TOKENS.length, 50);
  assert.equal(new Set(REQUIRED_TOKENS).size, REQUIRED_TOKENS.length);
});

test("--background is each base's ground (lib/brand.ts BASE_GROUNDS)", () => {
  for (const base of BASE_GROUND_IDS) {
    assert.equal(rule(BASE_SELECTOR[base]).decls.get("--background"), BASE_GROUNDS[base]);
  }
});

test("each base's --swatch-<id> is that accent's value on that ground (ACCENTS)", () => {
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (const id of ACCENT_IDS) {
      assert.equal(r.decls.get(`--swatch-${id}`), ACCENTS[id][ON[base]], `${base} --swatch-${id}`);
    }
  }
});

test("--swatch-custom reads the inline var customAccentVars writes for that base", () => {
  const vars = customAccentVars("#cc3366");
  assert.ok(vars);
  for (const base of BASE_GROUND_IDS) {
    const name = `--accent-custom-${base}`;
    assert.ok(name in vars, `customAccentVars has no ${name}`);
    assert.equal(
      rule(BASE_SELECTOR[base]).decls.get("--swatch-custom"),
      `var(${name}, var(--swatch-signal))`,
    );
  }
});

test("each base defaults --brand to Signal, keeps --primary neutral and rings in the accent", () => {
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    assert.equal(r.decls.get("--brand"), "var(--swatch-signal)");
    assert.equal(r.decls.get("--ring"), "var(--brand)");
    assert.doesNotMatch(r.decls.get("--primary") ?? "", /brand|swatch/);
    assert.equal(r.decls.get("--primary"), base === "dark" ? "#efe7d8" : "#202a31");
    assert.equal(r.decls.get("--brand-ink"), base === "dark" ? BASE_GROUNDS.dark : "#ffffff");
    assert.match(r.decls.get("--brand-strong") ?? "", base === "dark" ? /var\(--brand\).*white/ : /var\(--brand\).*black/);
    assert.match(r.decls.get("--brand-soft") ?? "", base === "dark" ? /var\(--brand\) 16%/ : /var\(--brand\) 12%/);
  }
});

test("an accent rule per id sets --brand to its swatch and --brand-mark to its on-dark value", () => {
  for (const id of ACCENT_IDS) {
    const r = rule(`html[data-accent="${id}"]`);
    assert.equal(r.decls.get("--brand"), `var(--swatch-${id})`);
    assert.equal(r.decls.get("--brand-mark"), ACCENTS[id].onDark);
  }
  const custom = rule('html[data-accent="custom"]');
  assert.equal(custom.decls.get("--brand"), "var(--swatch-custom)");
  assert.match(custom.decls.get("--brand-mark") ?? "", /^var\(--accent-custom-dark\b/);
});

test("the accent rules come after every base block (same specificity, later wins)", () => {
  const lastBase = Math.max(...BASE_GROUND_IDS.map((b) => rule(BASE_SELECTOR[b]).index));
  for (const id of [...ACCENT_IDS, "custom"]) {
    assert.ok(rule(`html[data-accent="${id}"]`).index > lastBase, `${id} precedes a base block`);
  }
});

test(":root sets the one radius and a Signal --brand-mark default; .font-display runs wide", () => {
  const root = rule(":root");
  assert.equal(root.decls.get("--radius"), "0.375rem");
  assert.equal(root.decls.get("--brand-mark"), ACCENTS.signal.onDark);
  assert.equal(rule(".font-display").decls.get("font-stretch"), "112%");
});

test("geometricPrecision is on the root and form controls from 1.5dppx up only", () => {
  // Hinted whole-pixel advances split words from DPR 1.5 on Linux ("Sig nal");
  // at 1x and 1.25x the hinted glyph fills them and keeps small text crisp, so
  // the rule must not reach them. Form controls are named too: the UA sheet
  // resets their text-rendering to auto.
  const media = rule("@media (min-resolution: 1.5dppx)");
  const inner = parseRules(media.body);
  assert.equal(inner.length, 1);
  assert.equal(inner[0].selector, "html, button, input, select, textarea");
  assert.equal(inner[0].decls.get("text-rendering"), "geometricPrecision");
  assert.ok(
    !RULES.some((r) => r.decls.has("text-rendering")),
    "a top-level text-rendering rule reaches 1x screens",
  );
});

test("no retired theme family is left in the sheet", () => {
  assert.doesNotMatch(CSS, /data-theme/);
  assert.doesNotMatch(CSS, /--font-(grotesk|plex|code)/);
  assert.ok(!RULES.some((r) => r.selector === ".dark"), "a .dark token block is back");
});

test("charts stay off the accent and off the gone colour", () => {
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (let n = 1; n <= 6; n++) assert.match(r.decls.get(`--chart-${n}`) ?? "", /^#[0-9a-f]{6}$/);
    // Six different colours on every base (the sixth, release 11, is a
    // validated slot of its own, not a repeat or the golden angle).
    const six = [1, 2, 3, 4, 5, 6].map((n) => r.decls.get(`--chart-${n}`));
    assert.equal(new Set(six).size, 6, `${base}: ${six.join(" ")}`);
    assert.notEqual(r.decls.get("--chart-6"), r.decls.get("--state-gone"));
    // FACTS.md ~6442: chart-3 once WAS the gone hex; the palette itself was
    // re-validated with the dataviz validator (plans/brand-and-themes.md, S2).
    assert.notEqual(r.decls.get("--chart-3"), r.decls.get("--state-gone"));
    assert.notEqual(r.decls.get("--chart-1"), ACCENTS.signal[ON[base]]);
    assert.notEqual(r.decls.get("--chart-1"), r.decls.get("--swatch-signal"));
  }
});

test("text tokens read at 4.5:1 on each base's ground and card", () => {
  const TEXT = [
    "--foreground",
    "--muted-foreground",
    "--destructive",
    "--success",
    "--warning",
    "--info",
    "--state-gone",
  ];
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (const bg of ["--background", "--card"]) {
      for (const t of TEXT) {
        const ratio = contrastRatio(r.decls.get(t)!, r.decls.get(bg)!);
        assert.ok(ratio >= 4.5, `${base}: ${t} on ${bg} is ${ratio.toFixed(2)}:1`);
      }
    }
    const inkOn = contrastRatio(r.decls.get("--primary-foreground")!, r.decls.get("--primary")!);
    assert.ok(inkOn >= 4.5, `${base}: primary-foreground on primary is ${inkOn.toFixed(2)}:1`);
  }
});

// "Soft = a low-alpha tint of the hue for badge/alert fills; the base color is
// tuned to read as TEXT on that soft fill" (tokens.css @theme). Every base
// keeps that promise on the ground and on a card. (Light's success and warning
// read 4.18 / 3.89 on their fills until the brand's integrate slice deepened
// them.)
function compositeOver(rgba: string, ground: string): string {
  const m = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*([\d.]+)\)$/.exec(rgba);
  assert.ok(m, `not an rgba(): ${rgba}`);
  const a = Number(m[4]);
  const g = parseInt(ground.slice(1), 16);
  const G = [(g >> 16) & 255, (g >> 8) & 255, g & 255];
  const out = [1, 2, 3].map((i, k) => Math.round(Number(m[i]) * a + G[k] * (1 - a)));
  return `#${out.map((v) => v.toString(16).padStart(2, "0")).join("")}`;
}

test("status text reads at 4.5:1 on its own soft fill, on every base", () => {
  const PAIRS = [
    ["--success", "--success-soft"],
    ["--warning", "--warning-soft"],
    ["--info", "--info-soft"],
    ["--destructive", "--destructive-soft"],
    ["--state-gone", "--state-gone-soft"],
  ] as const;
  let checks = 0;
  for (const base of BASE_GROUND_IDS) {
    const r = rule(BASE_SELECTOR[base]);
    for (const bg of ["--background", "--card"]) {
      for (const [text, soft] of PAIRS) {
        checks++;
        const fill = compositeOver(r.decls.get(soft)!, r.decls.get(bg)!);
        const ratio = contrastRatio(r.decls.get(text)!, fill);
        assert.ok(ratio >= 4.5, `${base}: ${text} on ${soft} over ${bg} is ${ratio.toFixed(2)}:1`);
      }
    }
  }
  assert.equal(checks, 20); // 2 bases × 2 grounds × 5 pairs
});