import elliptic from 'elliptic'
import { createHash } from 'crypto'
import * as fs from 'fs'

export default class ECCKey {
    keyPair: elliptic.ec.KeyPair

    constructor(keyPair: elliptic.ec.KeyPair) {
        this.keyPair = keyPair
    }

    static generate(): ECCKey {
        const EC = new elliptic.ec('p256')
        const keyPair = EC.genKeyPair()
        return new ECCKey(keyPair)
    }

    static construct(privateKey: Buffer | string | number): ECCKey {
        if (Buffer.isBuffer(privateKey)) {
            privateKey = privateKey.toString('hex')
        } else if (typeof privateKey === 'number') {
            privateKey = privateKey.toString(16)
        }

        const EC = new elliptic.ec('p256')
        const keyPair = EC.keyFromPrivate(privateKey, 'hex')

        return new ECCKey(keyPair)
    }

    static loads(data: string | Buffer): ECCKey {
        if (typeof data === 'string') {
            data = Buffer.from(data, 'base64')
        }
        if (!Buffer.isBuffer(data)) {
            throw new Error(`Expecting Bytes or Base64 input, got ${data}`)
        }

        if (data.length !== 96 && data.length !== 32) {
            throw new Error(
                `Invalid data length. Expecting 96 or 32 bytes, got ${data.length}`
            )
        }

        const privateKey = data.subarray(0, 32)
        return ECCKey.construct(privateKey)
    }

    static load(filePath: string): ECCKey {
        const data = fs.readFileSync(filePath)
        return ECCKey.loads(data)
    }

    dumps(): Buffer {
        return Buffer.concat([this.privateBytes(), this.publicBytes()])
    }

    dump(filePath: string): void {
        fs.writeFileSync(filePath, this.dumps())
    }

    getPoint(): { x: string; y: string } {
        const publicKey = this.keyPair.getPublic()
        return {
            x: publicKey.getX().toString('hex'),
            y: publicKey.getY().toString('hex')
        }
    }

    privateBytes(): Buffer {
        const privateKey = this.keyPair.getPrivate()
        return Buffer.from(privateKey.toArray('be', 32))
    }

    privateSha256Digest(): Buffer {
        const hash = createHash('sha256')
        hash.update(this.privateBytes())
        return hash.digest()
    }

    publicBytes(): Buffer {
        const publicKey = this.keyPair.getPublic()
        const x = publicKey.getX().toArray('be', 32)
        const y = publicKey.getY().toArray('be', 32)
        return Buffer.concat([Buffer.from(x), Buffer.from(y)])
    }

    publicSha256Digest(): Buffer {
        const hash = createHash('sha256')
        hash.update(this.publicBytes())
        return hash.digest()
    }
}