import Decimal from 'decimal.js'
// 格式化金额为货币格式
export function formatCurrency(value, currency = '', fixedDigits = 2) {
  if (value === undefined || value === null) return currency + '0.00'
  return currency + value.toFixed(fixedDigits).replace(/\d(?=(\d{3})+\.)/g, '$&,')
}
// 数字格式化
export function numberFormat(value, item) {
  const { valueType = 'text', decimalDigits = 2 } = item
  //   if (!value) return

  let result = String(value ?? '').trim()

  if (valueType === 'integer') {
    // 只保留数字和负号
    result = result.replace(/[^-\d]/g, '')

    // 如果有多个负号或者负号不在开头，则移除多余的负号
    if ((result.match(/-/g) || []).length > 1) {
      result = result.replace(/-/g, '').replace(/^/, '-') // 仅保留一个负号在最前面
    }
  } else if (valueType === 'decimalNumber') {
    // 可以输入正数，负数，小数
    // 1. 只保留数字、小数点和负号
    result = result.replace(/[^-\d.]/g, '')

    // 2. 处理负号：确保最多只有一个负号且必须在开头
    if ((result.match(/-/g) || []).length > 1) {
      result = result.replace(/-/g, '') // 移除所有负号
      if (result.startsWith('-')) {
        result = '-' + result.slice(1) // 确保负号在最前面
      } else {
        result = '-' + result // 如果原本没有负号但需要保留数值，可以省略此步骤
      }
    }

    // 3. 去掉开头的小数点（不允许 ".5" → 改为 "0.5" 更好）
    if (result.startsWith('.')) {
      result = '0' + result
    } else if (result.startsWith('-.')) {
      result = '-0' + result.slice(2)
    }

    // 4. 保证最多一个小数点
    const parts = result.split('.')
    if (parts.length > 2) {
      result = parts[0] + '.' + parts.slice(1).join('')
    }

    // 5. 限制小数位数（但保留结尾的小数点！）
    if (result.includes('.')) {
      const [intPart, decPart] = result.split('.')
      // 如果小数部分超过限制，截断
      if (decPart.length > decimalDigits) {
        result = intPart + '.' + decPart.slice(0, decimalDigits)
      }
      // ✅ 不再删除结尾的 '.'
    }
  } else if (valueType === 'decimal') {
    // 可以输入正整数和小数
    // 1. 只保留数字和小数点
    result = result.replace(/[^\d.]/g, '')

    // 2. 去掉开头的小数点（不允许 ".5" → 改为 "0.5" 更好，但这里先简单处理）
    if (result.startsWith('.')) {
      result = '0.' + result.slice(1)
    }

    // 3. 保证最多一个小数点
    const parts = result.split('.')
    if (parts.length > 2) {
      result = parts[0] + '.' + parts.slice(1).join('')
    }

    // 4. 限制小数位数（但保留结尾的小数点！）
    if (result.includes('.')) {
      const [intPart, decPart] = result.split('.')
      // 如果小数部分超过限制，截断
      if (decPart.length > decimalDigits) {
        result = intPart + '.' + decPart.slice(0, decimalDigits)
      }
    }
  }

  return result
}
/**
 * 为数字添加千位分隔符（分位符）
 * @param {number|string} value - 要格式化的数字
 * @param {number} decimalDigits - 小数位数，默认2位
 * @param {boolean} keepNegative - 是否保留负号，默认true
 * @returns {string} 格式化后的数字字符串
 * @example
 * formatThousands(1234.56) => '1,234.56'
 * formatThousands(-1234.56) => '-1,234.56'
 * formatThousands(1000) => '1,000.00'
 * formatThousands('1234567.89') => '1,234,567.89'
 */
export function formatThousands(value, decimalDigits = 2, keepNegative = true) {
  // 处理空值
  if (value === undefined || value === null || value === '') {
    return '0.00'
  }

  // 转换为字符串并去除已有的逗号
  let numStr = String(value).replace(/,/g, '').trim()

  // 如果字符串为空，返回默认值
  if (numStr === '') {
    return '0.00'
  }

  // 检查是否为负数
  const isNegative = keepNegative && numStr.startsWith('-')
  // 移除负号以便处理数字部分
  let absNumStr = isNegative ? numStr.slice(1) : numStr

  // 如果移除负号后为空，返回默认值
  if (absNumStr === '') {
    return isNegative ? '-0.00' : '0.00'
  }

  // 分割整数和小数部分
  let [intPart, decPart] = absNumStr.split('.')

  // 处理整数部分：如果为空，设为'0'
  intPart = intPart || '0'

  // 确保整数部分只包含数字
  intPart = intPart.replace(/[^\d]/g, '')
  if (intPart === '') {
    intPart = '0'
  }

  // 处理小数部分
  if (decPart !== undefined) {
    // 只保留数字
    decPart = decPart.replace(/[^\d]/g, '')
    // 如果小数部分超过指定长度，截断；如果不足，补零
    if (decPart.length > decimalDigits) {
      decPart = decPart.slice(0, decimalDigits)
    } else if (decPart.length < decimalDigits) {
      decPart = decPart.padEnd(decimalDigits, '0')
    }
  } else {
    // 如果没有小数部分，创建指定长度的零
    decPart = '0'.repeat(decimalDigits)
  }

  // 为整数部分添加千位分隔符
  intPart = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',')

  // 组合结果
  let result = decimalDigits > 0 ? `${intPart}.${decPart}` : intPart

  // 添加负号
  if (isNegative && parseFloat(intPart.replace(/,/g, '')) > 0) {
    result = '-' + result
  }

  return result
}

/**
 * 格式化数字为带千位分隔符的字符串（不强制小数位数）
 * @param {number|string} value - 要格式化的数字
 * @returns {string} 格式化后的数字字符串
 * @example
 * formatThousandsSimple(1234567.89) => '1,234,567.89'
 * formatThousandsSimple(-1234.5) => '-1,234.5'
 */
export function formatThousandsSimple(value) {
  if (value === undefined || value === null || value === '') {
    return ''
  }

  let numStr = String(value).replace(/,/g, '').trim()
  if (numStr === '') {
    return ''
  }

  // 检查是否为负数
  const isNegative = numStr.startsWith('-')
  let absNumStr = isNegative ? numStr.slice(1) : numStr

  // 分割整数和小数部分
  const [intPart, decPart] = absNumStr.split('.')

  // 为整数部分添加千位分隔符
  const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',')

  // 组合结果
  let result = decPart !== undefined ? `${formattedInt}.${decPart}` : formattedInt

  // 添加负号
  if (isNegative) {
    result = '-' + result
  }

  return result
}
export function inputThousands(value) {
  if (value === undefined || value === null || value === '') {
    return ''
  }
  const parts = String(value).split('.')
  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',')
  return parts.join('.')
}
/**
 * 金额计算（乘/除），保留指定位数小数（四舍五入）
 * @param {number|string|Decimal} a - 被乘数（或被除数）
 * @param {number|string|Decimal} b - 乘数（或除数）
 * @param {number} digits - 小数位数（默认2）
 * @param {string} [type] - 'Divided' 表示除法，否则乘法
 * @returns {number|null} 计算结果（数字类型）
 */
export function calculateAmount(a, b, digits = 2, type) {
  if (a == null || b == null) return null
  try {
    const da = new Decimal(a)
    const db = new Decimal(b)
    let result
    if (type === 'Divided') {
      if (db.isZero()) return null // 除零保护
      result = da.dividedBy(db)
    } else {
      result = da.times(db)
    }
    // 四舍五入到指定位数，并转为 Number（若需要字符串可用 .toFixed(digits)）
    // return result.toDecimalPlaces(digits, Decimal.ROUND_HALF_UP).toNumber()

    return result.toFixed(digits, Decimal.ROUND_HALF_UP)
  } catch (e) {
    return null
  }
}
/**
 * 格式化数字，保留最多 maxDigits 位小数，自动去除尾随零
 * @param {number|null|undefined} value - 原始数值
 * @param {number} maxDigits - 最多保留的小数位数，默认 5
 * @param {string} defaultValue - 无效值时的占位符，默认 '-'
 * @returns {string} 格式化后的字符串
 */
export function formatNumberToMaxDigits(value, maxDigits = 5, defaultValue = '-') {
  if (value === undefined || value === null || isNaN(Number(value))) {
    return defaultValue;
  }
  const num = Number(value);
  // 先固定保留 maxDigits 位小数（四舍五入）
  const fixed = num.toFixed(maxDigits);
  // 移除末尾的0，如果小数部分全是0则连小数点一起移除
  const trimmed = fixed.replace(/\.?0+$/, '');
  return trimmed;
}
export default {
  formatCurrency,
  numberFormat,
  formatThousands,
  formatThousandsSimple,
  inputThousands,
  calculateAmount
}
