import { describe, expect, it } from "@suaveplan/testing/runner";
import { deflateSync } from "fflate";
import { buildPlainZip } from "../__fixtures__/build-zip.js";
import { ZIP_CODES } from "../errors/error-codes.js";
import { normalizePath } from "../storage/normalize-path.js";
import { parseCdrEntry } from "./central-directory/parse-cdr-entry.js";
import { walkCdr } from "./central-directory/walk-cdr.js";
import { compress } from "./compression/compress.js";
import { decompress } from "./compression/decompress.js";
import { crc32 } from "./crc32.js";
import { aesDecrypt } from "./crypto/aes/aes-decrypt.js";
import { aesWriteBlock } from "./crypto/aes/aes-write-block.js";
import { findEocdOffset } from "./eocd/find-eocd.js";
import { parseEocd } from "./eocd/parse-eocd.js";
import {
    mergeEocd64,
    parseEocd64Locator,
    parseEocd64Record,
} from "./eocd/parse-eocd64.js";
import { parseLocalHeader } from "./local-header/parse-local-header.js";
import { readEntryBytes } from "./local-header/read-entry-bytes.js";
import {
    AE_EXTRA_TAG,
    CDR_SIG,
    EOCD_SIG,
    EOCD64_LOCATOR_SIG,
    EOCD64_SIG,
    LOCAL_HEADER_SIG,
    ZIP64_EXTRA_TAG,
} from "./signatures.js";

const enc = (s: string) => new TextEncoder().encode(s);

describe("parser unit", () => {
    it("findEocdOffset returns null for empty/short buffer", () => {
        expect(findEocdOffset(new Uint8Array(0))).toBeNull();
        expect(findEocdOffset(new Uint8Array(10))).toBeNull();
        expect(findEocdOffset(new Uint8Array(100))).toBeNull();
    });

    it("findEocdOffset rejects when comment length spans wrong", () => {
        // Build a fake buffer with EOCD magic but mismatched comment length.
        const buf = new Uint8Array(40);
        const v = new DataView(buf.buffer);
        v.setUint32(10, EOCD_SIG, true);
        v.setUint16(10 + 20, 999, true); // declared comment longer than remainder
        expect(findEocdOffset(buf)).toBeNull();
    });

    it("parseEocd throws for offset out of range", () => {
        const buf = new Uint8Array(50);
        expect(() => parseEocd(buf, -1)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.EOCD_NOT_FOUND })
        );
        expect(() => parseEocd(buf, 100)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.EOCD_NOT_FOUND })
        );
    });

    it("parseEocd throws when signature is wrong", () => {
        const buf = new Uint8Array(40);
        expect(() => parseEocd(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.EOCD_NOT_FOUND })
        );
    });

    it("parseEocd throws when comment length overflows", () => {
        const buf = new Uint8Array(24);
        const v = new DataView(buf.buffer);
        v.setUint32(0, EOCD_SIG, true);
        v.setUint16(20, 100, true); // way too long
        expect(() => parseEocd(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.EOCD_NOT_FOUND })
        );
    });

    it("parseEocd64Locator throws when no room before legacy EOCD", () => {
        const buf = new Uint8Array(20);
        expect(() => parseEocd64Locator(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
    });

    it("parseEocd64Locator throws when locator signature missing", () => {
        const buf = new Uint8Array(40);
        expect(() => parseEocd64Locator(buf, 20)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
    });

    it("parseEocd64Record throws on bad signature / range", () => {
        const buf = new Uint8Array(60);
        expect(() => parseEocd64Record(buf, -1)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
        expect(() => parseEocd64Record(buf, 100)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
        expect(() => parseEocd64Record(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
    });

    it("parseEocd64Locator + record + merge happy path", () => {
        // Build a hand-rolled ZIP64 set.
        const locator = new Uint8Array(20);
        const lv = new DataView(locator.buffer);
        lv.setUint32(0, EOCD64_LOCATOR_SIG, true);
        lv.setUint32(4, 0, true);
        lv.setUint32(8, 5, true); // low offset
        lv.setUint32(12, 0, true);
        lv.setUint32(16, 1, true);
        const eocd64Buf = new Uint8Array(56);
        const ev = new DataView(eocd64Buf.buffer);
        ev.setUint32(0, EOCD64_SIG, true);
        // remaining fields default to 0 which is sufficient
        // Concat into one buffer where legacyEocdOffset = 20 (after locator).
        const buf = new Uint8Array(76);
        buf.set(eocd64Buf, 0);
        buf.set(locator, 56);
        const loc = parseEocd64Locator(buf, 76);
        expect(loc.totalDisks).toBe(1);
    });

    it("readU64 rejects values exceeding MAX_SAFE_INTEGER", () => {
        const buf = new Uint8Array(8);
        const v = new DataView(buf.buffer);
        v.setUint32(0, 0, true);
        v.setUint32(4, 0xffffffff, true);
        // Build a ZIP64 record whose totalEntries field overflows.
        const z64 = new Uint8Array(56);
        const zv = new DataView(z64.buffer);
        zv.setUint32(0, EOCD64_SIG, true);
        zv.setUint32(32, 0, true);
        zv.setUint32(36, 0xffffffff, true); // hi
        expect(() => parseEocd64Record(z64, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
    });

    it("mergeEocd64 overrides every sentinel field from ZIP64 record", () => {
        const legacy = {
            diskNumber: 0xffff,
            diskWithCentralDir: 0xffff,
            entriesOnThisDisk: 0xffff,
            totalEntries: 0xffff,
            centralDirSize: 0xffffffff,
            centralDirOffset: 0xffffffff,
            comment: new Uint8Array(0),
            isZip64: false,
        };
        const z64 = {
            diskNumber: 5,
            diskWithCentralDir: 5,
            entriesOnThisDisk: 999,
            totalEntries: 999,
            centralDirSize: 12345,
            centralDirOffset: 67890,
        };
        const merged = mergeEocd64(legacy, z64);
        expect(merged.diskNumber).toBe(5);
        expect(merged.diskWithCentralDir).toBe(5);
        expect(merged.entriesOnThisDisk).toBe(999);
        expect(merged.totalEntries).toBe(999);
        expect(merged.centralDirSize).toBe(12345);
        expect(merged.centralDirOffset).toBe(67890);
    });

    it("mergeEocd64 preserves legacy values that fit", () => {
        const legacy = {
            diskNumber: 1,
            diskWithCentralDir: 1,
            entriesOnThisDisk: 3,
            totalEntries: 3,
            centralDirSize: 100,
            centralDirOffset: 50,
            comment: new Uint8Array([0x42]),
            isZip64: false,
        };
        const z64 = {
            diskNumber: 99,
            diskWithCentralDir: 99,
            entriesOnThisDisk: 999,
            totalEntries: 999,
            centralDirSize: 99999,
            centralDirOffset: 99999,
        };
        const merged = mergeEocd64(legacy, z64);
        expect(merged.diskNumber).toBe(1);
        expect(merged.totalEntries).toBe(3);
        expect(merged.centralDirSize).toBe(100);
        expect(merged.isZip64).toBe(true);
        expect(merged.comment).toEqual(new Uint8Array([0x42]));
    });

    it("parseCdrEntry throws when buffer too small", () => {
        const buf = new Uint8Array(20);
        expect(() => parseCdrEntry(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry throws on bad signature", () => {
        const buf = new Uint8Array(60);
        expect(() => parseCdrEntry(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry throws when variable-length tails overshoot", () => {
        const buf = new Uint8Array(60);
        const v = new DataView(buf.buffer);
        v.setUint32(0, CDR_SIG, true);
        v.setUint16(28, 1000, true); // huge name
        expect(() => parseCdrEntry(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry ignores ZIP64 extra when no sentinels are set", () => {
        const name = enc("a.txt");
        // ZIP64 extra carries some bytes but no 32-bit field is sentinel.
        const z64Extra = new Uint8Array(4 + 8);
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 8, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(20, 10, true);
        cv.setUint32(24, 10, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cv.setUint16(34, 0, true);
        cv.setUint32(42, 1, true);
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        const { entry } = parseCdrEntry(cdr, 0);
        expect(entry.compressedSize).toBe(10);
        expect(entry.uncompressedSize).toBe(10);
        expect(entry.localHeaderOffset).toBe(1);
        expect(entry.diskNumberStart).toBe(0);
    });

    it("parseCdrEntry decodes ZIP64 extra overrides", () => {
        // Construct a CDR entry whose 32-bit fields are sentinel and
        // whose ZIP64 extra provides 64-bit overrides.
        const name = enc("big.bin");
        const z64Extra = new Uint8Array(4 + 28);
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 28, true);
        // uncompressed, compressed, localOffset (each 8 bytes), then disk (4 bytes)
        zv.setUint32(4, 1000, true);
        zv.setUint32(8, 0, true);
        zv.setUint32(12, 500, true);
        zv.setUint32(16, 0, true);
        zv.setUint32(20, 200, true);
        zv.setUint32(24, 0, true);
        zv.setUint32(28, 7, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(20, 0xffffffff, true); // compressed
        cv.setUint32(24, 0xffffffff, true); // uncompressed
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cv.setUint16(34, 0xffff, true); // disk
        cv.setUint32(42, 0xffffffff, true); // local offset
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        const { entry } = parseCdrEntry(cdr, 0);
        expect(entry.uncompressedSize).toBe(1000);
        expect(entry.compressedSize).toBe(500);
        expect(entry.localHeaderOffset).toBe(200);
        expect(entry.diskNumberStart).toBe(7);
    });

    it("parseCdrEntry throws when ZIP64 extra missing compressed-size override", () => {
        const name = enc("a");
        const z64Extra = new Uint8Array(4 + 8); // only 8 payload bytes — uncompressed override only
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 8, true);
        zv.setUint32(4, 1000, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(20, 0xffffffff, true); // compressed sentinel
        cv.setUint32(24, 0xffffffff, true); // uncompressed sentinel
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry throws when ZIP64 extra missing local-offset override", () => {
        const name = enc("a");
        const z64Extra = new Uint8Array(4 + 16); // uncompressed + compressed, no offset
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 16, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(20, 0xffffffff, true);
        cv.setUint32(24, 0xffffffff, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cv.setUint32(42, 0xffffffff, true); // localOffset sentinel
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry throws when ZIP64 extra missing disk-number override", () => {
        const name = enc("a");
        // 8+8+8 = 24 bytes (uncompressed, compressed, localOffset) — no disk
        const z64Extra = new Uint8Array(4 + 24);
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 24, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(20, 0xffffffff, true);
        cv.setUint32(24, 0xffffffff, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cv.setUint16(34, 0xffff, true); // disk sentinel
        cv.setUint32(42, 0xffffffff, true);
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry throws when ZIP64 value > Number.MAX_SAFE_INTEGER", () => {
        const name = enc("a");
        const z64Extra = new Uint8Array(4 + 8);
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 8, true);
        zv.setUint32(4, 0, true);
        zv.setUint32(8, 0xffffffff, true); // high 32 bits overflow
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(24, 0xffffffff, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.ZIP64_REQUIRED })
        );
    });

    it("parseCdrEntry throws when ZIP64 extra truncated", () => {
        const name = enc("a");
        const z64Extra = new Uint8Array(4 + 4); // declares only 4 bytes, not enough for one 8-byte field
        const zv = new DataView(z64Extra.buffer);
        zv.setUint16(0, ZIP64_EXTRA_TAG, true);
        zv.setUint16(2, 4, true);
        const cdr = new Uint8Array(46 + name.byteLength + z64Extra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint32(24, 0xffffffff, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, z64Extra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(z64Extra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry rejects malformed extras (declared size overshoots)", () => {
        const name = enc("a");
        const badExtra = new Uint8Array(8);
        const ev = new DataView(badExtra.buffer);
        ev.setUint16(0, 0xdead, true);
        ev.setUint16(2, 100, true); // claims 100 bytes
        const cdr = new Uint8Array(46 + name.byteLength + badExtra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, badExtra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(badExtra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry rejects AE extra truncated", () => {
        const name = enc("a");
        const aeExtra = new Uint8Array(4 + 3); // only 3 payload bytes
        const av = new DataView(aeExtra.buffer);
        av.setUint16(0, AE_EXTRA_TAG, true);
        av.setUint16(2, 3, true);
        const cdr = new Uint8Array(46 + name.byteLength + aeExtra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, aeExtra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(aeExtra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("parseCdrEntry with AE extra but compressionMethod != placeholder keeps original method", () => {
        const name = enc("a");
        const aeExtra = new Uint8Array(4 + 7);
        const av = new DataView(aeExtra.buffer);
        av.setUint16(0, AE_EXTRA_TAG, true);
        av.setUint16(2, 7, true);
        av.setUint16(4, 1, true); // AE-1
        aeExtra[6] = "A".charCodeAt(0);
        aeExtra[7] = "E".charCodeAt(0);
        aeExtra[8] = 3;
        av.setUint16(9, 8, true); // originalMethod (advisory only)
        const cdr = new Uint8Array(46 + name.byteLength + aeExtra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint16(10, 8, true); // compressionMethod = DEFLATE (not placeholder)
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, aeExtra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(aeExtra, 46 + name.byteLength);
        const { entry } = parseCdrEntry(cdr, 0);
        expect(entry.compressionMethod).toBe(8);
        expect(entry.effectiveCompressionMethod).toBe(8); // unchanged
        expect(entry.aes).toBeDefined();
    });

    it("parseCdrEntry rejects AE strength byte not in 1..3", () => {
        const name = enc("a");
        const aeExtra = new Uint8Array(4 + 7);
        const av = new DataView(aeExtra.buffer);
        av.setUint16(0, AE_EXTRA_TAG, true);
        av.setUint16(2, 7, true);
        av.setUint16(4, 2, true);
        aeExtra[6] = "A".charCodeAt(0);
        aeExtra[7] = "E".charCodeAt(0);
        aeExtra[8] = 7; // invalid strength
        av.setUint16(9, 0, true);
        const cdr = new Uint8Array(46 + name.byteLength + aeExtra.byteLength);
        const cv = new DataView(cdr.buffer);
        cv.setUint32(0, CDR_SIG, true);
        cv.setUint16(28, name.byteLength, true);
        cv.setUint16(30, aeExtra.byteLength, true);
        cdr.set(name, 46);
        cdr.set(aeExtra, 46 + name.byteLength);
        expect(() => parseCdrEntry(cdr, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("walkCdr throws when buffer exhausted before expected count", () => {
        const buf = new Uint8Array(20);
        expect(() => walkCdr(buf, 0, 1)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
        // Iteration index check
        expect(() => walkCdr(buf, 100, 1)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT })
        );
    });

    it("decompress DEFLATE falls back when uncompressedSize is misadvertised", () => {
        // Synthesise a deflate stream by compressing 'abc' but tell decompress
        // we expect a larger output buffer.  fflate writes the true bytes and
        // returns a sub-view; decompress should return the sub-view rather
        // than a partially-zero-filled out buffer.
        const compressed = deflateSync(enc("abc"), { level: 6 });
        const out = decompress(compressed, 8, 999);
        expect(new TextDecoder().decode(out)).toBe("abc");
    });

    it("decompress STORE returns copy", () => {
        const src = new Uint8Array([1, 2, 3]);
        const out = decompress(src, 0, 3);
        expect(out).toEqual(src);
        // mutation isolated
        out[0] = 9;
        expect(src[0]).toBe(1);
    });

    it("decompress throws for unsupported method", () => {
        expect(() => decompress(new Uint8Array(4), 99, 4)).toThrow(
            expect.objectContaining({
                zipCode: ZIP_CODES.UNSUPPORTED_COMPRESSION,
            })
        );
    });

    it("compress short input uses STORE", () => {
        const { method } = compress(enc("x"));
        expect(method).toBe(0);
    });

    it("compress empty input uses STORE with zero bytes", () => {
        const { bytes, method } = compress(new Uint8Array(0));
        expect(method).toBe(0);
        expect(bytes.byteLength).toBe(0);
    });

    it("compress shrinkable input uses DEFLATE", () => {
        const big = new Uint8Array(4096).fill(0x41);
        const { method, bytes } = compress(big);
        expect(method).toBe(8);
        expect(bytes.byteLength).toBeLessThan(big.byteLength);
    });

    it("parseLocalHeader throws for offset out of range", () => {
        const buf = new Uint8Array(20);
        expect(() => parseLocalHeader(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.LOCAL_HEADER_INVALID })
        );
    });

    it("parseLocalHeader throws on bad signature", () => {
        const buf = new Uint8Array(40);
        expect(() => parseLocalHeader(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.LOCAL_HEADER_INVALID })
        );
    });

    it("parseLocalHeader throws on variable-length overshoot", () => {
        const buf = new Uint8Array(40);
        const v = new DataView(buf.buffer);
        v.setUint32(0, LOCAL_HEADER_SIG, true);
        v.setUint16(26, 1000, true); // name length too big
        expect(() => parseLocalHeader(buf, 0)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.LOCAL_HEADER_INVALID })
        );
    });

    it("parseLocalHeader decodes extras with truncated final extra (ignored)", () => {
        // Build a valid local header with 4 bytes of extras containing a tag with a too-large size.
        const name = enc("a");
        const extras = new Uint8Array(4);
        const ev = new DataView(extras.buffer);
        ev.setUint16(0, 0xdead, true);
        ev.setUint16(2, 100, true);
        const lh = new Uint8Array(30 + name.byteLength + extras.byteLength);
        const v = new DataView(lh.buffer);
        v.setUint32(0, LOCAL_HEADER_SIG, true);
        v.setUint16(26, name.byteLength, true);
        v.setUint16(28, extras.byteLength, true);
        lh.set(name, 30);
        lh.set(extras, 30 + name.byteLength);
        const parsed = parseLocalHeader(lh, 0);
        expect(parsed.extras.size).toBe(0); // truncated extra is skipped
    });

    it("readEntryBytes throws when payload exceeds buffer", () => {
        const bytes = buildPlainZip([
            { name: "a.txt", payload: enc("hello"), method: 0 },
        ]);
        // Build a synthetic entry referencing a payload past the end.
        const fake = {
            versionMadeBy: 0,
            versionNeeded: 20,
            flags: 0x0800,
            compressionMethod: 0,
            effectiveCompressionMethod: 0,
            mtimeDos: 0,
            mdateDos: 0x21,
            crc32: 0,
            compressedSize: 999999,
            uncompressedSize: 999999,
            diskNumberStart: 0,
            internalAttrs: 0,
            externalAttrs: 0,
            localHeaderOffset: 0,
            name: "a.txt",
            extras: new Map(),
            comment: new Uint8Array(0),
        };
        expect(() => readEntryBytes(bytes, fake)).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.LOCAL_HEADER_INVALID })
        );
    });

    it("normalizePath happy path returns input", () => {
        expect(normalizePath("a/b.txt")).toBe("a/b.txt");
    });

    it("normalizePath rejects every disallowed form", () => {
        expect(() => normalizePath("")).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.PATH_INVALID })
        );
        expect(() => normalizePath("a\\b")).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.PATH_INVALID })
        );
        expect(() => normalizePath("/abs")).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.PATH_INVALID })
        );
        expect(() => normalizePath("a/../b")).toThrow(
            expect.objectContaining({ zipCode: ZIP_CODES.PATH_INVALID })
        );
    });

    it("aesKeyLength branches for AES-128 / AES-192 strengths", async () => {
        const aes128 = {
            aeVersion: 1,
            vendorId: "AE",
            strength: 1 as const,
            originalMethod: 0,
        };
        const aes192 = {
            aeVersion: 1,
            vendorId: "AE",
            strength: 2 as const,
            originalMethod: 0,
        };
        // These will fail at the shortness check (payload too small for any salt),
        // but only AFTER the keyLen branch is hit.
        await expect(
            aesDecrypt(aes128, new Uint8Array(5), "pw", "x")
        ).rejects.toMatchObject({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT });
        await expect(
            aesDecrypt(aes192, new Uint8Array(5), "pw", "x")
        ).rejects.toMatchObject({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT });
    });

    it("aesDecrypt rejects payload shorter than salt + verifier + hmac", async () => {
        const aes = {
            aeVersion: 2,
            vendorId: "AE",
            strength: 3 as const,
            originalMethod: 0,
        };
        await expect(
            aesDecrypt(aes, new Uint8Array(8), "pw", "x.txt")
        ).rejects.toMatchObject({ zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT });
    });

    it("storage propagates non-auth AES errors verbatim", async () => {
        // Build a normal AES archive then truncate the payload so aesDecrypt
        // raises CENTRAL_DIR_CORRUPT instead of AES_AUTH_FAILED.
        const { buildAesZip } = await import("../__fixtures__/build-zip.js");
        const aesBytes = await buildAesZip(
            "x.txt",
            new TextEncoder().encode("payload"),
            "pw",
            0
        );
        const { ZipArchiveStorage } = await import(
            "../storage/zip-archive-storage.js"
        );
        // Patch the CDR compressedSize to 4 (way below saltLen+2+10=28) so
        // readEntryBytes succeeds but aesDecrypt fails the overhead check.
        const corrupted = aesBytes.slice();
        const v = new DataView(corrupted.buffer);
        const eocdOffset = corrupted.byteLength - 22;
        const cdrOff = v.getUint32(eocdOffset + 16, true);
        v.setUint32(cdrOff + 20, 4, true); // compressedSize in CDR
        const storage = await ZipArchiveStorage.open({
            source: corrupted,
            mode: "read-only",
            password: async () => "pw",
        });
        await expect(storage.get("x.txt")).rejects.toMatchObject({
            zipCode: ZIP_CODES.CENTRAL_DIR_CORRUPT,
        });
    });

    it("aesDecrypt rejects HMAC tampering with HMAC mismatch", async () => {
        // Build a fixture, then flip the HMAC tag.
        const { buildAesZip } = await import("../__fixtures__/build-zip.js");
        const aesBytes = await buildAesZip(
            "x.txt",
            new TextEncoder().encode("payload"),
            "pw",
            0
        );
        // Find the AES payload in the buffer.  The payload sits between the
        // local-header and the CDR; the local header starts at byte 0. Find
        // the local-header length by reading name+extras.
        const v = new DataView(aesBytes.buffer);
        const nameLen = v.getUint16(26, true);
        const extraLen = v.getUint16(28, true);
        const compressedSize = v.getUint32(18, true);
        const payloadStart = 30 + nameLen + extraLen;
        // Last 10 bytes of the payload are the HMAC tag.
        const tagStart = payloadStart + compressedSize - 10;
        // Build a copy and corrupt one HMAC byte to force HMAC mismatch.
        const corrupted = aesBytes.slice();
        corrupted[tagStart] = corrupted[tagStart] ^ 0xff;
        const { ZipArchiveStorage } = await import(
            "../storage/zip-archive-storage.js"
        );
        const storage = await ZipArchiveStorage.open({
            source: corrupted,
            mode: "read-only",
            password: async () => "pw",
        });
        // The PASSWORD_VERIFIER bytes are still valid (we only touched HMAC),
        // so verifier check passes and HMAC check fails.
        await expect(storage.get("x.txt")).rejects.toMatchObject({
            archiveCode: "ARCHIVE.PASSWORD_INVALID",
        });
    });

    it("aesWriteBlock always throws", () => {
        expect(() => aesWriteBlock("pw", new Uint8Array(4), 3)).toThrow(
            expect.objectContaining({
                zipCode: ZIP_CODES.AES_WRITE_UNSUPPORTED,
            })
        );
    });

    it("crc32 matches known-answer for the empty string", () => {
        expect(crc32(new Uint8Array(0))).toBe(0);
        expect(crc32(enc("123456789"))).toBe(0xcbf43926);
    });
});