/* 
 * @Author: ddmt
 * @Date: 2024-9-29 20:50:12
 * @LastEditTime: 2025-2-18 00:55:00
 * @LastEditors: ddmt
 * @Description: ddmt-index file
 * @FilePath: /Tool/number.js
 */

/**
 * 生成从minNum到maxNum的随机数
 * @param {number} minNum - 最小值
 * @param {number} [maxNum] - 最大值
 * @returns {number} - 生成的随机数
 */
export function randomNum (minNum, maxNum) {
  switch (arguments.length) {
    case 1:
      return parseInt(Math.random() * minNum + 1, 10);
    case 2:
      return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10);
    default:
      return 0;
  }
}


/**
 * 数组循环函数
 * @param {Array} arr - 数组
 * @param {number} index - 索引
 * @returns {Array} - 循环后的数组
 */
export function nextArray (arr, index) {
  index--;
  return arr.slice(index + 1, arr.length).concat(arr.slice(0, index + 1));
}

/**
 * 数组去重函数
 * @param {Array} arr - 数组
 * @returns {Array} - 去重后的数组
 */
export function ArrayDeHeavy (arr) {
  let newArr = new Set();
  arr.forEach(item => {
    newArr.add(item);
  });
  return Array.from(newArr);
}


/**
 * 获取相对时间(中文)
 * @param {Date} date - 日期对象
 * @returns {string} - 相对时间字符串
 */
export function getRelativeTime (date) {
  const now = new Date();
  const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000);

  if (diffInSeconds < 60) {
    return '刚刚';
  }

  const diffInMinutes = Math.floor(diffInSeconds / 60);
  if (diffInMinutes < 60) {
    return `${diffInMinutes}分钟前`;
  }

  const diffInHours = Math.floor(diffInMinutes / 60);
  if (diffInHours < 24) {
    return `${diffInHours}小时前`;
  }

  const diffInDays = Math.floor(diffInHours / 24);
  if (diffInDays < 30) {
    return `${diffInDays}天前`;
  }

  const diffInMonths = Math.floor(diffInDays / 30);
  if (diffInMonths < 12) {
    return `${diffInMonths}个月前`;
  }

  const diffInYears = Math.floor(diffInMonths / 12);
  if (diffInYears < 5) {
    return `${diffInYears}年前`;
  }

  return '很久以前';
}

/**
 * 解析nginx日志(单行)
 * @param {string} log - 日志字符串
 * @returns {Object|null} - 解析后的日志对象或null
 */
export function parseNginxLog (log) {
  const logPattern = /^(\S+) - - \[([^\]]+)\] "(\S+) (\S+) HTTP\/\d\.\d" (\d+) (\d+) "([^"]*)" "([^"]*)"/;

  try {
    const match = log.match(logPattern);
    if (match) {
      return {
        ip: match[1],
        timestamp: match[2],
        method: match[3],
        url: match[4],
        status: parseInt(match[5]),
        responseSize: parseInt(match[6]),
        referrer: match[7],
        userAgent: match[8],
      };
    }
  } catch (error) {
    return error;
  }
  return null;
}

/**
 * cookies 解析函数
 * @param {string} cookies - cookies字符串
 * @returns {Object} - 解析后的cookies对象
 */
export function toCookiesArray(cookies) {
  if (!cookies || cookies.length === 0) return;

  // 解析旧的 cookies
  const cookieMap = {};
  cookies.split("; ").forEach(cookie => {
      const [key, value] = cookie.split("=");
      if (key) cookieMap[key] = value;
  });

  return cookieMap;
}


/**
 * cookies 更新函数
 * @param {string} cookies - 原始cookies字符串
 * @param {Array} setCookieArray - 新的 Set-Cookie 数组
 * @returns {string} - 更新后的cookies字符串
 */
export function updateCookies(cookies, setCookieArray) {
  if (!setCookieArray || setCookieArray.length === 0) return;

  // 解析旧的 cookies
  const cookieMap = toCookiesArray(cookies);

  // 解析新的 Set-Cookie 数组并更新
  setCookieArray.forEach(cookieStr => {
      const cookiePair = cookieStr.split(";")[0]; // 只取 key=value
      const [key, value] = cookiePair.split("=");
      if (key) cookieMap[key] = value;
  });

  // 重新拼接成字符串存回全局 cookies
  return Object.entries(cookieMap).map(([key, value]) => `${key}=${value}`).join("; ");
}


/**
 * object 转 json
 * @param {string} ObjectText - 对象字符串
 * @returns {string|undefined} - 标准 JSON 字符串或undefined
 */
export function objectToJSON(ObjectText) {
  try {
    // 修复键没有双引号的问题
    let fixedString = ObjectText.replace(/(\w+):/g, '"$1":');
  
    // 修复单引号字符串值的问题
    fixedString = fixedString.replace(/'/g, '"');
  
    // 修复尾随逗号的问题
    fixedString = fixedString.replace(/,\s*([}\]])/g, '$1');
  
    // 解析为对象
    const outputObj = JSON.parse(fixedString);
  
    // 转换为标准 JSON 字符串
    return JSON.stringify(outputObj);
  } catch (error) {
    console.error("解析失败：", error);
  }
}

/**
 * 根据字段映射表重新命名对象的属性
 * renameObjectKeys
 * @param {Array} filteredRows - 过滤后的行数据数组，每个元素是一个对象
 * @param {Object} fieldMapping - 字段映射表，键是原始字段名，值是新的字段名
 * @returns {Array} - 返回一个新的数组，其中对象的属性根据字段映射表进行了重命名
 */
export function renameObjectKeys(filteredRows, fieldMapping) {
  return filteredRows.map(row => {
    return Object.keys(row).reduce((acc, key) => {
      // 如果字段在映射表中，则使用映射的字段名
      if (fieldMapping[key]) {
        const newKey = fieldMapping[key];
        acc[newKey] = row[key];
      }
      // 如果字段不在映射表中，则直接跳过（不加入新对象）
      return acc;
    }, {});
  });
}