import { str2uint, getType } from './helper.js'

const subtle = window.crypto.subtle

var __stamp__ = 0
var __inc__ = 0 //用于生成保证唯一的uuid种子

// 将其他数据类型转为uint8
function any2uint(data) {
  let val = data ?? ''
  let type = getType(val)
  switch (type) {
    case 'Uint8Array':
      break

    case 'ArrayBuffer':
      val = new Uint8Array(val)
      break

    case 'Number':
    case 'String':
    case 'Boolean':
      val = str2uint(val)
      break

    default:
      val = val.toString()
      break
  }
  return val
}

export function uuid(pipe = '-') {
  var rand = Math.random().toString(16).slice(2) + Math.random().toString(16).slice(2)
  var now = (~~(Date.now() / 1000)).toString(16)

  if (__stamp__ === now) {
    __inc__++
  } else {
    __stamp__ = now
    __inc__ = 0
  }
  rand = __inc__.toString(16) + rand
  return __stamp__ + pipe + rand.slice(0, 4) + pipe + rand.slice(4, 8) + pipe + rand.slice(-8)
}

/**
 * ArrayBuffer 转 hex
 */
export function ab2hex(buf) {
  var uint8 = new Uint8Array(buf)
  return [...uint8].map(n => n.toString(16).padStart(2, '0')).join('')
}

/**
 * ArrayBuffer 转 Binary
 */
export function ab2bin(buf) {
  var bin = ''
  var uint8 = new Uint8Array(buf)
  for (var i = 0; i < uint8.length; i++) {
    bin += String.fromCharCode(uint8[i])
  }
  return bin
}

/* ------------------------------------- */

/**
 * @return Promise
 */
export function hash(type, data) {
  return subtle.digest(type, any2uint(data)).then(buf => ab2hex(buf))
}

export function sha1(str) {
  return hash('SHA-1', str)
}

export function sha256(str) {
  return hash('SHA-256', str)
}

export function sha512(str) {
  return hash('SHA-512', str)
}

export function hmac(mode, data = '', key = '', encode) {
  if (key) {
    if (typeof key === 'string') {
      key = str2uint(key)
    }
  } else {
    key = new Uint8Array(16)
  }
  return subtle
    .importKey('raw', key, { name: 'HMAC', hash: { name: mode } }, true, ['sign', 'verify'])
    .then(cKey => subtle.sign('HMAC', cKey, any2uint(data)))
    .then(ab => {
      var output = ab

      switch (encode) {
        case 'binary':
          output = ab2bin(ab)
          break
        case 'hex':
          output = ab2hex(ab)
          break
        case 'base64':
          output = window.btoa(ab2bin(ab))
          break
        case 'buffer':
          output = new Uint8Array(ab)
          break
      }

      return output
    })
}