/**
 * @description: 将数字转化为字符串格式(添加逗号隔开)
 * @param {Number}  必选，需要添加逗号换算的数字
 * @return: {String} 数字添加了逗号的字符串
 */
export function numFormatToStr (data) {
  if (typeof data !== 'number') {
    return '0'
  }
  data = data || 0
  let negative = false
  if (data === 0) {
    return '0'
  }
  if (data < 0) {
    data *= -1
    negative = true
  }
  if (data) {
    let x1 = window.parseInt(data).toString()
    let len = x1.length
    let x2 = data.toString().slice(len)
    if (len <= 3) {
      return negative ? '-' + x1 + x2 : x1 + x2
    }
    let r = len % 3
    let b = x1.slice(r, len).match(/\d{3}/g).join(',')
    x1 = r > 0 ? x1.slice(0, r) + ',' + b : b
    let x = negative ? '-' + x1 + x2 : x1 + x2
    return x
  } else {
    return '0'
  }
}

/**
 * @description: 数值截取小数点后最多num位(不足num位，不补零)，非四舍五入
 * @param {Number} 必选
 * @param {Number} 可选，默认0
 * @return: {Number} 小数点位数截取后的数字
 */
export function sliceFloatNum (number, sliceNum) {
  if (typeof number !== 'number') {
    return 0
  }
  let numberStr = number.toString()
  let pointIndex = numberStr.indexOf('.')
  if (~pointIndex) {
    if (sliceNum) {
      number = numberStr.slice(0, pointIndex + sliceNum + 1)
    } else {
      number = numberStr.slice(0, pointIndex)
    }
  }
  return parseFloat(number)
}

/**
 * @description:  截取小数点后num位(若返回字符串，不足num位，则补零)，非四舍五入
 * @param {Number} 必选
 * @param {Number} 可选，默认2
 * @param {Boolean} 可选，是否转化为逗号分隔的字符串
 * @return: {Number | String} 小数点位数截取后的数字
 */
export function formatNum (data, sliceNum = 2, isFormatToStr = false) {
  if (!data || typeof data !== 'number') {
    return isFormatToStr ? '0' : 0
  }
  let negative = false
  if (data < 0) {
    negative = true
    data *= -1
  }
  let x1 = window.parseInt(data)
  let len = x1.toString().length
  data = sliceFloatNum(data, sliceNum)
  let x2 = data.toString().slice(len)
  let floatLength = sliceNum - x2.length
  if (~x2.indexOf('.')) {
    floatLength++
  }
  if (floatLength > 0) {
    if (!x2) { // 若数值为整数，不存在小数，则先添加小数点
      x2 = '.'
    }
    for (let i = 0; i < floatLength; i++) { // 小数点位数不足sliceNum位，则补零
      x2 += '0'
    }
  }
  if (isFormatToStr) { // 转化为字符串格式
    data = (negative ? '-' : '') + (numFormatToStr(x1) + x2)
  } else {
    data = parseFloat(x1 + x2)
    if (negative) {
      data *= -1
    }
  }
  return data
}

/**
 * @description:  formatNum数组里的数字
 * @param {Array} 必选，数字数组
 * @param {Number} 可选，默认2
 * @param {Boolean} 可选，是否转化为逗号分隔的字符串
 * @return: {Array} 返回一个数组，数组里的数字均为小数点位数截取为指定位数
 */
export function formatNumArray (dataArray, num = 2, isFormatToStr = false) {
  if (!(dataArray instanceof Array)) { // 输入非数组，返回[]
    return []
  }
  let formatDataArray = []
  for (let key in dataArray) {
    formatDataArray[key] = formatNum(dataArray[key], num, isFormatToStr)
  }
  return formatDataArray
}

/**
 * @description: 返回小数点后的数字长度
 * @param {Number}
 * @return: {Number}
 */
function getDigitLength (num) {
  let r
  try {
    r = num.toString().split('.')[1].length
  } catch (e) {
    r = 0
  }
  return r
}

/**
 * @description: 解决js浮点数的加法精度错误
 * @param {Number} 必选，加数
 * @param {Number} 必选，被加数
 * @return: {Number} 返回两个数的和
 */
export function accuratePlus (num1, num2) {
  let r1 = getDigitLength(num1)
  let r2 = getDigitLength(num2)
  let m = Math.pow(10, Math.max(r1, r2))
  return Math.round(num1 * m + num2 * m) / m
}

/**
 * @description: 解决js浮点数的减法精度错误
 * @param {Number} 必选，减数
 * @param {Number} 必选，被减数
 * @return: {Number} 返回两个数的差
 */
export function accurateMinus (num1, num2) {
  let r1 = getDigitLength(num1)
  let r2 = getDigitLength(num2)
  let m = Math.pow(10, Math.max(r1, r2))
  return Math.round(num1 * m - num2 * m) / m
}

/**
 * @description: 解决js浮点数的乘法精度错误
 * @param {Number} 必选，乘数
 * @param {Number} 必选，被乘数
 * @return: {Number} 返回两个数的积
 */
export function accurateTimes (num1, num2) {
  let m = 0
  let s1 = num1.toString()
  let s2 = num2.toString()
  try {
    m += s1.split('.')[1].length
  } catch (e) {}
  try {
    m += s2.split('.')[1].length
  } catch (e) {}
  let r1 = Number(s1.replace('.', ''))
  let r2 = Number(s2.replace('.', ''))
  return (r1 * r2) / Math.pow(10, m)
}

/**
 * @description: 解决js浮点数的除法精度错误
 * @param {Number} 必选，除数
 * @param {Number} 必选，被除数
 * @return: {Number} 返回两个数的商
 */
export function accurateDivide (num1, num2) {
  let t1 = getDigitLength(num1)
  let t2 = getDigitLength(num2)
  let r1 = Number(num1.toString().replace('.', ''))
  let r2 = Number(num2.toString().replace('.', ''))
  return (r1 / r2) * Math.pow(10, t2 - t1)
}