const Store = require("electron-store");
const store = new Store({ watch: true });

// ===== 1. 核心常量定义 =====
const DEFAULT_UNIQUE_KEY = "newId"; // 订单内部唯一标识字段（保持原始前缀）
const MAX_LIMIT_RECORD_KEY = "originalIdMaxLimitRecord"; // 永久上限标记（保留你的原有逻辑）

// ===== 2. 核心内存缓存 =====
let orderCacheMap = new Map(); // key格式：前缀-数字（如AAAF...-1），value：原始订单对象

// ===== 3. 永久上限标记方法（保留你的原有核心逻辑，无改动） =====
/**
 * 获取已达永久上限的原始newId Map
 * @returns {Map<string|number, boolean>} 永久上限标识Map
 */
function getMaxLimitFlagMap() {
  const limitRecord = store.get(MAX_LIMIT_RECORD_KEY) || {};
  return new Map(Object.entries(limitRecord));
}

/**
 * 标记原始newId为永久上限（无法再添加）
 * @param {string|number} originalNewId 原始newId前缀
 */
function setPermanentMaxLimit(originalNewId) {
  if (!originalNewId) return;

  const limitMap = getMaxLimitFlagMap();
  if (!limitMap.has(originalNewId)) {
    limitMap.set(originalNewId, true);
    store.set(MAX_LIMIT_RECORD_KEY, Object.fromEntries(limitMap));
    console.log(`已标记 ${originalNewId} 为永久上限，后续无法再添加`);
  }
}

/**
 * 判断原始newId是否已达永久上限
 * @param {string|number} originalNewId 原始newId前缀
 * @returns {boolean} 是否永久上限
 */
function isOriginalIdPermanentLimit(originalNewId) {
  if (!originalNewId) return false;

  const limitMap = getMaxLimitFlagMap();
  return limitMap.has(originalNewId) && limitMap.get(originalNewId);
}

// ===== 4. 核心辅助方法（根据newId前缀查找最新订单，核心逻辑） =====
/**
 * 根据原始newId前缀，查找匹配的最新一条订单
 * @param {string|number} targetNewId 原始newId前缀
 * @returns {object|null} {cacheKey: 最新缓存key, order: 最新订单对象}，无匹配返回null
 */
function getLatestOrderByPrefixNewId(targetNewId, type) {
  if (!targetNewId || orderCacheMap.size === 0) return null;

  // 正则匹配：以targetNewId开头，后跟-数字结尾（严格匹配cacheKey格式）
  const prefixReg = new RegExp(`^${targetNewId}-(\\d+)$`);
  let matchedKeyWithSuffix = [];

  // 遍历缓存，筛选匹配前缀的订单
  orderCacheMap.forEach((order, cacheKey) => {
    const regMatch = cacheKey.match(prefixReg);
    if (regMatch) {
      const suffix = parseInt(regMatch[1], 10) || 0;
      matchedKeyWithSuffix.push({
        cacheKey: cacheKey,
        suffix: suffix,
        order: order
      });
    }
  });

  // 无匹配结果返回null
  if (matchedKeyWithSuffix.length === 0) {
    console.log(`未找到以${targetNewId}为前缀的订单`);
    return null;
  }

  // ===== 核心新增：根据type过滤，只保留满足条件的条目 =====
  if (type) {
    // 传入type时才执行过滤，提高灵活性
    matchedKeyWithSuffix = matchedKeyWithSuffix.filter(item => {
      const { order } = item;
      // 1. 容错：判断saveImgList是否存在且为数组，避免报错
      if (!order.saveImgList || !Array.isArray(order.saveImgList)) {
        return false;
      }
      // 2. 查找是否存在：title===type 且 power===false
      const matchImgItem = order.saveImgList.find(imgItem => {
        return imgItem.title === type && imgItem.power === false;
      });
      // 3. 存在则保留该条目，否则过滤掉
      return !!matchImgItem;
    });
    if (matchedKeyWithSuffix.length === 0) {
      console.log(
        `未找到以${targetNewId}为前缀、且type=${type}（power=false）的订单`
      );
      return null; // 直接返回null，终止后续逻辑，避免报错
    }
  }
  // 按后缀降序排序，取最新一条
  matchedKeyWithSuffix.sort((a, b) => b.suffix - a.suffix);
  const latestItem = matchedKeyWithSuffix[0];

  // 无匹配结果返回null
  if (matchedKeyWithSuffix.length === 0) {
    console.log(`未找到以${targetNewId}为前缀的订单`);
    return null;
  }

  console.log(
    `找到以${targetNewId}为前缀的最新订单，cacheKey：${latestItem.cacheKey}，后缀：${latestItem.suffix}`
  );
  return {
    cacheKey: latestItem.cacheKey,
    order: latestItem.order
  };
}

// ===== 5. 基础辅助方法（缓存刷新、格式转换） =====
/**
 * 刷新内存缓存（从本地存储加载数据）
 */
function refreshOrderCache() {
  const currentArray = store.get("orderInfo") || [];
  const newCacheMap = new Map();

  // 重新构建缓存key：前缀-数字，保持格式一致
  currentArray.forEach(item => {
    if (item && item[DEFAULT_UNIQUE_KEY]) {
      const itemPrefix = item[DEFAULT_UNIQUE_KEY];
      // 查找该前缀对应的所有订单，生成连续后缀
      const samePrefixItems = currentArray.filter(
        i => i[DEFAULT_UNIQUE_KEY] === itemPrefix
      );
      samePrefixItems.forEach((sameItem, index) => {
        const cacheKey = `${itemPrefix}-${index + 1}`;
        newCacheMap.set(cacheKey, sameItem);
        // console.log("cacheKey", cacheKey);
      });
    }
  });

  orderCacheMap = newCacheMap;
  console.log("缓存已从本地存储刷新完成");
}

/**
 * Map转数组（辅助批量操作）
 * @param {Map} dataMap 待转换的Map
 * @returns {Array} 转换后的数组
 */
function mapToArray(dataMap) {
  return Array.from(dataMap.values());
}

// ===== 6. 初始化缓存（模块加载时执行） =====
refreshOrderCache();

// ===== 7. 公开API（暴露给外部调用，核心逻辑+原有基础配置） =====
module.exports = {
  // === 原有基础配置方法（无改动，保留你的初始逻辑） ===
  setVersion: version => {
    store.set("desktoVersion", version);
  },
  getVersion: () => store.get("desktoVersion") || "print",

  setNowDate: version => {
    store.set("nowDate", version);
  },
  getNowDate: () => store.get("nowDate") || "",

  setSkip: value => {
    store.set("skipValue", value);
  },
  getSkipValue: () => store.get("skipValue") || 2,

  setSkipVersion: value => {
    store.set("skipVersion", value);
  },
  getSkipVersion: () => store.get("skipVersion") || "1.0",

  setApi: value => {
    store.set("hostApi", value);
  },
  getHostApi: () =>
    store.get("hostApi") || {
      apiApiHost: "https://factory.jomalls.com/api",
      fileApiUrl: "https://factory.jomalls.com/upload/factory",
      visionUrl: "https://console.jomalls.com",
      configPath: ""
    },

  setBoard: version => {
    store.set("desktoBoard", version);
  },
  getBoard: () => store.get("desktoBoard") || 3,
  setIsOver: value => {
    store.set("isOver", value);
  },
  getIsOver: () => store.get("isOver") || false,

  setLocation: (version, locationKey) => {
    if (!locationKey) return;
    store.set(locationKey, version);
  },
  getLocation: locationKey => {
    if (!locationKey) return "";
    return store.get(locationKey) || "";
  },

  setDesktopDevice: version => {
    store.set("desktopDevice", version);
  },
  getDesktopDevice: () => store.get("desktopDevice") || 1,

  // === 订单核心操作方法（最终逻辑，传入newId前缀处理最新一条） ===
  /**
   * 获取所有订单数据
   * @returns {Array} 所有订单数组
   */
  getOrderInfo: () => store.get("orderInfo") || [],

  /**
   * 获取订单内存缓存Map
   * @returns {Map} 订单缓存Map
   */
  getOrderInfoMap: () => orderCacheMap,

  /**
   * 批量设置订单（保留永久上限逻辑，不修改订单内部数据）
   * @param {Array|Map} newData 待批量添加的订单数据
   */
  setOrderInfo: newData => {
    let newObjArray = [];
    if (newData instanceof Map) {
      newObjArray = mapToArray(newData);
    } else if (Array.isArray(newData)) {
      newObjArray = newData;
    } else {
      console.warn("setOrderInfo 要求传入数组或 Map 类型，当前传入值无效");
      return;
    }

    const handledArray = [];
    newObjArray.forEach(item => {
      if (
        !item ||
        !item[DEFAULT_UNIQUE_KEY] ||
        typeof item.num !== "number" ||
        !Number.isInteger(item.num) ||
        item.num <= 0
      ) {
        console.warn("批量添加跳过无效订单：缺少newId或有效num永久上限");
        return;
      }

      const originalNewId = item[DEFAULT_UNIQUE_KEY];
      const numLimit = item.num;

      // 永久上限校验
      if (isOriginalIdPermanentLimit(originalNewId)) {
        console.warn(
          `批量添加跳过：${originalNewId} 已达到永久上限 ${numLimit}，无法再添加`
        );
        return;
      }

      // 统计当前前缀对应的订单数量
      let currentCount = 0;
      orderCacheMap.forEach((cacheItem, cacheKey) => {
        const prefixReg = new RegExp(`^${originalNewId}-(\\d+)$`);
        if (cacheKey.match(prefixReg)) {
          currentCount++;
        }
      });

      // 上限校验
      if (currentCount >= numLimit) {
        console.warn(
          `批量添加跳过：${originalNewId} 已达到永久上限 ${numLimit}`
        );
        setPermanentMaxLimit(originalNewId);
        return;
      }

      // 不修改订单内部数据，直接存入
      handledArray.push(item);
      if (currentCount + 1 === numLimit) {
        setPermanentMaxLimit(originalNewId);
      }
    });

    // 写入本地存储并刷新缓存
    store.set("orderInfo", handledArray);
    refreshOrderCache();
    console.log("批量订单已添加完成，缓存已更新");
  },

  /**
   * 单个添加订单（保留永久上限逻辑，不修改订单内部数据）
   * @param {object} newOrderObj 待添加的单个订单
   */
  addToOrderInfo: newOrderObj => {
    if (
      typeof newOrderObj !== "object" ||
      newOrderObj === null ||
      !newOrderObj[DEFAULT_UNIQUE_KEY]
    ) {
      console.warn("添加失败：请传入包含 newId 的有效订单对象");
      return;
    }

    const targetQuantity =
      newOrderObj.num || newOrderObj.customizedQuantity || 0;

    // 统一校验：必须是 正整数
    if (
      typeof targetQuantity !== "number" ||
      !Number.isInteger(targetQuantity) ||
      targetQuantity <= 0
    ) {
      console.warn(
        "添加失败：订单缺少有效数量（num 或 customizedQuantity 需为正整数）"
      );
      return;
    }

    const originalNewId = newOrderObj[DEFAULT_UNIQUE_KEY];
    const numLimit = targetQuantity;

    // 永久上限校验
    if (isOriginalIdPermanentLimit(originalNewId)) {
      console.warn(
        `添加失败：${originalNewId} 已达到永久上限 ${numLimit}，无法再添加`
      );
      return;
    }

    // 统计当前前缀对应的订单数量
    let currentCount = 0;
    orderCacheMap.forEach((cacheItem, cacheKey) => {
      const prefixReg = new RegExp(`^${originalNewId}-(\\d+)$`);
      if (cacheKey.match(prefixReg)) {
        currentCount++;
      }
    });

    // 上限校验
    if (currentCount >= numLimit) {
      console.warn(`添加失败：${originalNewId} 已达到永久上限 ${numLimit}`);
      setPermanentMaxLimit(originalNewId);
      return;
    }

    // 不修改订单内部数据，追加写入
    const originalOrderArray = store.get("orderInfo") || [];
    originalOrderArray.push(newOrderObj);
    store.set("orderInfo", originalOrderArray);
    refreshOrderCache();

    // 达到上限标记永久限制
    if (currentCount + 1 === numLimit) {
      setPermanentMaxLimit(originalNewId);
    }

    console.log(`订单 ${originalNewId} 已添加完成，缓存已更新`);
  },

  /**
   * 查询：传入newId前缀，获取匹配的最新一条订单
   * @param {string|number} targetNewId 原始newId前缀
   * @returns {object|null} 最新订单对象
   */
  getOrderInfoItem: (targetNewId, type) => {
    const latestResult = getLatestOrderByPrefixNewId(targetNewId, type);
    if (!latestResult) {
      console.log(`无匹配${targetNewId}的最新订单`);
      return null;
    }
    return latestResult.order;
  },

  /**
   * 删除：传入newId前缀，只删除「saveImgList所有power都为true」的最新一条订单（避免误伤）
   * @param {string|number} targetNewId 原始newId前缀
   * @param {string} [type] 可选，订单筛选辅助类型（保留兼容）
   */
  removeFromOrderInfo: targetNewId => {
    if (!targetNewId || orderCacheMap.size === 0) {
      console.log(`无有效参数或缓存为空，无法执行删除`);
      return;
    }

    // 步骤1：获取targetNewId前缀对应的所有匹配订单（未过滤power）
    const prefixReg = new RegExp(`^${targetNewId}-(\\d+)$`);
    let matchedKeyWithSuffix = [];

    orderCacheMap.forEach((order, cacheKey) => {
      const regMatch = cacheKey.match(prefixReg);
      if (regMatch) {
        const suffix = parseInt(regMatch[1], 10) || 0;
        matchedKeyWithSuffix.push({
          cacheKey: cacheKey, // 保留唯一cacheKey
          suffix: suffix,
          order: order
        });
      }
    });

    // 步骤2：无前缀匹配订单，直接返回
    if (matchedKeyWithSuffix.length === 0) {
      console.log(`未找到以${targetNewId}为前缀的订单`);
      return;
    }

    // 步骤3：核心筛选：保留「saveImgList中所有power都为true」的订单
    const qualifiedOrders = matchedKeyWithSuffix.filter(item => {
      const { order } = item;

      // 容错1：saveImgList不存在或非数组，视为不满足条件
      if (!order.saveImgList || !Array.isArray(order.saveImgList)) {
        return false;
      }

      // 容错2：saveImgList为空数组，视为不满足条件
      if (order.saveImgList.length === 0) {
        return false;
      }

      // 核心判断：every() 验证所有条目都满足 power === true
      return order.saveImgList.every(imgItem => {
        return !!imgItem && imgItem.power === true;
      });
    });

    // 步骤4：无满足条件的订单，返回提示
    if (qualifiedOrders.length === 0) {
      console.log(
        `未找到以${targetNewId}为前缀、且saveImgList所有power都为true的订单`
      );
      return;
    }

    // 步骤5：按后缀降序排序，取最新一条（只删这一条）
    qualifiedOrders.sort((a, b) => b.suffix - a.suffix);
    const latestQualifiedItem = qualifiedOrders[0];
    const { cacheKey: toDeleteCacheKey } = latestQualifiedItem;

    // 步骤6：【核心修复】用「唯一cacheKey」精准匹配，只删除目标订单（避免误伤）
    const originalOrderArray = store.get("orderInfo") || [];
    // 先构建「本地订单数组」与「cacheKey」的映射关系（因为本地订单没有cacheKey，需要反向匹配）
    const orderToCacheKeyMap = new Map();
    originalOrderArray.forEach(item => {
      if (item && item[DEFAULT_UNIQUE_KEY]) {
        const itemPrefix = item[DEFAULT_UNIQUE_KEY];
        const samePrefixItems = originalOrderArray.filter(
          i => i[DEFAULT_UNIQUE_KEY] === itemPrefix
        );
        samePrefixItems.forEach((sameItem, index) => {
          const itemCacheKey = `${itemPrefix}-${index + 1}`;
          // 用「订单深拷贝字符串」作为map的key，避免引用问题（精准匹配订单）
          const sameItemKey = JSON.stringify(sameItem);
          orderToCacheKeyMap.set(sameItemKey, itemCacheKey);
        });
      }
    });

    // 精准过滤：只删除「cacheKey等于toDeleteCacheKey」的订单
    const newOrderArray = originalOrderArray.filter(item => {
      const itemKey = JSON.stringify(item);
      const itemCacheKey = orderToCacheKeyMap.get(itemKey) || "";
      // 只保留「cacheKey不等于要删除的cacheKey」的订单，精准无误伤
      return itemCacheKey !== toDeleteCacheKey;
    });

    // 步骤7：调试日志，确认过滤效果（避免全删）
    console.log(`删除前订单数组长度：${originalOrderArray.length}`);
    console.log(`删除后订单数组长度：${newOrderArray.length}`);
    console.log(`要删除的目标cacheKey：${toDeleteCacheKey}`);
    if (originalOrderArray.length - newOrderArray.length > 1) {
      console.warn("警告！删除了超过1条订单，可能存在cacheKey重复问题");
      return;
    }
    if (originalOrderArray.length === newOrderArray.length) {
      console.warn("过滤失效！未删除任何订单");
      return;
    }

    // 步骤8：加固写入本地存储+刷新缓存
    store.set("orderInfo", newOrderArray);
    refreshOrderCache();

    console.log(
      `成功删除${targetNewId}对应的订单（cacheKey：${toDeleteCacheKey}，仅删除1条），缓存已更新`
    );
  },

  /**
   * 更新：传入newId前缀，更新匹配的最新一条订单
   * @param {string|number} targetNewId 原始newId前缀
   * @param {object} newOrderFields 要更新的字段对象
   */
  updateOrderInfoItem: (targetNewId, newOrderFields, type) => {
    if (typeof newOrderFields !== "object" || newOrderFields === null) {
      console.warn("修改失败：请传入有效字段对象");
      return;
    }

    const latestResult = getLatestOrderByPrefixNewId(targetNewId, type);
    console.log(targetNewId, latestResult);

    if (!latestResult) {
      console.log(`无匹配${targetNewId}的最新订单可修改`);
      return;
    }

    const { cacheKey, order } = latestResult;
    const originalOrderArray = store.get("orderInfo") || [];

    // 合并更新字段，不修改订单内部核心数据
    const newOrderArray = originalOrderArray.map(item => {
      if (JSON.stringify(item) === JSON.stringify(order)) {
        return {
          ...item,
          ...newOrderFields
        };
      }
      return item;
    });

    // 写入本地存储并刷新缓存
    store.set("orderInfo", newOrderArray);
    refreshOrderCache();

    console.log(
      `成功更新${targetNewId}对应的最新订单（cacheKey：${cacheKey}），缓存已更新`
    );
  },
  clearMaxLimitRecord: () => {
    return store.set(MAX_LIMIT_RECORD_KEY, {});
  }
};
