import { promises as fs } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";
import {
    afterAll,
    beforeAll,
    describe,
    expect,
    it,
} from "@suaveplan/testing/runner";
import {
    prepareFileCommand,
    validateFileCommand,
} from "../../src/commands/files/files.js";
import { serveFileCommand } from "../../src/commands/files/serve-file.js";
import { createRootKeysCommand } from "../../src/commands/keys/keys.js";

const PW = "intpw1234";

function tmp(label: string): string {
    return path.join(
        tmpdir(),
        `sk-int-${label}-${Date.now()}-${Math.random().toString(36).slice(2)}`
    );
}

describe("integration: prepare → validate → serve round-trip", () => {
    let dir = "";
    let input = "";
    let originalBytes = new Uint8Array();
    const preparedDir = (): string => path.join(dir, "prepared");

    beforeAll(async () => {
        dir = tmp("rt");
        await fs.mkdir(dir, { recursive: true });
        await createRootKeysCommand(PW, { output: dir });
        input = path.join(dir, "data.bin");
        // 1 MiB + 1 byte to exercise multi-packet and an odd tail packet.
        const size = 1_048_577;
        originalBytes = new Uint8Array(size);
        for (let i = 0; i < size; i++) {
            originalBytes[i] = (i * 31 + 7) & 0xff;
        }
        await fs.writeFile(input, originalBytes);
    });

    afterAll(async () => {
        await fs.rm(dir, { recursive: true, force: true });
    });

    it("prepares + validates + serves a binary file byte-identical to the input", {
        timeout: 120000,
    }, async () => {
        const manifest = await prepareFileCommand(
            input,
            path.join(dir, "root.vault"),
            PW,
            { output: preparedDir(), packetSize: 256 * 1024 }
        );
        expect(manifest.totalPackets).toBe(5);
        expect(manifest.originalSize).toBe(originalBytes.byteLength);

        const validation = await validateFileCommand(preparedDir());
        expect(validation.isComplete).toBe(true);
        expect(validation.validPackets).toBe(manifest.totalPackets);
        expect(validation.invalidPackets).toEqual([]);

        const reassembledPath = path.join(dir, "out.bin");
        const result = await serveFileCommand(preparedDir(), {
            output: reassembledPath,
        });
        expect(result.bytesWritten).toBe(originalBytes.byteLength);
        const reassembled = await fs.readFile(reassembledPath);
        expect(reassembled.byteLength).toBe(originalBytes.byteLength);
        // Byte-identical comparison.
        for (let i = 0; i < originalBytes.byteLength; i++) {
            if (reassembled[i] !== originalBytes[i]) {
                throw new Error(
                    `byte mismatch at offset ${i}: expected ${originalBytes[i]} got ${reassembled[i]}`
                );
            }
        }
    });
});