/**
 * 生成一个按数字顺序的名字，如：名字1，名字2，名字3
 * @param names {string[]} 要生成的名字前缀列表
 * @param list {string[]} 已经有的名字列表
 * @param options {object}
 * @returns {string[]}
 */
export function getSequenceName(names, list, options) {
  const result = [];
  // 从数字几开始
  const start = options?.start ?? 1;

  names.forEach((name) => {
    const sequence = [];
    if (!list.length) {
      result.push(name + start);
      return;
    }
    list
      .map((i) => getDomText(i))
      .filter((i) => !!i)
      .forEach((item) => {
        if (item.startsWith(name)) {
          const index = Number(item.substring(name.length));
          if (!isNaN(index) && index >= start) {
            sequence.push(index);
          }
        }
      });
    sequence.sort((a, b) => a - b);
    if (!sequence.includes(start)) {
      result.push(`${name}${start}`);
      return;
    }
    for (let i = 0; i < sequence.length; i += 1) {
      if (!sequence[i + 1] || sequence[i] + 1 !== sequence[i + 1]) {
        result.push(`${name}${sequence[i] + 1}`);
        break;
      }
    }
  });

  return result;
}

/**
 * 获取富文本中的文字
 * @param dom {string} 富文本
 * @returns {string}
 */
export function getDomText(dom) {
  const div = document.createElement('div');
  div.innerHTML = dom;
  return div.textContent;
}

/**
 * 判断富文本是否与列表中的富文本重复。重复则返回 true，不同则返回 false
 * @param list {string[]} 待判断的富文本列表
 * @param comparedList {string[]} 用于比较的富文本列表
 * @param options {object}
 * @returns {boolean[]}
 */
export function isRichRepeat(list, comparedList, options) {
  // 不比较图片。只要存在图片，则认为两段富文本不同
  const imageAsDifference = options?.imageAsDifference !== false;

  return list.map((rich) => {
    return comparedList.some((compared) => {
      if (imageAsDifference) {
        if (rich.includes('<img') || compared.includes('<img')) {
          return false;
        }
      }

      return getDomText(rich) === getDomText(compared);
    });
  });
}

/**
 * 判断富文本是否为空。
 * @param list {string[]} 待判断的富文本列表
 * @param options {object}
 * @returns {boolean[]}
 */
export function isRichEmpty(list, options) {
  // 不判断图片。只要存在图片，则认为两段富文本不为空
  const imageAsEmpty = options?.imageAsEmpty === true;

  return list.map((rich) => {
    if (!imageAsEmpty) {
      if (rich.includes('<img')) {
        return false;
      }
    }

    return !getDomText(rich);
  });
}

/**
 * 使数组 options 里的内容按随机的方式，重新排序。不改变原数组，返回新的排好序的数组。
 * @param options
 * @param isRandom
 */
export function randomOptions(options, isRandom = true) {
  if (!isRandom) {
    return options;
  }
  return [...(options || [])].sort(() => Math.random() - 0.5);
}

/**
 * 根据 field 字段，判断两个对象数组是否相同
 * @param arr1
 * @param arr2
 * @param field
 */
export function compareArrayByField(arr1, arr2, field) {
  const arr1Fields = Array.from(new Set(arr1.map((i) => i[field])));
  const arr2Fields = Array.from(new Set(arr2.map((i) => i[field])));

  if (arr1Fields.length !== arr2Fields.length) {
    return false;
  }

  return arr1Fields.every((i) => arr2Fields.includes(i));
}

/**
 * 获取题目索引
 * @param questions {question.list}
 * @param question {questionsList}
 * @return {number}
 */
export function getQuestionIndex(questions, question) {
  if (!question) {
    return -1;
  }
  const result = questions.indexOf(question);
  // console.log(`get question index`, result);
  return result;
}

/**
 * 防抖函数
 * @param fn {Function} 需要防抖的函数
 * @param wait {number} 防抖时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(fn, wait) {
  let timer = null;
  return function () {
    const context = this;
    const args = arguments;
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(context, args), wait);
  };
}

/**
 * 节流函数
 * @param fn {Function} 需要节流的函数
 * @param wait {number} 节流时间
 * @returns {Function} 节流后的函数
 */
export function throttle(fn, wait) {
  let lastTime = 0;
  return function() {
    const context = this;
    const args = arguments;
    const now = Date.now();
    if (now - lastTime >= wait) {
      console.log(`throttle`, now - lastTime);
      
      fn.apply(context, args);
      lastTime = now;
    }
  };
}

/**
 * 格式化时间
 * @param type now：当前时间  endOfDay：当前时间的 23:59:59
 * @returns {string}
 */
export function getFormattedTime(type = 'now') {
  const date = new Date();

  if (type === 'endOfDay') {
    date.setHours(23, 59, 59, 999); // 设置为当天的 23:59:59.999
  }

  // 格式化时间为 yyyy-MM-dd hh:mm:ss
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从 0 开始，需要 +1
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  const seconds = String(date.getSeconds()).padStart(2, '0');

  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}
