// node modules/test/test-cryptogzip-gunzip.js
// test-cryptogzip-gunzip — plan 2026-11-03_061900-newos4-cryptogzip-base64-guard.md, T3.
// `_cmdGunzip` must go through the byte path so that:
//   (1) a base64 .gz written by the module's own `gzip` still decompresses,
//   (2) a real gzip file (raw Latin-1 bytes in the VFS, e.g. from `wget`) also decompresses
//       — before T3 this reported "not valid base64 input (…)" and could not be unpacked at all,
//   (3) a plain text file named *.gz reports exactly "not a gzip file" and changes nothing,
//   (4) the "output already exists" confirm guard still refuses and changes nothing.
const fs = require('fs');
const path = require('path');

global.window = {};   // the file's auto-registration tail is window-guarded

const SRC = path.join(__dirname, '..', 'ext', 'cryptogzip.js');
const CryptoGzipModule = new Function(fs.readFileSync(SRC, 'utf8') + '\nreturn CryptoGzipModule;')();

let passes = 0, fails = 0;
function ok(name, cond, detail) {
    if (cond) { passes++; return; }
    fails++;
    console.log('FAIL ' + name + (detail ? ' — ' + detail : ''));
}

// VFS stub mirroring the real semantics: the exact string handed to writeFile is what readFile
// returns (base64 text, or Latin-1 one-char-per-byte for _vfsWriteBytes).
function mkTerm(files) {
    const store = Object.assign({}, files || {});
    const printed = [];
    const term = {
        print: (msg, kind) => printed.push({ msg: String(msg), kind: kind || '' }),
        fs: {
            readFile: (p) => (p in store ? store[p] : null),
            writeFile: (p, c) => { store[p] = c; return true; },
            deleteFile: (p) => { delete store[p]; },
            readDir: () => []
        },
        inputCallback: null,
        _onCommand: null
    };
    const mod = new CryptoGzipModule();
    mod.terminal = term;
    mod.registerCommands();
    return { mod, term, printed, store, answer: (line) => term.inputCallback(line) };
}

const SUCCESS = /^gunzipped: (\S+) → (\S+) \((\d+) → (\d+) chars\)$/;

(async () => {
    // ── T1: module-produced (base64) .gz still decompresses (legacy path) ────────────────
    const t1 = mkTerm({});
    t1.store['note.txt.gz'] = await t1.mod._gzipString('gunzip me');
    await t1.mod.commands['gunzip'](['note.txt.gz']);
    const s1 = t1.printed.find(p => p.kind === 'success');
    ok('T1 base64 .gz decompresses', t1.store['note.txt'] === 'gunzip me',
        JSON.stringify(Object.keys(t1.store)));
    ok('T1 .gz removed after success', !('note.txt.gz' in t1.store),
        JSON.stringify(Object.keys(t1.store)));
    ok('T1 success line keeps its format', !!s1 && SUCCESS.test(s1.msg), s1 ? s1.msg : 'no success line');

    // ── T2: real gzip bytes in the VFS (what `wget` stores) decompress ───────────────────
    const t2 = mkTerm({});
    const payload = 'binary payload — ümlauts ✓\nline two\n';
    const gzBytes = await t2.mod._gzipBytes(new TextEncoder().encode(payload));
    t2.mod._vfsWriteBytes('dl.txt.gz', gzBytes);                       // raw Latin-1, like wget
    const asRead = t2.mod._vfsReadBytes('dl.txt.gz');
    ok('T2 fixture is real gzip magic and read back byte-identical',
        t2.mod._isGzip(asRead) && Buffer.from(asRead).equals(Buffer.from(gzBytes)),
        asRead.length + ' bytes, magic ' + asRead[0].toString(16) + ' ' + asRead[1].toString(16));
    await t2.mod.commands['gunzip'](['dl.txt.gz']);
    ok('T2 raw gzip bytes decompress', t2.store['dl.txt'] === payload,
        JSON.stringify(t2.store['dl.txt']));
    ok('T2 no "not valid base64" on a real gzip file',
        !t2.printed.some(p => /base64/.test(p.msg)), JSON.stringify(t2.printed));

    // ── T3: plain text named .gz -> exactly "not a gzip file", nothing touched ───────────
    const t3 = mkTerm({ 'fake.gz': 'this is not compressed at all' });
    await t3.mod.commands['gunzip'](['fake.gz']);
    const err3 = t3.printed.find(p => /^gunzip error: /.test(p.msg));
    ok('T3 reports "not a gzip file"', !!err3 && err3.msg === 'gunzip error: not a gzip file',
        err3 ? err3.msg : 'no gunzip error line');
    ok('T3 error is not a base64 message', !!err3 && !/base64/.test(err3.msg),
        err3 ? err3.msg : 'no gunzip error line');
    ok('T3 input file untouched', t3.store['fake.gz'] === 'this is not compressed at all',
        JSON.stringify(t3.store));
    ok('T3 no output file created', !('fake' in t3.store), JSON.stringify(Object.keys(t3.store)));
    ok('T3 nothing deleted (exactly one key left)', Object.keys(t3.store).length === 1,
        JSON.stringify(Object.keys(t3.store)));
    ok('T3 no success line', !t3.printed.some(p => p.kind === 'success'), JSON.stringify(t3.printed));

    // ── T4: output-exists guard still refuses (answer "no") and changes nothing ──────────
    const t4 = mkTerm({});
    t4.store['dup.txt.gz'] = await t4.mod._gzipString('compressed contents');
    t4.store['dup.txt'] = 'ORIGINAL — must survive';
    const p4 = t4.mod.commands['gunzip'](['dup.txt.gz']);
    t4.answer('no');
    await p4;
    ok('T4 refuses to overwrite without confirmation', t4.store['dup.txt'] === 'ORIGINAL — must survive',
        JSON.stringify(t4.store['dup.txt']));
    ok('T4 leaves the .gz in place', t4.store['dup.txt.gz'] !== undefined,
        JSON.stringify(Object.keys(t4.store)));
    ok('T4 prints Cancelled.', t4.printed.some(p => /^Cancelled\.$/.test(p.msg)),
        JSON.stringify(t4.printed));

    // ── T5: same guard, answer "yes" -> overwrite proceeds ───────────────────────────────
    const t5 = mkTerm({});
    t5.store['dup2.txt.gz'] = await t5.mod._gzipString('new contents');
    t5.store['dup2.txt'] = 'stale';
    const p5 = t5.mod.commands['gunzip'](['dup2.txt.gz']);
    t5.answer('yes');
    await p5;
    ok('T5 overwrite proceeds on "yes"', t5.store['dup2.txt'] === 'new contents'
        && !('dup2.txt.gz' in t5.store), JSON.stringify(t5.store));

    // ── T6: non-.gz path is still refused with the Usage line ────────────────────────────
    const t6 = mkTerm({ 'plain.txt.gz': 'x', 'other.txt': 'y' });
    await t6.mod.commands['gunzip'](['other.txt']);
    ok('T6 refuses a non-.gz path', t6.printed.some(p => /^Usage: gunzip /.test(p.msg))
        && t6.store['other.txt'] === 'y', JSON.stringify(t6.printed));

    // ── T7: missing file is still a "File not found" error (no throw) ────────────────────
    const t7 = mkTerm({});
    let threw7 = null;
    try { await t7.mod.commands['gunzip'](['nope.gz']); } catch (e) { threw7 = e; }
    ok('T7 missing file reports File not found', !threw7
        && t7.printed.some(p => /^File not found: nope\.gz$/.test(p.msg)),
        threw7 ? 'threw ' + threw7.message : JSON.stringify(t7.printed));

    console.log('test-cryptogzip-gunzip: ' + passes + ' passed, ' + fails + ' failed');
    process.exit(fails ? 1 : 0);
})().catch(e => { console.error('FATAL ' + (e && e.stack || e)); process.exit(1); });