/**
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string}
 */
export function parseTime(time, cFormat) {
  if (arguments.length === 0) {
    return null
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object' && time) {
    date = time
  } else {
    if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
      time = parseInt(time)
    }
    if (typeof time === 'number' && time.toString().length === 10) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const timeStr = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value]
    }
    if (result.length > 0 && value < 10) {
      value = '0' + value
    }
    return value || 0
  })
  return timeStr
}

/**
 * @param {string} url
 * @returns {Object}
 */
export function getQueryObject(url) {
  url = url == null ? window.location.href : url
  const search = url.substring(url.lastIndexOf('?') + 1)
  const obj = {}
  const reg = /([^?&=]+)=([^?&=]*)/g
  search.replace(reg, (rs, $1, $2) => {
    const name = decodeURIComponent($1)
    let val = decodeURIComponent($2)
    val = String(val)
    obj[name] = val
    return rs
  })
  return obj
}

/**
 * @param {string} input value
 * @returns {number} output value
 */
export function byteLength(str) {
  // returns the byte length of an utf8 string
  let s = str.length
  for (var i = str.length - 1; i >= 0; i--) {
    const code = str.charCodeAt(i)
    if (code > 0x7f && code <= 0x7ff) s++
    else if (code > 0x7ff && code <= 0xffff) s += 2
    if (code >= 0xdc00 && code <= 0xdfff) i--
  }
  return s
}

/**
 * @param {Array} actual
 * @returns {Array}
 */
export function cleanArray(actual) {
  const newArray = []
  for (let i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(actual[i])
    }
  }
  return newArray
}

/**
 * @param {Object} json
 * @returns {Array}
 */
export function param(json) {
  if (!json) return ''
  return cleanArray(
    Object.keys(json).map(key => {
      if (json[key] === undefined) return ''
      return encodeURIComponent(key) + '=' + encodeURIComponent(json[key])
    })
  ).join('&')
}

/**
 * @param {string} url
 * @returns {Object}
 */
export function param2Obj(url) {
  const search = url.split('?')[1]
  if (!search) {
    return {}
  }
  return JSON.parse(
    '{"' +
      decodeURIComponent(search)
        .replace(/"/g, '\\"')
        .replace(/&/g, '","')
        .replace(/=/g, '":"')
        .replace(/\+/g, ' ') +
      '"}'
  )
}

/**
 * Merges two objects, giving the last one precedence
 * @param {Object} target
 * @param {(Object|Array)} source
 * @returns {Object}
 */
export function objectMerge(target, source) {
  if (typeof target !== 'object') {
    target = {}
  }
  if (Array.isArray(source)) {
    return source.slice()
  }
  Object.keys(source).forEach(property => {
    const sourceProperty = source[property]
    if (typeof sourceProperty === 'object') {
      target[property] = objectMerge(target[property], sourceProperty)
    } else {
      target[property] = sourceProperty
    }
  })
  return target
}

/**
 * @param {string} type
 * @returns {Date}
 */
export function getTime(type) {
  if (type === 'start') {
    return new Date().getTime() - 3600 * 1000 * 24 * 90
  } else {
    return new Date(new Date().toDateString())
  }
}

/**
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @return {*}
 */
export function debounce(func, wait, immediate) {
  let timeout, args, context, timestamp, result

  const later = function() {
    // 据上一次触发时间间隔
    const last = +new Date() - timestamp

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last)
    } else {
      timeout = null
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args)
        if (!timeout) context = args = null
      }
    }
  }

  return function(...args) {
    context = this
    timestamp = +new Date()
    const callNow = immediate && !timeout
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait)
    if (callNow) {
      result = func.apply(context, args)
      context = args = null
    }

    return result
  }
}

/**
 * 节流
 * @param {*} func
 * @param {*} wait
 * @param {*} immediate
 */
export function throttle(fn, wait = 1000, immediate) {
  let timer = null
  let callNow = immediate
  return function(...args) {
    let context = this
    if (callNow) {
      fn.apply(context, args)
      callNow = null
    }
    if (!timer) {
      timer = setTimeout(() => {
        fn.apply(context, args)
        timer = null
      }, wait)
    }
  }
}

/**
 * @param {Array} arr
 * @returns {Array}
 */
export function uniqueArr(arr) {
  return Array.from(new Set(arr))
}

/**
 * @returns {string}
 */
export function createUniqueString() {
  const timestamp = +new Date() + ''
  const randomNum = parseInt((1 + Math.random()) * 65536) + ''
  return (+(randomNum + timestamp)).toString(32)
}
/**
 * 延迟执行某个操作
 * @param {} ms
 */
export function timeout(ms) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, ms, 'done')
  })
}
/**
 * 二进制转文件
 * @param {*} blobs blob对象
 * @param {*} fileName 文件名
 */
export function blob2File(blobs, fileName) {
  const blob = new Blob([blobs])
  const href = window.URL.createObjectURL(blob) // 创建下载的链接
  const aEle = document.createElement('a') // 创建a标签
  aEle.href = href
  aEle.download = fileName // 下载后文件名
  document.body.appendChild(aEle)
  aEle.click() // 点击下载
  document.body.removeChild(aEle) // 下载完成移除元素
  window.URL.revokeObjectURL(href) // 释放掉blob对象
}
/**
 * url下载文件
 * @param {*} url
 * @param {*} name
 */
export function downFile(url, name) {
  const a = document.createElement('a')
  a.href = url
  a.download = name
  document.body.appendChild(a)
  a.click()
  document.body.removeChild(a)
}

/**
 * 对象转换成formdata形式
 * @param {*} data
 */
export function obj2FormData(data) {
  const form = new FormData()
  Object.keys(data).forEach(key => {
    if (data[key] !== undefined) {
      form.append(key, data[key])
    }
  })
  return form
}
function typeOf(obj) {
  const toString = Object.prototype.toString
  const map = {
    '[object Boolean]': 'boolean',
    '[object Number]': 'number',
    '[object String]': 'string',
    '[object Null]': 'null',
    '[object Undefined]': 'undefined',
    '[object Symbol]': 'symbol',
    '[object Object]': 'object',
    '[object Function]': 'function',
    '[object Array]': 'array',
    '[object Date]': 'date',
    '[object RegExp]': 'regexp'
  }
  return map[toString.call(obj)]
}
/**
 * 深克隆
 * @param {*} data
 */
export function deepClone(data) {
  const type = typeOf(data)
  let copy
  if (type === 'array') {
    copy = []
  } else if (type === 'object') {
    copy = {}
  } else {
    return data
  }
  if (type === 'array') {
    for (let i = 0; i < data.length; i++) {
      copy.push(deepClone(data[i]))
    }
  }
  if (type === 'object') {
    for (let key in data) {
      copy[key] = deepClone(data[key])
    }
  }
  return copy
}

/**
 * filter undefined
 * @param {*} temp
 */
export function parseUndefined(temp) {
  // 判断是否为0
  if (temp === 0 || temp === '0') {
    return temp
  }
  if (temp) {
    return temp
  } else {
    return undefined
  }
}
/**
 * 获取目标的元素的截图
 * @param {*} target
 * @param {*} format
 */
export function shotTargetToImage(target, format) {
  const canvas = document.createElement('canvas') // 创建画布
  canvas.width = target.videoWidth
  canvas.height = target.videoHeight // 设定宽高比
  canvas.getContext('2d').drawImage(target, 0, 0, canvas.width, canvas.height) // 将视频此刻帧数画入画布
  return canvas.toDataURL(format)
}

// 去掉base头部
export function substringBasehead(base64) {
  let length = 'data:image/png;base64,'.length
  return base64.substring(length)
}

export function parseTimeSecond(time) {
  let minutes = parseInt((time % (1000 * 60 * 60)) / (1000 * 60))
  let second = parseInt((time % (1000 * 60)) / 1000)
  if (minutes < 10) {
    minutes = `0${minutes}`
  }
  if (second < 10) {
    second = `0${second}`
  }
  return `${minutes}:${second}`
}

export function sleep(time) {
  return new Promise(resolve => {
    setTimeout(resolve, time)
  })
}