import {test, expect} from 'bun:test'

import {signature} from '..'
import {gen, sign, verify} from '../src/signature'

test('base case', async () => {
  const keypair = await gen()
  expect(keypair.privateKey.extractable).toBeTrue()
  expect(keypair.publicKey.extractable).toBeTrue()
  const data = new TextEncoder().encode('Message 123 !')

  const sig = await sign(data, keypair.privateKey)
  expect(sig).not.toBeNull()
  const verification = await verify(data, keypair.publicKey, sig!)

  expect(verification).toBe(true)
})

test('extractable or not', async () => {
  const kp1 = await gen()
  const kp2 = await gen(true)
  const kp3 = await gen(false)

  expect(kp1.privateKey.extractable).toBeTrue()
  expect(kp2.privateKey.extractable).toBeTrue()
  expect(kp3.privateKey.extractable).toBeFalse()

  expect(kp1.publicKey.extractable).toBeTrue()
  expect(kp2.publicKey.extractable).toBeTrue()
  expect(kp3.publicKey.extractable).toBeTrue()
})

test('inverted keys', async () => {
  const keypair = await signature.gen()
  const data = new TextEncoder().encode('Message 123 !')

  const sig = await sign(data, keypair.publicKey)
  expect(sig).toBeNull()
})

test('tampered message', async () => {
  const keypair = await signature.gen()
  const data1 = new TextEncoder().encode('Message 123 !')
  const data2 = new TextEncoder().encode('Message 321 !')
  expect(data1).not.toEqual(data2)

  const sig = await sign(data1, keypair.privateKey)
  expect(sig).not.toBeNull()
  const verification = await verify(data2, keypair.publicKey, sig!)

  expect(verification).toBe(false)
})

test('different keypair', async () => {
  const keypair = await signature.gen()
  const keypair2 = await signature.gen()
  const data = new TextEncoder().encode('Message 123 !')

  const sig = await sign(data, keypair.privateKey)
  expect(sig).not.toBeNull()
  const verification = await verify(data, keypair2.publicKey, sig!)

  expect(verification).toBe(false)
})

test('tampered signature', async () => {
  const keypair = await signature.gen()
  const data = new TextEncoder().encode('Message 123 !')

  const sig = await sign(data, keypair.privateKey)
  expect(sig).not.toBeNull()
  sig![0] ^= 1
  const verification = await verify(data, keypair.publicKey, sig!)

  expect(verification).toBe(false)
})

/*describe('Derive array', () => {
  test('Base case', async () => {
    const data = new Uint8Array([1])
    const kp = await derive_keypair(data)

    const message = new Uint8Array(12)
    const sig = await sign(message, kp[0])
    const verif = await verify(message, kp[1], sig)

    expect(verif).toBeTrue()
  })

  test('Same derive, same key', async () => {
    const data = new Uint8Array([1, 2, 3])

    const k1 = await derive_keypair(data)
    const k2 = await derive_keypair(data)

    const message = new Uint8Array(12)
    const sig = await sign(message, k1[0])
    const verif = await verify(message, k2[1], sig)

    expect(verif).toBeTrue()
  })

  test('Different input, different key', async () => {
    const d1 = new Uint8Array([1, 2, 3])
    const d2 = new Uint8Array([3, 2, 1])

    const k1 = await derive_keypair(d1)
    const k2 = await derive_keypair(d2)

    const message = new Uint8Array(12)
    const sig = await sign(message, k1[0])
    const verif = await verify(message, k2[1], sig)

    expect(verif).toBeFalse()
  })
})*/