export const nextStepMap = {
  ylTeamLeader: {
    name: '养护组长分配',
    btnText: '分配',
    operateTypePass: 110,
    operateTypeNoPass: 210,  //养护组长退回：210
    backShow: true,
    renewShow: false
  },
  ylWorker: {
    name: '养护员待实施',
    btnText: '实施',
    operateTypePass: 120,
    operateTypeNoPass: 220,
    backShow: true,
    renewShow: false
  },
  ylTeamLeaderConfirm: {
    name: '养护组长验收',
    btnText: '验收',
    operateTypePass: 130, //养护组长验收通过: 130
    operateTypeNoPass: 230,  // 养护组长验收不通过：230
    backShow: false,
    renewShow: false
  },
  ylInspector: {
    name: '巡查员验收',
    btnText: '验收',
    operateTypePass: 140, //巡查员验收通过: 140
    operateTypeNoPass: 240,  // 巡查员验收不通过：230
    backShow: false,
    renewShow: false
  },
  ylInspectorStart: {
    name: '发起人确认',
    btnText: '结束工单',
    operateTypePass: 200, //巡查员结束工单：200
    operateTypeNoPass: 240,  // 巡查员验收不通过：230
    operateTypeRenew: 100,  //巡查员重新发起：100
    backShow: false,
    renewShow: true
  },
}


export const buzStatusMap = {
  '000' :'巡查员发起',
  "210" : '养护组长退回',
  "110" : '养护组长分配',
  "200" : '巡查员结束工单',
  "100" : '巡查员重新发起',
  "220" : '养护员退回',
  "120" : '养护员实施',
  "130" : '养护组长验收通过',
  "230" : '养护组长验收不通过',
  "140" : '巡查员验收通过',
  "240" : '巡查员验收不通过',
}


/**
 * 计算两个时间的时间差，返回格式化字符串（天/小时/分钟/秒，按需显示，无无效单位）
 * @param {string | Date | number} startTime - 开始时间（时间字符串/Date对象/10位/13位时间戳）
 * @param {string | Date | number} endTime - 结束时间（时间字符串/Date对象/10位/13位时间戳）
 * @returns {string} - 格式化时间差字符串（如：3天5小时2分钟30秒、3小时2分钟30秒、2分钟30秒、30秒）
 */
export const calculateFormatTimeDiff = (startTime, endTime) => {
  // 辅助函数：将任意合法时间格式转换为13位毫秒级时间戳
  const to13BitTimestamp = (time) => {
    let timestamp = 0;

    // 情况1：数字类型（时间戳）
    if (typeof time === 'number') {
      const timeStr = time.toString();
      if (timeStr.length === 10) {
        timestamp = time * 1000; // 10位秒级转13位毫秒级
      } else if (timeStr.length === 13) {
        timestamp = time; // 13位毫秒级直接使用
      } else {
        console.error('非法时间戳：仅支持10位/13位数字', time);
        return 0;
      }
      return timestamp;
    }

    // 情况2：Date对象
    if (time instanceof Date) {
      timestamp = time.getTime();
      if (isNaN(timestamp)) {
        console.error('无效的Date对象', time);
        return 0;
      }
      return timestamp;
    }

    // 情况3：字符串类型
    if (typeof time === 'string') {
      const timeStr = time.trim().replace(/\//g, '-'); // 统一分隔符，兼容YYYY/MM/DD
      const date = new Date(timeStr);
      timestamp = date.getTime();
      if (isNaN(timestamp)) {
        console.error('无效的时间字符串', time);
        return 0;
      }
      return timestamp;
    }

    // 非法类型
    console.error('不支持的时间类型：仅支持string/Date/number', time);
    return 0;
  };

  // 1. 统一转换为13位时间戳
  const startTimestamp = to13BitTimestamp(startTime);
  const endTimestamp = to13BitTimestamp(endTime);

  // 2. 校验时间戳有效性
  if (startTimestamp === 0 || endTimestamp === 0) {
    return '0秒';
  }

  // 3. 计算总毫秒差（取绝对值，确保时间差为正数，不影响单位计算）
  const totalMsDiff = Math.abs(endTimestamp - startTimestamp);

  // 4. 定义时间单位换算（毫秒）
  const oneDayMs = 24 * 60 * 60 * 1000;
  const oneHourMs = 60 * 60 * 1000;
  const oneMinuteMs = 60 * 1000;
  const oneSecondMs = 1000;

  // 5. 计算各单位的差值（向下取整，获取整数单位）
  const days = Math.floor(totalMsDiff / oneDayMs);
  const remainingMsAfterDay = totalMsDiff % oneDayMs; // 扣除天数后剩余的毫秒数

  const hours = Math.floor(remainingMsAfterDay / oneHourMs);
  const remainingMsAfterHour = remainingMsAfterDay % oneHourMs; // 扣除小时后剩余的毫秒数

  const minutes = Math.floor(remainingMsAfterHour / oneMinuteMs);
  const remainingMsAfterMinute = remainingMsAfterHour % oneMinuteMs; // 扣除分钟后剩余的毫秒数

  const seconds = Math.floor(remainingMsAfterMinute / oneSecondMs);

  // 6. 组装格式化字符串（按需添加单位，无无效单位）
  const timeParts = [];
  if (days > 0) {
    timeParts.push(`${days}天`);
  }
  if (hours > 0 || (days > 0 && hours === 0)) { // 有天数时，小时即使为0也可保留（可选：删除 || 后的条件则不显示0小时）
    timeParts.push(`${hours}小时`);
  }
  if (minutes > 0 || (timeParts.length > 0 && minutes === 0)) { // 有天/小时时，分钟即使为0也可保留（可选：删除 || 后的条件则不显示0分钟）
    timeParts.push(`${minutes}分钟`);
  }
  // 秒数始终保留（即使为0，保证最后有一个有效单位）
  timeParts.push(`${seconds}秒`);

  // 7. 过滤掉可能存在的「0单位」（可选优化：避免出现“0小时”等无效字段）
  const validTimeParts = timeParts.filter(part => {
    const num = parseInt(part);
    return num > 0 || (timeParts.length === 1 && num === 0); // 仅当只有秒数时，允许0秒
  });

  // 8. 拼接并返回结果
  return validTimeParts.join('');
};