import { bech32 } from 'bech32'
import crypto from 'crypto'
import hexEncoding from 'crypto-js/enc-hex'
import ripemd160 from 'crypto-js/ripemd160'
import sha256 from 'crypto-js/sha256'

/**
 * Convert string to bytes.
 *
 * @param {string} string
 * @returns {number[]} The bytes from the given string.
 */
export const getBytes = (string: string): number[] => {
  const arrayBytes: number[] = []
  const buffer = Buffer.from(string, 'utf16le')
  for (let i = 0; i < buffer.length; i++) {
    arrayBytes.push(buffer[i])
  }
  return arrayBytes
}

/**
 * Convert Buffer to hex string.
 *
 * @param {Buffer} arr
 * @returns {string} The hex string from the given buffer.
 */
export const ab2hexstring = (arr: Buffer) => {
  let result = ''
  for (let i = 0; i < arr.length; i++) {
    let str = arr[i].toString(16)
    str = str.length === 0 ? '00' : str.length === 1 ? '0' + str : str
    result += str
  }
  return result
}

/**
 * Calculate `ripemd160(sha256(hex))` from the hex string
 *
 * @param {string} hex The hex encoded string.
 * @returns {string} The hex string from the given buffer.
 *
 * @throws {"sha256ripemd160 expects a string"} Thrown if non-string is provided.
 * @throws {"invalid hex string length"} Thrown if the given hex string is an invalid one.
 */
export const sha256ripemd160 = (hex: string): string => {
  if (typeof hex !== 'string') throw new Error('sha256ripemd160 expects a string')
  if (hex.length % 2 !== 0) throw new Error(`invalid hex string length: ${hex}`)
  const hexEncoded = hexEncoding.parse(hex)
  const ProgramSha256 = sha256(hexEncoded)
  return ripemd160(ProgramSha256).toString()
}

/**
 * Encode address from the string or Buffer.
 *
 * @param {string|Buffer} value The string or Buffer to be encoded.
 * @param {string} prefix The prefix of the address. (optional)
 * @param {BufferEncoding} type The buffer encoding type. It will be used when string is provided. (optional)
 * @returns {string} The address generated from the given string or buffer.
 */
export const encodeAddress = (value: string | Buffer, prefix = 'dojima', type: BufferEncoding = 'hex'): string => {
  let words
  if (Buffer.isBuffer(value)) {
    words = bech32.toWords(Buffer.from(value))
  } else {
    words = bech32.toWords(Buffer.from(value, type))
  }
  return bech32.encode(prefix, words)
}

/**
 * Create address from the public key.
 *
 * @param {Buffer} publicKey The public key in Buffer format.
 * @returns {string} The address generated from the given public key(buffer format).
 */
export const createAddress = (publicKey: Buffer): string => {
  const hexed = ab2hexstring(publicKey)
  const hash = sha256ripemd160(hexed)
  const address = encodeAddress(hash, 'dojima')
  return address
}

/**
 * Calculate pbkdf2 (Password-Based Key Derivation Function 2).
 *
 * @param {string|Buffer|Array|DataView} passphrase.
 * @param {string|Buffer|Array|DataView} salt
 * @param {number} iterations
 * @param {number} keylen
 * @param {string} digest
 * @returns {Buffer} The pbkdf2 value from the given options.
 */
export const pbkdf2Async = async (
  passphrase: string | Buffer | NodeJS.TypedArray | DataView,
  salt: string | Buffer | NodeJS.TypedArray | DataView,
  iterations: number,
  keylen: number,
  digest: string,
): Promise<Buffer> => {
  return new Promise<Buffer>((resolve, reject) => {
    crypto.pbkdf2(passphrase, salt, iterations, keylen, digest, (err, drived) => {
      if (err) {
        reject(err)
      } else {
        resolve(drived)
      }
    })
  })
}