
/**
 * 深度比较两个对象或数组是否相同
 * @param {any} obj1
 * @param {any} obj2
 * @returns {Boolean}
 */
export function isDeepEqual(obj1: any, obj2: any) {
  // 检查类型是否相同
  if (typeof obj1 !== typeof obj2) return false;

  // 如果不是对象或为空，直接比较值
  if (obj1 === null || obj2 === null || typeof obj1 !== 'object') {
    return obj1 === obj2;
  }


  if (isNumeric(obj1) && isNumeric(obj2)) {
    console.log("-----111111")
    // 将两者都转为数字进行比较，处理 "4.00" == 4 的情况
    return Number(obj1) === Number(obj2);
  }

  // 处理数组
  if (Array.isArray(obj1) && Array.isArray(obj2)) {
    if (obj1.length !== obj2.length) return false;

    // 先对数组进行排序比较（如果需要基于特定字段比较）
    const sortedObj1 = [...obj1].sort((a, b) => a.sortNumber - b.sortNumber);
    const sortedObj2 = [...obj2].sort((a, b) => a.sortNumber - b.sortNumber);

    // 递归比较每个元素
    for (let i = 0; i < sortedObj1.length; i++) {
      if (!isDeepEqual(sortedObj1[i], sortedObj2[i])) {
        return false;
      }
    }
    return true;
  }

  // 处理普通对象
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);

  if (keys1.length !== keys2.length) return false;

  // 检查所有键值对是否相同
  for (const key of keys1) {
    if (!keys2.includes(key) || !isDeepEqual(obj1[key], obj2[key])) {
      return false;
    }
  }

  return true;
}

/**
 * 深度比较两个数组中的对象是否相等，支持数字和数字字符串的等价比较
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {boolean} - 如果两个数组的所有元素深度相等返回 true
 */
export function deepEqualArrays(arr1, arr2) {
  // 1. 快速检查：相同引用或都是 null/undefined
  if (arr1 === arr2) return true;

  // 2. 检查是否为数组
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) {
    return false;
  }

  // 3. 检查数组长度
  if (arr1.length !== arr2.length) return false;

  // 4. 深度比较每个元素
  for (let i = 0; i < arr1.length; i++) {
    if (!deepEqualObjects(arr1[i], arr2[i])) {
      return false;
    }
  }

  return true;
}

/**
 * 深度比较两个对象是否相等，支持数字和数字字符串的等价比较
 * @param {any} obj1 - 第一个值
 * @param {any} obj2 - 第二个值
 * @returns {boolean} - 如果相等返回 true
 */
function deepEqualObjects(obj1, obj2) {
  // 1. 快速检查
  if (obj1 === obj2) return true;

  // 2. 处理 null 和 undefined
  if (obj1 == null || obj2 == null) {
    return obj1 === obj2;
  }

  // 3. 处理数字和数字字符串
  if (isNumeric(obj1) && isNumeric(obj2)) {
    const num1 = Number(obj1);
    const num2 = Number(obj2);
    // 处理浮点数精度问题
    return Math.abs(num1 - num2) < 0.000001;
  }

  // 4. 处理数组
  if (Array.isArray(obj1) && Array.isArray(obj2)) {
    return deepEqualArrays(obj1, obj2);
  }

  // 5. 处理普通对象
  if (typeof obj1 === 'object' && typeof obj2 === 'object') {
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);

    if (keys1.length !== keys2.length) return false;

    // 检查所有键是否相同
    const keySet = new Set([...keys1, ...keys2]);
    if (keySet.size !== keys1.length) return false;

    // 递归比较每个属性
    for (const key of keys1) {
      if (!deepEqualObjects(obj1[key], obj2[key])) {
        return false;
      }
    }

    return true;
  }

  // 6. 其他情况使用严格相等
  return obj1 === obj2;
}

/**
 * 判断一个值是否可以安全转为数字
 * @param {any} value - 要检查的值
 * @returns {boolean} - 如果可以安全转为数字返回 true
 */
function isNumeric(value) {
  if (value === null || value === undefined || value === '') {
    return false;
  }

  // 如果是数字类型
  if (typeof value === 'number') {
    return !isNaN(value) && isFinite(value);
  }

  // 如果是字符串
  if (typeof value === 'string') {
    const trimmed = value.trim();
    if (trimmed === '') return false;

    // 检查是否为有效的数字字符串
    const num = Number(trimmed);
    return !isNaN(num) && isFinite(num);
  }

  return false;
}
