function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
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; }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
import { locales } from '@pisell/utils';
import Decimal from "decimal.js";

/**
 * 格式化 SKU 数据源，适配 SkuCard 组件
 */
export var formatSkuDataSource = function formatSkuDataSource(dataSource) {
  var _price = dataSource.price,
    _original_price = dataSource.original_price,
    is_bundle = dataSource.is_bundle,
    minimum_markup_price = dataSource.minimum_markup_price;
  var price = _price;
  var original_price = _original_price;
  if (is_bundle) {
    price = new Decimal(price || 0).plus(new Decimal(minimum_markup_price || 0)).toFixed(2);
    original_price = new Decimal(original_price || 0).plus(new Decimal(minimum_markup_price || 0)).toFixed(2);
  }
  return {
    id: dataSource.id,
    title: dataSource.title,
    subtitle: dataSource.subtitle,
    cover: dataSource.cover,
    price: price,
    original_price: original_price,
    stock: dataSource.stock_quantity,
    sortKeys: ['title', 'subtitle', 'price'],
    isMini: is_bundle
  };
};

/**
 * Tab 项接口定义（与 List 组件保持一致）
 */

/**
 * 产品分类信息接口
 */

/**
 * 产品项接口
 */

/**
 * 分类树节点接口（Switch 模式返回值）
 */

/**
 * 生成简单的 Tab 列表（非树形结构）
 * 遍历商品直接关联的分类，扁平化输出为 CategoryTreeNode[]
 * 
 * @param products 产品列表
 * @returns CategoryTreeNode[] 扁平化的分类列表，children 为空数组
 */
var generateSimpleTabItems = function generateSimpleTabItems(products) {
  // 收集所有分类及其对应的商品 ID
  var categoryMap = new Map();
  var categoryProductMap = new Map();
  products.forEach(function (product) {
    if (product.category && Array.isArray(product.category)) {
      product.category.forEach(function (cat) {
        // 收集分类信息
        if (!categoryMap.has(cat.id)) {
          categoryMap.set(cat.id, {
            id: cat.id,
            name: cat.name,
            icon: cat.icon,
            slug: cat.slug,
            sort: cat.sort
          });
        }

        // 收集分类对应的商品 ID
        if (!categoryProductMap.has(cat.id)) {
          categoryProductMap.set(cat.id, new Set());
        }
        categoryProductMap.get(cat.id).add(product.id);
      });
    }
  });

  // 构建 CategoryTreeNode 列表
  var result = [];
  categoryMap.forEach(function (category, id) {
    var productIds = Array.from(categoryProductMap.get(id) || []);
    result.push({
      id: id,
      key: id,
      group: id,
      label: category.name,
      name: category.name,
      icon: category.icon,
      productIds: productIds,
      children: [],
      childrenMaxLevel: 0
    });
  });

  // 按 sort 字段排序（降序）
  result.sort(function (a, b) {
    var catA = categoryMap.get(a.id);
    var catB = categoryMap.get(b.id);
    return ((catB === null || catB === void 0 ? void 0 : catB.sort) || 0) - ((catA === null || catA === void 0 ? void 0 : catA.sort) || 0);
  });
  return result;
};

/**
 * 根据产品数据生成分类 Tabs（Switch 模式）
 * 参考 TestResponsiveWrapper 的 generateSimpleTabItems 函数
 * 
 * @param products 产品列表
 * @param tabStyle tab 样式类型
 * @returns Switch 模式返回 CategoryTreeNode[]，Anchor 模式返回 TabItem[]
 */
export var generateProductTabs = function generateProductTabs(products) {
  var tabStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'switch';
  var isTreeTab = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  if (!products || products.length === 0) {
    if (tabStyle === 'switch') {
      return [];
    }
    return [{
      key: 'all',
      label: locales.getText('pisell2.ticket-booking.all')
    }];
  }
  if (tabStyle === 'switch') {
    // 切换模式：构建多级分类树形结构
    return isTreeTab ? buildCategoryTree(products) : generateSimpleTabItems(products);
  } else {
    // 锚点模式：基于实际数据统计数量
    var categoryCount = products.reduce(function (acc, product) {
      if (product.category && Array.isArray(product.category)) {
        product.category.forEach(function (cat) {
          var key = String(cat.id);
          if (!acc[key]) {
            acc[key] = {
              count: 0,
              category: cat
            };
          }
          acc[key].count += 1;
        });
      }
      return acc;
    }, {});

    // 生成 tabs
    var tabs = [{
      key: 'all',
      label: "".concat(locales.getText('pisell2.ticket-booking.all'), " (").concat(products.length, ")")
    }];

    // 按 sort 排序
    var sortedEntries = Object.entries(categoryCount).sort(function (_ref, _ref2) {
      var _ref3 = _slicedToArray(_ref, 2),
        a = _ref3[1];
      var _ref4 = _slicedToArray(_ref2, 2),
        b = _ref4[1];
      return (b.category.sort || 0) - (a.category.sort || 0);
    });
    sortedEntries.forEach(function (_ref5) {
      var _ref6 = _slicedToArray(_ref5, 2),
        key = _ref6[0],
        _ref6$ = _ref6[1],
        count = _ref6$.count,
        category = _ref6$.category;
      tabs.push({
        key: key,
        label: "".concat(category.name, " (").concat(count, ")"),
        group: key
      });
    });
    return tabs;
  }
};

/**
 * 递归收集分类及其所有父级分类
 * 通过 parent_category 字段向上追溯，确保所有层级的分类都被收集
 * 
 * @param category 当前分类（带 parent_category 字段）
 * @param categoryMap 分类信息 Map
 */
var collectCategoryWithParents = function collectCategoryWithParents(category, categoryMap) {
  // 收集当前分类
  if (!categoryMap.has(category.id)) {
    var _ref7, _category$parent_id, _category$parent_cate;
    categoryMap.set(category.id, {
      id: category.id,
      name: category.name,
      icon: category.icon,
      slug: category.slug,
      sort: category.sort,
      parent_id: (_ref7 = (_category$parent_id = category.parent_id) !== null && _category$parent_id !== void 0 ? _category$parent_id : (_category$parent_cate = category.parent_category) === null || _category$parent_cate === void 0 ? void 0 : _category$parent_cate.id) !== null && _ref7 !== void 0 ? _ref7 : null
    });
  }

  // 递归收集父级分类
  if (category.parent_category) {
    collectCategoryWithParents(category.parent_category, categoryMap);
  }
};

/**
 * 构建分类树形结构（Switch 模式专用）
 * 
 * @param products 产品列表
 * @returns CategoryTreeNode[] 树形分类结构
 */
var buildCategoryTree = function buildCategoryTree(products) {
  // 1. 收集所有分类及其对应的商品 ID
  // 使用 category 字段，通过 parent_category 链递归收集所有层级的分类
  var categoryMap = new Map();
  var categoryProductMap = new Map();
  products.forEach(function (product) {
    if (product.category && Array.isArray(product.category)) {
      product.category.forEach(function (cat) {
        // 递归收集当前分类及其所有父级分类
        collectCategoryWithParents(cat, categoryMap);

        // 收集分类对应的商品 ID（只记录商品直接关联的分类）
        if (!categoryProductMap.has(cat.id)) {
          categoryProductMap.set(cat.id, new Set());
        }
        categoryProductMap.get(cat.id).add(product.id);
      });
    }
  });

  // 2. 构建父子关系映射
  var childrenMap = new Map();
  var rootCategories = [];
  categoryMap.forEach(function (category, id) {
    var parentId = category.parent_id;
    // parent_id 为 0、null 或 undefined 表示一级分类
    if (!parentId || parentId === 0) {
      rootCategories.push(id);
    } else {
      if (!childrenMap.has(parentId)) {
        childrenMap.set(parentId, []);
      }
      childrenMap.get(parentId).push(id);
    }
  });

  // 3. 按 sort 字段排序
  var sortBySort = function sortBySort(ids) {
    return ids.sort(function (a, b) {
      var catA = categoryMap.get(a);
      var catB = categoryMap.get(b);
      return ((catB === null || catB === void 0 ? void 0 : catB.sort) || 0) - ((catA === null || catA === void 0 ? void 0 : catA.sort) || 0);
    });
  };

  /**
   * 递归构建分类节点
   * 
   * @param categoryId 分类 ID
   * @param parentPath 父级路径（用于生成 pid）
   * @returns CategoryTreeNode 分类节点
   */
  var buildNode = function buildNode(categoryId, parentPath) {
    var category = categoryMap.get(categoryId);
    var childIds = childrenMap.get(categoryId) || [];
    var sortedChildIds = sortBySort(_toConsumableArray(childIds));

    // 当前分类直接关联的商品 ID
    var directProductIds = Array.from(categoryProductMap.get(categoryId) || []);

    // 计算当前节点的 pid
    var currentPath = parentPath ? "".concat(parentPath, "_").concat(categoryId) : String(categoryId);
    var pid = parentPath || undefined;

    // 基础节点
    var node = {
      id: categoryId,
      key: categoryId,
      group: categoryId,
      label: category.name,
      name: category.name,
      icon: category.icon,
      productIds: directProductIds,
      childrenMaxLevel: 0 // 默认无子分类时为 0
    };

    // 添加 pid（一级分类没有 pid）
    if (pid) {
      node.pid = pid;
    }

    // 如果有子分类，递归构建
    if (sortedChildIds.length > 0) {
      var childNodes = sortedChildIds.map(function (childId) {
        return buildNode(childId, currentPath);
      });

      // 递归汇总所有子分类的商品 ID
      var allChildProductIds = childNodes.reduce(function (acc, child) {
        return acc.concat(child.productIds);
      }, []);

      // 合并当前分类和所有子分类的商品 ID（去重）
      var mergedProductIds = Array.from(new Set([].concat(directProductIds, _toConsumableArray(allChildProductIds))));
      node.productIds = mergedProductIds;
      node.children = _toConsumableArray(childNodes);

      // 计算 childrenMaxLevel：取所有子节点中最大的 childrenMaxLevel + 1
      var maxChildLevel = 0;
      for (var i = 0; i < childNodes.length; i++) {
        if (childNodes[i].childrenMaxLevel > maxChildLevel) {
          maxChildLevel = childNodes[i].childrenMaxLevel;
        }
      }
      node.childrenMaxLevel = maxChildLevel + 1;
    }
    return node;
  };

  // 4. 从根分类开始构建树
  var sortedRootIds = sortBySort([].concat(rootCategories));
  var rootNodes = sortedRootIds.map(function (rootId) {
    return buildNode(rootId, '');
  });

  // 5. 如果有根分类，在根级别追加 All 节点
  if (rootNodes.length > 0) {
    // 汇总所有根分类的商品 ID
    var allProductIds = Array.from(new Set(rootNodes.flatMap(function (node) {
      return node.productIds;
    })));
    return _toConsumableArray(rootNodes);
  }
  return rootNodes;
};

/**
 * 按 tabData 分类顺序对商品列表排序，同分类内按商品 sort 降序
 * 仅在 isTreeTab 为 false 时使用
 *
 * @param data 商品列表（category 已转为 string[] 格式）
 * @param tabData 分类 tab 列表（CategoryTreeNode[]）
 * @returns 排序后的商品列表（原地排序）
 */
export var sortProductsByTabOrder = function sortProductsByTabOrder(data, tabData) {
  var categoryOrderMap = new Map();
  tabData.forEach(function (tab, index) {
    categoryOrderMap.set(String(tab.id), index);
  });
  return data.sort(function (a, b) {
    var _a$category, _b$category, _categoryOrderMap$get, _categoryOrderMap$get2;
    var aIndex = Math.max(Array.isArray(a.category) ? a.category.length - 1 : 0, 0);
    var bIndex = Math.max(Array.isArray(b.category) ? b.category.length - 1 : 0, 0);
    var aCategoryId = (_a$category = a.category) === null || _a$category === void 0 ? void 0 : _a$category[aIndex];
    var bCategoryId = (_b$category = b.category) === null || _b$category === void 0 ? void 0 : _b$category[bIndex];

    // 按 tabData 分类顺序排序（无分类的排到最后）
    var aOrder = aCategoryId !== undefined ? (_categoryOrderMap$get = categoryOrderMap.get(String(aCategoryId))) !== null && _categoryOrderMap$get !== void 0 ? _categoryOrderMap$get : Infinity : Infinity;
    var bOrder = bCategoryId !== undefined ? (_categoryOrderMap$get2 = categoryOrderMap.get(String(bCategoryId))) !== null && _categoryOrderMap$get2 !== void 0 ? _categoryOrderMap$get2 : Infinity : Infinity;
    if (aOrder !== bOrder) {
      return aOrder - bOrder;
    }

    // 同分类内按商品 sort 降序（越大越前）
    return (b.sort || 0) - (a.sort || 0);
  });
};