import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { createPrivateKey } from "node:crypto";

import { seal, open, generateKeyPair, type SealedBox } from "../dist/seal/index.js";
import { sealWith } from "../dist/seal/box.js";

// The fixtures the Go package proves itself against: boxes the licence manager's own seal.go made, and
// the one the agent module's TypeScript made. One format, three implementations.
const fixtures = new URL("../go/seal/testdata/", import.meta.url);
const lm = JSON.parse(readFileSync(new URL("sealed-by-licence-manager.json", fixtures), "utf8")) as {
  recipient: { publicKey: string; privateKey: string };
  sealed: { plaintext: string; box: SealedBox }[];
  vectors: { plaintext: string; ephPrivate: string; iv: string; box: SealedBox }[];
};

// PKCS #8 for an X25519 private key is this prefix and the 32 raw bytes.
const pkcs8 = (raw: Buffer) =>
  createPrivateKey({ key: Buffer.concat([Buffer.from("302e020100300506032b656e04220420", "hex"), raw]), format: "der", type: "pkcs8" });

test("seal: every box the licence manager sealed opens to its plaintext", () => {
  assert.ok(lm.sealed.length > 0);
  for (const s of lm.sealed) assert.equal(open(s.box, lm.recipient.privateKey), s.plaintext);
});

test("seal: given the same one-time key and iv, the box is byte for byte the licence manager's", () => {
  assert.ok(lm.vectors.length > 0);
  for (const v of lm.vectors) {
    const box = sealWith(v.plaintext, lm.recipient.publicKey, pkcs8(Buffer.from(v.ephPrivate, "base64")), Buffer.from(v.iv, "base64"));
    assert.deepEqual(box, v.box);
    assert.equal(open(box, lm.recipient.privateKey), v.plaintext);
  }
});

test("seal: the agent module's TypeScript box opens", () => {
  const f = JSON.parse(readFileSync(new URL("sealed-by-typescript.json", fixtures), "utf8"));
  assert.equal(open(f.box, f.privateKey), f.plaintext);
});

test("seal: a box opens for its recipient only, and two boxes share no one-time key or iv", () => {
  const a = generateKeyPair();
  const b = generateKeyPair();
  const box = seal("a token", a.publicKey);
  assert.equal(open(box, a.privateKey), "a token");
  assert.throws(() => open(box, b.privateKey));
  const again = seal("a token", a.publicKey);
  assert.notEqual(again.eph, box.eph);
  assert.notEqual(again.iv, box.iv);
});

test("seal: a box changed in any field, or of another version, does not open", () => {
  const good = lm.sealed[1].box;
  const flip = (s: string) => {
    const b = Buffer.from(s, "base64");
    b[b.length - 1] ^= 1;
    return b.toString("base64");
  };
  for (const box of [
    { ...good, ct: flip(good.ct) },
    { ...good, tag: flip(good.tag) },
    { ...good, iv: flip(good.iv) },
    { ...good, eph: flip(good.eph) },
    { ...good, v: 2 },
  ]) assert.throws(() => open(box as SealedBox, lm.recipient.privateKey));
});

test("seal: a key that is not X25519 PEM is refused", () => {
  assert.throws(() => seal("x", "not a key"));
  assert.throws(() => open(lm.sealed[0].box, lm.recipient.publicKey));
});