// chrome_type before/after evidence, replace=true, navigation-aware includeSnapshot, and tab.new load
// settling. Chrome and the page are mocked; live caret behavior is covered by challenge 44.
import assert from "node:assert/strict";
import fs from "node:fs";
import vm from "node:vm";
import { stripTypeScriptTypes } from "node:module";
import { test } from "node:test";

const workerSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/browser-extension/service_worker.js", import.meta.url), "utf8");
const indexSource = fs.readFileSync(new URL("../../extensions/chrome-profile-bridge/index.ts", import.meta.url), "utf8");
const clone = (value) => JSON.parse(JSON.stringify(value));

function makeInput({ value = "", caret = value.length, type = "text", name = "q" } = {}) {
  return {
    tagName: "INPUT", type, name, id: name, isConnected: true, isContentEditable: false,
    value, selectionStart: caret, selectionEnd: caret,
    getAttribute(attr) { return attr === "type" ? this.type : attr === "name" ? this.name : null; },
    scrollIntoView() {}, getBoundingClientRect: () => ({ left: 10, top: 10, width: 300, height: 30 }),
    focus() {},
  };
}

function harness(element, { platform = "MacIntel", tabs = {} } = {}) {
  const calls = [];
  const listeners = new Set();
  const page = vm.createContext({
    document: { activeElement: element, querySelector: (s) => (s === "#q" ? element : null), createRange: () => ({}) },
    getSelection: () => null,
    location: { href: "https://fixture.test/" },
    __PI_CHROME_STATE__: { elements: { "el-1": element } },
  });
  page.window = page;
  const listener = { addListener() {}, removeListener() {} };
  const chrome = {
    runtime: { id: "test", getManifest: () => ({ version: "0.0.1" }), onInstalled: listener, onStartup: listener },
    alarms: { create() {}, onAlarm: listener }, action: { onClicked: listener }, webNavigation: { onCommitted: listener },
    debugger: { onDetach: listener },
    scripting: { executeScript: async ({ func, args = [] }) => [{ result: await vm.runInContext(`(${func.toString()})`, page)(...args) }] },
    tabs: {
      onUpdated: { addListener: (fn) => listeners.add(fn), removeListener: (fn) => listeners.delete(fn) },
      get: async (id) => clone(tabs[id] ?? { id, windowId: 1, url: "https://fixture.test/", status: "complete" }),
    },
  };
  const worker = { chrome, console, AbortController, setTimeout, clearTimeout, setInterval: () => 0, navigator: { userAgent: "unit-test", platform }, fetch: async () => { throw new Error("offline"); } };
  worker.self = worker;
  vm.runInNewContext(workerSource, worker);
  worker.sleep = async () => {};
  worker.getTabByParams = async (params) => clone(tabs[Number(params.targetId ?? 2)] ?? { id: Number(params.targetId ?? 2), windowId: 1, url: "https://fixture.test/", status: "complete" });
  worker.bringToFront = async (tab) => tab;
  worker.attachDebugger = async () => {};
  worker.cdpMoveTo = async () => {};
  const splice = (text) => {
    if (typeof element.value !== "string") return;
    const { value, selectionStart: s, selectionEnd: e } = element;
    element.value = value.slice(0, s) + text + value.slice(e);
    element.selectionStart = element.selectionEnd = s + text.length;
  };
  worker.cdp = async (_tabId, method, params = {}) => {
    calls.push({ method, params: clone(params) });
    if (method === "Input.dispatchKeyEvent") {
      if ((params.commands || []).includes("selectAll")) { element.selectionStart = 0; element.selectionEnd = element.value.length; }
      else if ((params.commands || []).includes("moveToEndOfDocument") && typeof element.value === "string") { element.selectionStart = element.selectionEnd = element.value.length; }
      else if (params.type === "keyDown" && params.key === "Delete") {
        if (element.selectionEnd > element.selectionStart) splice("");
      } else if (params.type === "keyDown" && params.text && params.key !== "Enter") splice(params.text);
    }
    return {};
  };
  return { worker, calls, element, listeners, fire: (tabId, info) => { for (const fn of [...listeners]) fn(tabId, info); } };
}

test("a targeted chrome_type moves the caret to the end after its focus click, so it appends", async () => {
  const h = harness(makeInput({ value: "why do flamingos stand", caret: 7 }));
  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: " still" });
  assert.equal(h.element.value, "why do flamingos stand still");
  assert.equal(result.insertedAt, "caret-end");
  const moves = h.calls.filter((c) => (c.params.commands || []).includes("moveToEndOfDocument"));
  assert.equal(moves.length, 1);
  assert.equal(h.calls.indexOf(moves[0]) > h.calls.findIndex((c) => c.method === "Input.dispatchMouseEvent" && c.params.type === "mouseReleased"), true, "caret moves after the focus click");
});

test("replace=true does not move the caret first; untargeted typing keeps the user's caret", async () => {
  const replace = harness(makeInput({ value: "old", caret: 1 }));
  await replace.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "new", replace: true });
  assert.equal(replace.calls.some((c) => (c.params.commands || []).includes("moveToEndOfDocument")), false);
  const focused = harness(makeInput({ value: "abc", caret: 1 }));
  await focused.worker.dispatch("page.type", { targetId: "2", text: "X" });
  assert.equal(focused.calls.some((c) => (c.params.commands || []).includes("moveToEndOfDocument")), false);
  assert.equal(focused.element.value, "aXbc");
});

test("typing into the middle of a focused prefilled field reports the splice instead of a bare count", async () => {
  const h = harness(makeInput({ value: "why do flamingos stand", caret: 7 }));
  const result = await h.worker.dispatch("page.type", { targetId: "2", text: "cats " });
  assert.equal(h.element.value, "why do cats flamingos stand");
  assert.equal(result.valueBefore, "why do flamingos stand");
  assert.equal(result.valueAfter, "why do cats flamingos stand");
  assert.equal(result.existingTextLengthBefore, 22);
  assert.equal(result.insertedAt, "caret-middle");
  assert.equal(result.replaced, undefined);
});

test("empty and caret-end targets are classified without warnings", async () => {
  const empty = harness(makeInput());
  assert.equal((await empty.worker.dispatch("page.type", { targetId: "2", uid: "el-1", text: "hi" })).insertedAt, "empty");
  const end = harness(makeInput({ value: "hello" }));
  const result = await end.worker.dispatch("page.type", { targetId: "2", uid: "el-1", text: "!" });
  assert.equal(result.insertedAt, "caret-end");
  assert.equal(result.valueAfter, "hello!");
});

for (const [platform, modifiers] of [["MacIntel", 4], ["Win32", 2]]) {
  test(`replace=true selects all with the platform shortcut + selectAll command, then deletes (${platform})`, async () => {
    const h = harness(makeInput({ value: "old query text", caret: 3 }), { platform });
    const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "new", replace: true });
    assert.equal(h.element.value, "new");
    assert.equal(result.replaced, true);
    assert.equal(result.insertedAt, "replaced-all");
    assert.equal(result.valueBefore, "old query text", "before is read prior to select-all/delete");
    const selectAll = h.calls.find((c) => (c.params.commands || []).includes("selectAll"));
    assert.equal(selectAll.params.modifiers, modifiers);
  });
}

test("sensitive fields never expose contents in type evidence", async () => {
  const h = harness(makeInput({ value: "hunter2", type: "password", name: "password" }));
  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "x" });
  assert.equal(result.valueRedacted, true);
  assert.equal(result.valueBefore, undefined);
  assert.equal(result.valueAfter, undefined);
  assert.ok(!JSON.stringify(result).includes("hunter2"));
  assert.equal(result.existingTextLengthBefore, 7);
});

test("a non-text focus target reports no value evidence rather than a false empty field", async () => {
  const h = harness({ tagName: "DIV", isConnected: true, isContentEditable: false, scrollIntoView() {}, getBoundingClientRect: () => ({ left: 0, top: 0, width: 10, height: 10 }) });
  const result = await h.worker.dispatch("page.type", { targetId: "2", selector: "#q", text: "x" });
  assert.equal(result.valueBefore, undefined);
  assert.equal(result.insertedAt, undefined);
});

test("includeSnapshot waits for a navigation the action started and snapshots the new page", async () => {
  const tabs = { 2: { id: 2, windowId: 1, url: "https://fixture.test/", status: "complete" } };
  const h = harness(makeInput(), { tabs });
  h.worker.chromeInputKey = async () => {
    tabs[2] = { ...tabs[2], url: "https://fixture.test/search?q=x", status: "loading" };
    setTimeout(() => { tabs[2].status = "complete"; h.fire(2, { status: "complete" }); }, 20);
    return { input: "chrome", key: "Enter" };
  };
  h.worker.snapshotInTab = async (params) => ({ url: tabs[Number(params.targetId)].url, status: tabs[Number(params.targetId)].status });
  const out = await h.worker.dispatch("page.key", { targetId: "2", key: "Enter", includeSnapshot: true });
  assert.equal(out.navigation.from, "https://fixture.test/");
  assert.equal(out.navigation.to, "https://fixture.test/search?q=x");
  assert.equal(out.navigation.settled, true);
  assert.deepEqual(clone(out.snapshot), { url: "https://fixture.test/search?q=x", status: "complete" });
  assert.equal(h.listeners.size, 0, "listener removed");
});

test("a non-navigating action snapshots immediately; an already-loading page is not waited on", async () => {
  const tabs = { 2: { id: 2, windowId: 1, url: "https://fixture.test/", status: "complete" } };
  const h = harness(makeInput(), { tabs });
  h.worker.chromeInputClick = async () => ({ input: "chrome" });
  h.worker.snapshotInTab = async () => ({ ok: true });
  const plain = await h.worker.dispatch("page.click", { targetId: "2", selector: "#q", includeSnapshot: true });
  assert.equal(plain.navigation, undefined);

  tabs[2].status = "loading"; // e.g. a hanging subresource, same URL
  const started = Date.now();
  const busy = await h.worker.dispatch("page.click", { targetId: "2", selector: "#q", includeSnapshot: true });
  assert.ok(Date.now() - started < 1_000, "no bounded wait for a load the action did not start");
  assert.equal(busy.navigation.settled, false);
  assert.equal(busy.navigation.waitedMs < 1_000, true);
});

test("tab.new reports the settled tab and loadStatus instead of the t=0 loading stub", async () => {
  const tabs = {};
  const h = harness(makeInput(), { tabs });
  h.worker.findGroupRecordByTitle = async () => null;
  h.worker.trackSessionTab = async () => {};
  h.worker.groupTab = async (tab) => ({ tab: { id: tab.id, url: tab.url, status: tab.status }, group: { title: "Pi Session: t" } });
  h.worker.formatTab = async (tab) => ({ id: tab.id, url: tab.url, status: tab.status, title: tab.title });
  h.worker.chrome.tabs.create = async ({ url }) => {
    tabs[9] = { id: 9, windowId: 1, url: "", title: "", status: "loading" };
    setTimeout(() => { tabs[9] = { ...tabs[9], url, title: "Loaded", status: "complete" }; h.fire(9, { status: "complete" }); }, 20);
    return clone(tabs[9]);
  };
  const out = await h.worker.dispatch("tab.new", { url: "https://fixture.test/page", background: true });
  assert.equal(out.loadStatus, "complete");
  assert.deepEqual(clone(out.tab), { id: 9, url: "https://fixture.test/page", status: "complete", title: "Loaded" });
  assert.equal(out.group.title, "Pi Session: t");
});

// ---- Pi-side text ----
function section(start, end) {
  const from = indexSource.indexOf(start);
  const to = indexSource.indexOf(end, from);
  assert.ok(from >= 0 && to > from, `Missing source section: ${start}`);
  return indexSource.slice(from, to);
}
const pi = vm.runInNewContext(`${stripTypeScriptTypes(section("function formatIncludedSnapshotText(", "\n// Keep raw CDP"))}; ({ formatIncludedSnapshotText, describeTypeEvidence })`, {
  formatChromeSnapshot: (s) => `SNAPSHOT ${s.url}`,
});

test("chrome_type text warns on splices, mentions spliced submits, and redacts secrets", () => {
  const spliced = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "aXbc", insertedAt: "caret-middle" }, 1, true).join("\n");
  assert.match(spliced, /Field went from "abc" to "aXbc"/);
  assert.match(spliced, /spliced into the middle/);
  assert.match(spliced, /submitted the spliced value/);
  const appended = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "abcX", insertedAt: "caret-end" }, 1, false).join("\n");
  assert.match(appended, /appended to existing content/);
  assert.doesNotMatch(appended, /⚠/);
  const secret = pi.describeTypeEvidence({ valueRedacted: true, existingTextLengthBefore: 7, valueLengthAfter: 8, insertedAt: "caret-end" }, 1, false).join("\n");
  assert.match(secret, /\[redacted\] \(7 → 8 chars/);
  assert.equal(pi.describeTypeEvidence({ input: "chrome" }, 1, false).length, 0);
  const lost = pi.describeTypeEvidence({ valueBefore: "abc", valueAfter: "abc", existingTextLengthBefore: 3, valueLengthAfter: 3, insertedAt: "caret-middle" }, 5, true).join("\n");
  assert.match(lost, /did not change/);
  assert.doesNotMatch(lost, /spliced/, "an unchanged field is not reported as a splice");
  const lostSecret = pi.describeTypeEvidence({ valueRedacted: true, existingTextLengthBefore: 3, valueLengthAfter: 3, insertedAt: "caret-end" }, 2, false).join("\n");
  assert.match(lostSecret, /did not change/);
});

test("included snapshots state whether a navigation settled", () => {
  const settled = pi.formatIncludedSnapshotText({ snapshot: { url: "https://b.test/" }, navigation: { from: "https://a.test/", to: "https://b.test/", settled: true, waitedMs: 120 } }, "Pressed Enter.");
  assert.match(settled, /Navigated https:\/\/a\.test\/ → https:\/\/b\.test\/ \(waited 120ms/);
  assert.match(settled, /SNAPSHOT https:\/\/b\.test\//);
  const stale = pi.formatIncludedSnapshotText({ snapshot: { url: "https://a.test/" }, navigation: { from: "https://a.test/", to: "https://b.test/", settled: false, waitedMs: 5000 } }, "Pressed Enter.");
  assert.match(stale, /⚠ The action started a navigation that had not finished after 5000ms/);
  assert.equal(pi.formatIncludedSnapshotText({ result: {} }, "Clicked."), "Clicked.");
});