// Tests for the passkey-backup banner visibility rule.  node test/backup.test.mjs
import assert from "node:assert/strict";
import { autoRestoreRequested, backupBannerState, parseReturnNonce, parseRestoreReturn, REMIND_RUNGS_MS } from "../web/static/backup.js";

let failures = 0;
async function test(name, fn) {
  try {
    await fn();
    console.log("PASS  " + name);
  } catch (e) {
    console.log("FAIL  " + name + "  —  " + (e && e.message));
    failures++;
  }
}

const DAY = 24 * 60 * 60 * 1000;
const now = 1_700_000_000_000; // a fixed "now" so snooze comparisons are deterministic

await test("home space links request automatic restore by exact marker", () => {
  assert.equal(autoRestoreRequested("?restore=1"), true);
  assert.equal(autoRestoreRequested("?thread=7&restore=1"), true);
  assert.equal(autoRestoreRequested("?restore=0"), false);
  assert.equal(autoRestoreRequested("?restored=1"), false);
});

await test("not enrolled + not snoozed → show", () => {
  assert.equal(backupBannerState({ enrolled: false, dismissed: false, snoozedUntil: 0, now }), "show");
});

await test("enrolled → hidden", () => {
  assert.equal(backupBannerState({ enrolled: true, dismissed: false, snoozedUntil: 0, now }), "hidden");
});

await test("snoozed in the future → hidden", () => {
  assert.equal(backupBannerState({ enrolled: false, dismissed: false, snoozedUntil: now + 7 * DAY, now }), "hidden");
});

await test("snooze expired → show", () => {
  assert.equal(backupBannerState({ enrolled: false, dismissed: false, snoozedUntil: now - DAY, now }), "show");
});

await test("permanently dismissed → hidden", () => {
  assert.equal(backupBannerState({ enrolled: false, dismissed: true, snoozedUntil: 0, now }), "hidden");
});

await test("enrolled wins even if the snooze has expired", () => {
  assert.equal(backupBannerState({ enrolled: true, dismissed: false, snoozedUntil: now - DAY, now }), "hidden");
});

// The deferral schedule: a setup-time skip keeps the banner quiet until each
// escalating rung (24h → 72h → 1w) is due; past the rungs, classic rules apply.
await test("setup skip: quiet before the 24h rung, shows once due", () => {
  const base = { enrolled: false, dismissed: false, snoozedUntil: 0, deferredAt: now, remindStage: 0 };
  assert.equal(backupBannerState({ ...base, now: now + DAY - 1 }), "hidden");
  assert.equal(backupBannerState({ ...base, now: now + DAY }), "show");
});

await test("setup skip: each dismissal advances to the next rung", () => {
  const base = { enrolled: false, dismissed: false, snoozedUntil: 0, deferredAt: now };
  assert.equal(backupBannerState({ ...base, remindStage: 1, now: now + DAY + 1 }), "hidden", "72h rung not yet due");
  assert.equal(backupBannerState({ ...base, remindStage: 1, now: now + 3 * DAY }), "show");
  assert.equal(backupBannerState({ ...base, remindStage: 2, now: now + 6 * DAY }), "hidden", "final rung not yet due");
  assert.equal(backupBannerState({ ...base, remindStage: 2, now: now + 7 * DAY }), "show");
});

await test("setup skip: past the final rung the classic snooze rule owns it", () => {
  const base = { enrolled: false, dismissed: false, deferredAt: now, remindStage: REMIND_RUNGS_MS.length };
  assert.equal(backupBannerState({ ...base, snoozedUntil: now + 30 * DAY, now: now + 8 * DAY }), "hidden");
  assert.equal(backupBannerState({ ...base, snoozedUntil: 0, now: now + 8 * DAY }), "show");
});

await test("setup skip: enrolment or opt-out silences the schedule", () => {
  const due = now + 2 * DAY;
  assert.equal(backupBannerState({ enrolled: true, dismissed: false, snoozedUntil: 0, deferredAt: now, remindStage: 0, now: due }), "hidden");
  assert.equal(backupBannerState({ enrolled: false, dismissed: true, snoozedUntil: 0, deferredAt: now, remindStage: 0, now: due }), "hidden");
});

// parseReturnNonce: pull our one-time nonce out of the /enroll return fragment.
await test("return nonce parses from a lone marker", () => {
  assert.equal(parseReturnNonce("#lchat_backup=abc123"), "abc123");
});
await test("return nonce is URL-decoded", () => {
  assert.equal(parseReturnNonce("#lchat_backup=a%2Fb%2Bc"), "a/b+c");
});
await test("return nonce parses when not first in the fragment", () => {
  assert.equal(parseReturnNonce("#foo=1&lchat_backup=xyz"), "xyz");
});
await test("no marker → empty", () => {
  assert.equal(parseReturnNonce("#something-else"), "");
  assert.equal(parseReturnNonce(""), "");
  assert.equal(parseReturnNonce("#lchat_backupZZZ=nope"), "");
});

// parseRestoreReturn: pull { nonce, wrapped } out of the /restore return fragment.
function b64url(s) {
  return Buffer.from(s, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
await test("restore return parses nonce + wrapped", () => {
  const h = "#lchat_restore=" + b64url(JSON.stringify({ nonce: "n1", wrapped: "w1" }));
  assert.deepEqual(parseRestoreReturn(h), { nonce: "n1", wrapped: "w1" });
});
await test("restore return: no marker → null", () => {
  assert.equal(parseRestoreReturn("#something"), null);
  assert.equal(parseRestoreReturn(""), null);
});
await test("restore return: malformed base64 → null", () => {
  assert.equal(parseRestoreReturn("#lchat_restore=%%%"), null);
});
await test("restore return: valid base64 but missing fields → null", () => {
  assert.equal(parseRestoreReturn("#lchat_restore=" + b64url(JSON.stringify({ nonce: "n" }))), null);
});

console.log(failures === 0 ? "\nALL PASSED" : `\n${failures} FAILED`);
process.exit(failures === 0 ? 0 : 1);