// src/AsymmetricCrypto.test.ts

import { AsymmetricCrypto } from "./AsymmetricCrypto"

/**
 * Async-Await (ou callbacks)
 * Node.js Event Loop
 */

it("should enable secure message exchange between Ana and Bob", async () => {
    const asymmetricCrypto = new AsymmetricCrypto()
    const anaKeys = await asymmetricCrypto.generateKeyPair()
    const bobKeys = await asymmetricCrypto.generateKeyPair()

    /**
     * Aqui ocorreria a Exchange de Keys 
     * (Ana envia a publica para o Bob e vice-versa)
     */

    // Ana envia mensagem para Bob
    const cryptedMessage = asymmetricCrypto.encrypt("Hello", bobKeys.publicKey)
    expect(cryptedMessage.toString()).not.toEqual("Hello")

    // Bob recebe mensagem de Ana
    const message = asymmetricCrypto.decrypt(cryptedMessage, bobKeys.privateKey)
    expect(message.toString()).toEqual("Hello")

    // Bob responde mensagem para Ana
    const cryptedReply = asymmetricCrypto.encrypt("Hello, Ana", anaKeys.publicKey)
    expect(cryptedReply.toString()).not.toEqual("Hello, Ana")

    // Ana recebe a resposta de Bob
    const reply = asymmetricCrypto.decrypt(cryptedReply, anaKeys.privateKey)
    expect(reply.toString()).toEqual("Hello, Ana")
})

// src/AsymmetricCrypto.ts 

import { generateKeyPair as cryptoGenerateKeyPair, publicEncrypt, privateDecrypt } from "node:crypto"
import { promisify } from 'node:util'

export type KeyPair = {
    privateKey: string 
    publicKey: string
}

export class AsymmetricCrypto {

    public async generateKeyPair(): Promise<KeyPair> {
        const { privateKey, publicKey } = await promisify(cryptoGenerateKeyPair)('rsa', {
            modulusLength: 4096,
            publicKeyEncoding: {
              type: 'spki',
              format: 'pem'
            },
            privateKeyEncoding: {
              type: 'pkcs8',
              format: 'pem'
            }
          })

        return {
            privateKey,
            publicKey
        }
    }

    public encrypt(message: string, recipientKey: string): Buffer {
        return publicEncrypt(recipientKey, Buffer.from(message))
    }

    public decrypt(encryptedMessage: Buffer, privateKey: string): Buffer {
        return privateDecrypt(privateKey, encryptedMessage)
    }
}