import {
  assert,
  assertAlmostEquals,
  assertArrayIncludes,
  assertEquals,
  assertExists,
} from "@std/assert";
import { describe, it } from "@std/testing/bdd";
import { createMessage, enums, readSignature, sign } from "openpgp";
import { Signature } from "./sign.ts";
import { get, instanciate } from "../../utils/anonymous.ts";
import { bufferToBase } from "../../utils/bases.ts";
import { generateKeyPair } from "../../../tests/fixtures/setup.ts";

describe("Signature wrapper", () => {
  const now = new Date();
  const aliceKeyPair = generateKeyPair("Alice");
  const signature = Promise.all([
    aliceKeyPair.then(get("privateKey")),
    createMessage({ text: "Hello world" }),
  ]).then(([privateKey, message]) =>
    sign({
      message,
      signingKeys: privateKey,
      detached: true,
      format: "object",
    })
  ).then((x) => readSignature({ armoredSignature: x.armor() })).then(
    instanciate(Signature),
  );

  describe("Single signer", () => {
    it("signingKeyIDs", async () => {
      const { publicKey } = await aliceKeyPair;
      const sig = await signature;

      assertEquals(sig.signingKeyIDs.length, 1);
      assert(sig.signingKeyIDs[0].equals(publicKey.getKeyID()));
    });

    it("getPackets", async () => {
      const sig = await signature;

      assertEquals(sig.getPackets().length, 1);
      assertEquals(sig.getPackets(sig.signingKeyIDs[0]).length, 1);
    });

    describe("Packet wrapper", () => {
      const packet = signature.then((x) => x.getPackets()[0]);

      it("created", async () => {
        const p = await packet;

        assertExists(p.created);
        assertAlmostEquals(p.created.getTime(), now.getTime());
      });

      it("issuerKeyID and issuerFingerprint", async () => {
        const { privateKey } = await aliceKeyPair;
        const p = await packet;

        assertEquals(p.issuerKeyID, privateKey.getKeyID());
        assertExists(p.issuerFingerprint);
        assertEquals(
          bufferToBase(p.issuerFingerprint, 16),
          privateKey.getFingerprint(),
        );
      });

      it("signatureType", async () => {
        const p = await packet;

        assertEquals(p.signatureType, enums.signature.text);
      });
    });
  });

  const bobKeyPair = generateKeyPair("Bob");
  const multiSignature = Promise.all([
    Promise.all([
      aliceKeyPair.then(get("privateKey")),
      bobKeyPair.then(get("privateKey")),
    ]),
    createMessage({ text: "Hello world" }),
  ]).then(([signingKeys, message]) =>
    sign({
      message,
      signingKeys,
      detached: true,
      format: "object",
    })
  ).then((x) => readSignature({ armoredSignature: x.armor() })).then(
    instanciate(Signature),
  );

  describe("with multiple signers", () => {
    it("signingKeyIDs", async () => {
      const { publicKey: alice } = await aliceKeyPair;
      const { publicKey: bob } = await bobKeyPair;
      const sig = await multiSignature;

      assertEquals(sig.signingKeyIDs.length, 2);
      assertArrayIncludes(sig.signingKeyIDs, [
        alice.getKeyID(),
        bob.getKeyID(),
      ]);
    });

    it("getPackets", async () => {
      const sig = await multiSignature;
      const { publicKey: alice } = await aliceKeyPair;
      const { publicKey: bob } = await bobKeyPair;

      assertEquals(sig.getPackets().length, 2);

      assertEquals(sig.getPackets(alice.getKeyID()).length, 1);

      assertEquals(sig.getPackets(bob.getKeyID()).length, 1);
    });
  });
});