import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { formatShortcut, initializeShortcut, renderStaticShortcuts } from "../options/shortcut.js";

function setup(commands, os) {
  const elements = Object.fromEntries([
    "shortcut-intro", "shortcut-intro-key", "shortcut-keycaps", "shortcut-current", "change-shortcut",
  ].map((id) => [id, Object.assign(new EventTarget(), {
    textContent: "",
    hidden: true,
    children: [],
    replaceChildren(...children) { this.children = children; },
  })]));
  const document = Object.assign(new EventTarget(), {
    visibilityState: "visible",
    getElementById: (id) => elements[id],
    createElement: (tagName) => ({ tagName, className: "", textContent: "" }),
  });
  const window = new EventTarget();
  const ready = initializeShortcut({ commands, document, window, os });
  return { elements, document, window, ready };
}

const flush = () => new Promise((resolve) => setImmediate(resolve));
const command = (shortcut) => ({ name: "ask-chatgpt", description: "Ask ChatGPT", shortcut });
// The drawing's key caps and the "+" text between them, in order.
const drawn = (element) => element.children.map((child) => child.textContent ?? child);

test("shows the configured command rather than another command or the default", async () => {
  const { elements, ready } = setup({ getAll: async () => [
    { name: "other", description: "Other", shortcut: "Alt+O" }, command("Ctrl+Shift+Y"),
  ] });
  await ready;
  assert.equal(elements["shortcut-intro"].hidden, false);
  assert.equal(elements["shortcut-intro-key"].textContent, "<Ctrl>+<Shift>+Y");
  assert.equal(elements["shortcut-current"].textContent, "Current shortcut: <Ctrl>+<Shift>+Y");
  assert.deepEqual(drawn(elements["shortcut-keycaps"]), ["Ctrl", "+", "Shift", "+", "Y"]);
  assert.ok(elements["shortcut-keycaps"].children
    .filter((child) => typeof child !== "string")
    .every(({ tagName, className }) => tagName === "kbd" && className === "drawing-key"));
});

test("writes keys the way the page does, with Mac names on a Mac", () => {
  assert.equal(formatShortcut("Alt+Shift+G", "linux"), "<Alt>+<Shift>+G");
  assert.equal(formatShortcut("Ctrl+L", "win"), "<Ctrl>+L");
  assert.equal(formatShortcut("Enter", undefined), "<Enter>");
  assert.equal(formatShortcut("Ctrl+Shift+F5", "win"), "<Ctrl>+<Shift>+<F5>");
  // Firefox names punctuation and media keys rather than using the character.
  assert.equal(formatShortcut("Ctrl+Shift+Comma", "win"), "<Ctrl>+<Shift>+<Comma>");
  assert.equal(formatShortcut("MediaPlayPause", "linux"), "<MediaPlayPause>");
  assert.equal(formatShortcut("Alt+Shift+G", "mac"), "<Option>+<Shift>+G");
  // Firefox reads a manifest's Ctrl as Command on a Mac, and stores shortcuts
  // the user sets there with Command and MacCtrl.
  assert.equal(formatShortcut("Ctrl+L", "mac"), "<Cmd>+L");
  assert.equal(formatShortcut("Command+Shift+Y", "mac"), "<Cmd>+<Shift>+Y");
  assert.equal(formatShortcut("MacCtrl+Alt+Y", "mac"), "<Ctrl>+<Option>+Y");
  assert.equal(formatShortcut("Enter", "mac"), "<Return>");
});

test("a Mac shows its own key names for the configured shortcut", async () => {
  const { elements, ready } = setup({ getAll: async () => [command("Alt+Shift+G")] }, "mac");
  await ready;
  assert.equal(elements["shortcut-intro-key"].textContent, "<Option>+<Shift>+G");
  assert.deepEqual(drawn(elements["shortcut-keycaps"]), ["Option", "+", "Shift", "+", "G"]);
});

test("the page's written hotkeys match the formatter and are rewritten per platform", () => {
  const html = readFileSync(new URL("../options/options.html", import.meta.url), "utf8");
  const written = [...html.matchAll(/data-shortcut="([^"]+)">([^<]*)</g)];
  assert.ok(written.length >= 2);
  // Every hotkey must match the pattern above, or this test would skip it.
  assert.equal(written.length, html.split("data-shortcut=").length - 1);
  for (const [, shortcut, text] of written) {
    assert.equal(text.replaceAll("&lt;", "<").replaceAll("&gt;", ">"), formatShortcut(shortcut, "linux"));
  }

  const elements = written.map(([, shortcut]) => ({ dataset: { shortcut }, textContent: "" }));
  renderStaticShortcuts({ querySelectorAll: () => elements }, "mac");
  assert.deepEqual(
    elements.map(({ textContent }) => textContent),
    written.map(([, shortcut]) => formatShortcut(shortcut, "mac")),
  );
  assert.ok(elements.some(({ textContent }) => textContent === "<Cmd>+L"));
});

test("updates an open page when the shortcut is removed", async () => {
  let changed;
  let shortcut = "Alt+Shift+G";
  const { elements, ready } = setup({
    getAll: async () => [command(shortcut)],
    onChanged: { addListener: (listener) => { changed = listener; } },
  });
  await ready;
  shortcut = "";
  changed({ name: "ask-chatgpt", newShortcut: "", oldShortcut: "Alt+Shift+G" });
  await flush();
  assert.match(elements["shortcut-current"].textContent, /No keyboard shortcut assigned/);
  assert.equal(elements["shortcut-intro"].hidden, true);
  assert.equal(elements["shortcut-intro-key"].textContent, "");
  assert.deepEqual(elements["shortcut-keycaps"].children, []);
});

test("refreshes on focus and visibility without the change event API", async () => {
  let shortcut = "Alt+Shift+G";
  const { elements, window, document, ready } = setup({ getAll: async () => [command(shortcut)] });
  await ready;
  shortcut = "Ctrl+Shift+Y";
  window.dispatchEvent(new Event("focus"));
  await flush();
  assert.match(elements["shortcut-current"].textContent, /<Ctrl>\+<Shift>\+Y/);
  shortcut = "Alt+J";
  document.dispatchEvent(new Event("visibilitychange"));
  await flush();
  assert.match(elements["shortcut-current"].textContent, /<Alt>\+J/);
});

test("missing commands and failed reads never claim the default is assigned", async () => {
  for (const commands of [undefined, { getAll: async () => [] }, {
    getAll: async () => { throw new Error("Unavailable"); },
  }]) {
    const { elements, ready } = setup(commands);
    await ready;
    assert.doesNotMatch(elements["shortcut-current"].textContent, /<Alt>\+<Shift>\+G|Alt\+Shift\+G/);
    assert.equal(elements["shortcut-intro"].hidden, true);
    assert.equal(elements["change-shortcut"].hidden, true);
  }
});

test("shortcut editor failure displays manual recovery instructions", async () => {
  const { elements, ready } = setup({
    getAll: async () => [command("Alt+J")],
    openShortcutSettings: async () => { throw new Error("Unavailable"); },
  });
  await ready;
  assert.equal(elements["change-shortcut"].hidden, false);
  elements["change-shortcut"].dispatchEvent(new Event("click"));
  await flush();
  assert.match(elements["shortcut-current"].textContent, /Manage Extension Shortcuts/);
});