/**
 * Regression tests for the v2.0.3 journal fixes.
 *
 * These run the real functions out of the shipping HTML build, so they fail
 * if the demo and shipping files drift apart or if the encoding changes.
 */
import { describe, it, expect } from 'vitest';
import { readFileSync, existsSync } from 'node:fs';
import { execSync } from 'node:child_process';

const DEMO = 'public/demo-app/index.html';
const SHIP = 'release/The_Eternal_Journal.html';

if (!existsSync(SHIP)) execSync('node scripts/build-journal-shipping.mjs');

const demo = readFileSync(DEMO, 'utf8');
const ship = readFileSync(SHIP, 'utf8');

/** Pulls a named function's source out of the HTML and evaluates it. */
function extract(names: string[]) {
  const parts = names.map((name) => {
    const start = ship.indexOf(`function ${name}(`);
    if (start === -1) throw new Error(`function ${name} not found`);
    let depth = 0;
    let i = ship.indexOf('{', start);
    const open = i;
    for (; i < ship.length; i++) {
      if (ship[i] === '{') depth++;
      else if (ship[i] === '}') { depth--; if (depth === 0) break; }
    }
    return ship.slice(start, i + 1) + `\nglobalThis.${name} = ${name};`;
  });
  // eslint-disable-next-line no-new-func
  new Function('BASE64_CHUNK_SIZE', 'MIN_PASSPHRASE_LENGTH', parts.join('\n'))(8192, 12);
}

const g = globalThis as any;
g.window = g.window || {};
extract(['bytesToBase64', 'base64ToBytes', 'getMinimumPassphraseLength', 'describePassphraseStrength']);

const bytesToBase64: (bytes: Uint8Array) => string = g.bytesToBase64;
const base64ToBytes: (value: string) => Uint8Array = g.base64ToBytes;
const describePassphraseStrength: (value: string) => string = g.describePassphraseStrength;

const legacyEncode = (bytes: Uint8Array) => btoa(String.fromCharCode(...Array.from(bytes)));

describe('parity between demo and shipping builds', () => {
  it('differs only by the caret CSS and the demo bootstrap', () => {
    const stripped = demo
      .replace('\n  caret-color:var(--tx);-webkit-text-fill-color:var(--tx);}', '}')
      .replace(/<script>\n\/\* \u2550+ DEMO BOOTSTRAP[\s\S]*?<\/script>\n/, '');
    expect(stripped).toBe(ship);
  });

  it('keeps the shipping build free of network requests', () => {
    expect(/\bfetch\s*\(|XMLHttpRequest|<script[^>]+src=|<link[^>]+href="http/.test(ship)).toBe(false);
  });

  it('is stamped v2.0.4 in both builds', () => {
    expect(demo).toContain('v2.0.4');
    expect(ship).toContain('v2.0.4');
  });
});

describe('base64 encoding (F2)', () => {
  it('matches the v2.0.2 output byte for byte on small inputs', () => {
    for (let size = 0; size <= 512; size++) {
      const bytes = new Uint8Array(size);
      for (let i = 0; i < size; i++) bytes[i] = (i * 37 + size) & 0xff;
      expect(bytesToBase64(bytes)).toBe(legacyEncode(bytes));
    }
  });

  it('matches on inputs that straddle the chunk boundary', () => {
    for (const size of [8191, 8192, 8193, 16384, 16385, 24576]) {
      const bytes = new Uint8Array(size);
      for (let i = 0; i < size; i++) bytes[i] = (i * 131) & 0xff;
      expect(bytesToBase64(bytes)).toBe(legacyEncode(bytes));
    }
  });

  it('encodes a large journal where the old code threw RangeError', () => {
    const bytes = new Uint8Array(4 * 1024 * 1024);
    for (let i = 0; i < bytes.length; i++) bytes[i] = i & 0xff;
    expect(() => legacyEncode(bytes)).toThrow();
    const encoded = bytesToBase64(bytes);
    expect(encoded.length).toBe(Math.ceil(bytes.length / 3) * 4);
    const decoded = base64ToBytes(encoded);
    expect(decoded.length).toBe(bytes.length);
    let identical = true;
    for (let i = 0; i < bytes.length; i++) {
      if (decoded[i] !== bytes[i]) { identical = false; break; }
    }
    expect(identical).toBe(true);
  }, 30000);

  it('round-trips every byte value', () => {
    const bytes = new Uint8Array(256);
    for (let i = 0; i < 256; i++) bytes[i] = i;
    expect(base64ToBytes(bytesToBase64(bytes))).toEqual(bytes);
  });
});

describe('passphrase policy (F3)', () => {
  it('enforces twelve characters when setting or changing', () => {
    expect(ship).toContain('const MIN_PASSPHRASE_LENGTH = 12;');
    expect(ship).not.toContain('at least four characters');
  });

  it('never applies the minimum to unlocking', () => {
    const unlock = ship.slice(ship.indexOf('async function handleExistingJournalUnlock'));
    expect(unlock.slice(0, 1500)).not.toContain('getMinimumPassphraseLength');
  });

  it('reads strength locally', () => {
    expect(describePassphraseStrength('')).toBe('');
    expect(describePassphraseStrength('short')).toContain('too short');
    expect(describePassphraseStrength('correcthorsebattery')).toBeTruthy();
    expect(describePassphraseStrength('Correct-Horse-Battery-Staple-42')).toBe('strong');
  });
});

describe('import and export (F5)', () => {
  it('writes self-describing exports', () => {
    expect(ship).toContain('kdf: exportSaltBase64 ?');
    expect(ship).toContain('deriveEncryptionKeyWithParams');
  });

  it('still accepts v2.0.2 exports and plain files', () => {
    expect(ship).toContain('if (derivedKey) {');
    expect(ship).toContain('parsed.entries');
  });

  it('has no silent import failure path', () => {
    const fn = ship.slice(
      ship.indexOf('async function importJournalFile'),
      ship.indexOf('async function handleFileInputChange')
    );
    const catches = fn.match(/catch \(error\) \{/g) || [];
    const reports = fn.match(/reportImportOutcome\(/g) || [];
    expect(catches.length).toBeGreaterThan(0);
    expect(reports.length).toBeGreaterThanOrEqual(catches.length);
  });
});

describe('durability, locking and origin (F1, F6, F7)', () => {
  it('asks for persistent storage after unlock, not on load', () => {
    expect(ship).toContain('requestStoragePersistence();');
    const reveal = ship.slice(ship.indexOf('function revealJournalInterface'));
    expect(reveal.slice(0, 2000)).toContain('requestStoragePersistence()');
  });

  it('handles an absent storage API', () => {
    expect(ship).toContain("typeof navigator.storage.persist !== 'function'");
  });

  it('offers manual lock and an idle default of fifteen minutes', () => {
    expect(ship).toContain('const DEFAULT_IDLE_LOCK_MINUTES = 15;');
    expect(ship).toContain("id=\"bLock\"");
    expect(ship).toContain('derivedKey = null;');
  });

  it('warns first-time users that journals are per browser', () => {
    expect(ship).toContain('one browser and one profile');
  });
});