import * as bip39 from 'bip39'
import crypto from 'crypto'
import { blake256 } from 'foundry-primitives'
import { v4 as uuidv4 } from 'uuid'

import { pbkdf2Async } from './utils'

// Constants
const cipher = 'aes-128-ctr'
const kdf = 'pbkdf2'
const prf = 'hmac-sha256'
const dklen = 32
const c = 262144
const hashFunction = 'sha256'
const meta = 'd11k-keystore'

/**
 * The Keystore interface
 */
export type Keystore = {
  crypto: {
    cipher: string
    ciphertext: string
    cipherparams: {
      iv: string
    }
    kdf: string
    kdfparams: {
      prf: string
      dklen: number
      salt: string
      c: number
    }
    mac: string
  }
  id: string
  version: number
  meta: string
}

/**
 * Determines if the current environment is node
 *
 * @returns {boolean} True if current environment is node
 */
const _isNode = (): boolean => {
  return typeof window === 'undefined'
}

/**
 * Generate a new phrase.
 *
 * @param {string} size The new phrase size.
 * @returns {string} The generated phrase based on the size.
 */
export const generatePhrase = (size = 12): string => {
  if (_isNode()) {
    const bytes = crypto.randomBytes((size == 12 ? 128 : 256) / 8)
    const phrase = bip39.entropyToMnemonic(bytes)
    return phrase
  } else {
    const entropy = size == 12 ? 128 : 256
    const phrase = bip39.generateMnemonic(entropy)
    return phrase
  }
}

/**
 * Validate the given phrase.
 *
 * @param {string} phrase
 * @returns {boolean} `true` or `false`
 */
export const validatePhrase = (phrase: string): boolean => {
  return bip39.validateMnemonic(phrase)
}

/**
 * Get the seed from the given phrase.
 *
 * @param {string} phrase
 * @returns {Buffer} The seed from the given phrase.
 *
 * @throws {"Invalid BIP39 phrase"} Thrown if phrase is an invalid one.
 */
export const getSeed = (phrase: string): Buffer => {
  if (!validatePhrase(phrase)) {
    throw new Error('Invalid BIP39 phrase')
  }

  return bip39.mnemonicToSeedSync(phrase)
}

/**
 * Get the Keystore interface from the given phrase and password.
 *
 * @param {string} phrase
 * @param {string} password
 * @returns {Keystore} The keystore interface generated from the given phrase and password.
 *
 * @throws {"Invalid BIP39 phrase"} Thrown if phrase is an invalid one.
 */
export const encryptToKeyStore = async (phrase: string, password: string): Promise<Keystore> => {
  if (!validatePhrase(phrase)) {
    throw new Error('Invalid BIP39 phrase')
  }

  const ID = _isNode() ? require('uuid').v4() : uuidv4()
  const salt = crypto.randomBytes(32)
  const iv = crypto.randomBytes(16)
  const kdfParams = {
    prf: prf,
    dklen: dklen,
    salt: salt.toString('hex'),
    c: c,
  }
  const cipherParams = {
    iv: iv.toString('hex'),
  }

  const derivedKey = await pbkdf2Async(Buffer.from(password), salt, kdfParams.c, kdfParams.dklen, hashFunction)
  const cipherIV = crypto.createCipheriv(cipher, derivedKey.slice(0, 16), iv)
  const cipherText = Buffer.concat([cipherIV.update(Buffer.from(phrase, 'utf8')), cipherIV.final()])
  const mac = blake256(Buffer.concat([derivedKey.slice(16, 32), Buffer.from(cipherText)]))

  const cryptoStruct = {
    cipher: cipher,
    ciphertext: cipherText.toString('hex'),
    cipherparams: cipherParams,
    kdf: kdf,
    kdfparams: kdfParams,
    mac: mac,
  }

  const keystore = {
    crypto: cryptoStruct,
    id: ID,
    version: 1,
    meta: meta,
  }

  return keystore
}

/**
 * Get the phrase from the keystore
 *
 * @param {Keystore} keystore
 * @param {string} password
 * @returns {Keystore} The phrase from the keystore.
 *
 * @throws {"Invalid password"} Thrown if password is an incorrect one.
 */
export const decryptFromKeystore = async (keystore: Keystore, password: string): Promise<string> => {
  const kdfparams = keystore.crypto.kdfparams
  const derivedKey = await pbkdf2Async(
    Buffer.from(password),
    Buffer.from(kdfparams.salt, 'hex'),
    kdfparams.c,
    kdfparams.dklen,
    hashFunction,
  )

  const ciphertext = Buffer.from(keystore.crypto.ciphertext, 'hex')
  const mac = blake256(Buffer.concat([derivedKey.slice(16, 32), ciphertext]))

  if (mac !== keystore.crypto.mac) throw new Error('Invalid password')
  const decipher = crypto.createDecipheriv(
    keystore.crypto.cipher,
    derivedKey.slice(0, 16),
    Buffer.from(keystore.crypto.cipherparams.iv, 'hex'),
  )

  const phrase = Buffer.concat([decipher.update(ciphertext), decipher.final()])
  return phrase.toString('utf8')
}