function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
/**
 * 检测商品库存是否足够
 * 
 * 只有同时满足以下条件时才会进行库存检测：
 * - is_track 开启（值为 1 或 true）
 * - over_sold 为 0（不允许超卖）
 * 
 * 对于多规格商品：
 * - 如果有 product_variant_id，则从 productData.variant 数组中查找对应规格
 * - 使用规格的 is_track, over_sold, stock_quantity 而不是主商品的
 * 
 * @param productData 商品数据（需包含 is_track, over_sold, stock_quantity 字段，多规格商品需包含 variant 数组）
 * @param product_variant_id 商品变体ID，如果存在则为多规格商品
 * @param quantity 需要添加的数量
 * @param bundle 套餐配置（子商品需包含 is_track, over_sold, stock_quantity 字段）
 * @param currentCartItems 当前购物车商品列表
 * @returns 库存检测结果
 */
export function checkProductStock(_ref) {
  var productData = _ref.productData,
    product_variant_id = _ref.product_variant_id,
    quantity = _ref.quantity,
    bundle = _ref.bundle,
    currentCartItems = _ref.currentCartItems;
  // 1. 检测主商品库存
  // 处理多规格商品：如果有product_variant_id，则从variant数组中查找对应的规格配置
  var mainProductConfig = productData;
  if (product_variant_id && productData.variant && Array.isArray(productData.variant)) {
    var variant = productData.variant.find(function (v) {
      return v.id === product_variant_id;
    });
    if (variant) {
      mainProductConfig = variant; // 使用规格的配置替换主商品配置
    }
  }

  // 只有开启库存控制且不允许超卖时才需要检测主商品库存
  var isMainProductTrackingEnabled = mainProductConfig.is_track === 1 || mainProductConfig.is_track === true;
  var isMainProductOverSoldDisabled = mainProductConfig.over_sold === 0;
  if (isMainProductTrackingEnabled && isMainProductOverSoldDisabled) {
    var existingQuantity = currentCartItems.reduce(function (total, cartItem) {
      var _cartItem$_productOri, _cartItem$_productOri2, _cartItem$_productOri3;
      // 检查是否为相同商品（比较商品ID和变体ID）
      var isSameProduct = ((_cartItem$_productOri = cartItem._productOrigin) === null || _cartItem$_productOri === void 0 ? void 0 : _cartItem$_productOri.id) === productData.id;
      var isSameVariant = !product_variant_id && !((_cartItem$_productOri2 = cartItem._productOrigin) !== null && _cartItem$_productOri2 !== void 0 && _cartItem$_productOri2.product_variant_id) || ((_cartItem$_productOri3 = cartItem._productOrigin) === null || _cartItem$_productOri3 === void 0 ? void 0 : _cartItem$_productOri3.product_variant_id) === product_variant_id;
      if (isSameProduct && isSameVariant) {
        return total + (cartItem.num || 0);
      }
      return total;
    }, 0);
    var totalQuantity = existingQuantity + quantity;
    var stockQuantity = mainProductConfig.stock_quantity;

    // 检查主商品库存是否足够
    if (stockQuantity !== undefined && stockQuantity !== null && totalQuantity > stockQuantity) {
      return {
        success: false,
        errorCode: 'not_enough_stock'
      };
    }
  }

  // 2. 检测套餐商品库存
  if (bundle && Array.isArray(bundle)) {
    // 直接遍历套餐商品数组
    var _iterator = _createForOfIteratorHelper(bundle),
      _step;
    try {
      var _loop = function _loop() {
          var bundleItem = _step.value;
          var bundleProductId = bundleItem.bundle_product_id;
          var bundleStockQuantity = bundleItem.stock_quantity;
          var bundleRequiredQuantity = (bundleItem.num || 1) * quantity; // 子商品需求数量 = 子商品配置数量 * 主商品购买数量

          // 检查套餐子商品是否需要进行库存控制
          var isBundleTrackingEnabled = bundleItem.is_track === 1 || bundleItem.is_track === true;
          var isBundleOverSoldDisabled = bundleItem.over_sold === 0;

          // 跳过没有开启库存控制或允许超卖的子商品
          if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled) return 0; // continue

          // 跳过没有库存配置的子商品
          if (bundleStockQuantity === undefined || bundleStockQuantity === null) return 0; // continue

          // 计算购物车中已有的相同子商品数量
          var existingBundleQuantity = currentCartItems.reduce(function (total, cartItem) {
            // 检查购物车中商品的套餐配置
            if (!cartItem._bundleOrigin || !Array.isArray(cartItem._bundleOrigin)) return total;
            cartItem._bundleOrigin.forEach(function (cartBundleItem) {
              if (cartBundleItem.bundle_product_id === bundleProductId) {
                total += (cartBundleItem.num || 1) * (cartItem.num || 1);
              }
            });
            return total;
          }, 0);
          var totalBundleQuantity = existingBundleQuantity + bundleRequiredQuantity;

          // 检查子商品库存是否足够
          if (totalBundleQuantity > bundleStockQuantity) {
            return {
              v: {
                success: false,
                errorCode: 'not_enough_stock'
              }
            };
          }
        },
        _ret;
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        _ret = _loop();
        if (_ret === 0) continue;
        if (_ret) return _ret.v;
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  }
  return {
    success: true
  };
}