'use strict';

// 模块化库存监控 —— MKH-BOM 资料
//
// 页面结构（与业务确认的模板）：MKH商品编码 | 配件明细 | 数量 | 配件仓位
//
// ── 数据口径 ──────────────────────────────────────────────────────
//
// ① MKH 商品编码（列表主数据）—— 业务库 JSReportReplica（MSSQL / schema=rpt）
//    rpt.jst_sku WHERE sku_id LIKE N'MKH%' AND item_type = N'成品'
//      AND other_3 = N'简尚-崔桥工厂品牌仓'
//      AND 该编码存在正式 BOM 配件明细          （当前 4223 条）
//    · 商品档案里的 item_type/labels 不能单独作为成品依据：上游也会把部分配件
//      标成“成品/模块化成品”。只有 jst_skuBomItem 的父项才进入本页面。
//    · 形态 MKH + 款号 + 序列，例 MKHDNZ0409260600198
//
// ② 配件明细（BOM）—— 聚水潭商品 BOM（主来源）
//    rpt.jst_skuBomInfo / rpt.jst_skuBomItem
//    · jst_skuBomInfo.sku_id = MKH 成品编码
//    · jst_skuBomItem.map_outer_sku_id = 配件编码，rm_qty = 配件数量
//    · 两表当前分别约 4,257 / 49,012 行；远端副本暂未提供 sku_id 索引，
//      因此只读取必要列并在进程内短时缓存，避免分页和下钻重复扫描。
//
// ③ 业务中台组合商品表（降级来源）
//    JSDataMiddlePlatform.dbo.jst_comboProductItem
//    · combine_sku_id = MKH 成品编码，src_sku_id = 配件编码，qty = 配件数量
//    · 当前实测 1,406 个 MKH 成品、3,022 条配件关系、159 个不同配件编码
//
// ④ 产品资料系统数据库（PostgreSQL / furniture3d_prod）作为补充来源
//    public."IntakeNonIntegratedProduct".payload -> 'skuItems' -> 'componentDetails'
//    · 每一项形如 { code, name, role/assetType, barcode, quantity }
//    · 例：MKH-DNZ0384 → [{ barcode: DNZ038501N1437V01, quantity: 1, role: 板材 },
//                         { barcode: DNZ038401N1440V01, quantity: 1, role: 组件 }]
//    · 匹配：编码去横线/空格转大写后比对；精确 SKU 匹配不到时退化到 SPU 前缀匹配
//      （业务库 MKHDNZ0384260600002 ↔ 资料库 MKH-DNZ0384260600001）
//    · BOM 只用于补充指定仓库商品的配件明细，不能把无 jst_sku 仓库档案的编码追加为商品。
//
//    ⚠️ 该库另有 external.product_bom_v1 标准视图，但它依赖 Product / ProductSKU /
//       Panel 三张整合表，这三张表当前均为 0 行，因此视图恒为空、不要用。
//       payload 里的 bomDetails / factoryRows / pricingRows 属成本与工厂行，结构不同
//       （无 SKU 条码），也不能直接当配件 BOM。
//
// ⑤ 配件仓位 —— 业务库 rpt.jst_packInventoryInfo；
//    sku_id 可能带“-包装序号”后缀，需按基础配件编码匹配。优先显示 bin_group / bin，
//    仓位为空时显示净数量大于 0 的 pack_id（箱号）与 wh_id（仓库）。
//    该列只使用箱及仓位库存表，不用库存仓库或商品档案仓库冒充仓位。
//
// ⑥ 配件库存 —— 业务库 rpt.jst_inventoryInfo 按 sku_id 汇总。

const cloudDatabase = require('../config/cloudDatabase');
const productDb = require('../config/productInformationDatabase');

const DEFAULT_PAGE_SIZE = 50;
const MAX_PAGE_SIZE = 200;
const BOM_CACHE_TTL_MS = 2 * 60 * 1000;
const OFFICIAL_BOM_DETAIL_CACHE_TTL_MS = 15 * 60 * 1000;
const COMPONENT_LOCATION_CACHE_TTL_MS = 2 * 60 * 1000;

let businessBomCache = null;
let officialBomIndexCache = null;
const officialBomDetailCache = new Map();
const componentLocationCache = new Map();
let productBomCache = null;

// MKH 模块化成品必须同时是指定仓库商品档案和正式 BOM 父项。
// 上游存在被 item_type/labels 误标为成品的配件，不能仅依赖商品档案标签。
const DESIGNATED_WAREHOUSE = '简尚-崔桥工厂品牌仓';
const MKH_WHERE = `s.sku_id LIKE N'MKH%'
  AND s.item_type = N'成品'
  AND s.other_3 = N'${DESIGNATED_WAREHOUSE}'
  AND EXISTS (
    SELECT 1
    FROM rpt.jst_skuBomItem parent_bom WITH (NOLOCK)
    WHERE parent_bom.sku_id = s.sku_id
      AND NULLIF(LTRIM(RTRIM(parent_bom.map_outer_sku_id)), N'') IS NOT NULL
  )`;

const toText = (value) => {
  if (value === null || value === undefined) return null;
  const text = String(value).trim();
  return text === '' ? null : text;
};

const toNumber = (value) => {
  if (value === null || value === undefined || value === '') return null;
  const parsed = Number(value);
  return Number.isFinite(parsed) ? parsed : null;
};

// 编码归一化：去横线/空格 + 大写，用于跨库匹配
const normalizeCode = (value) => {
  const text = toText(value);
  return text ? text.toUpperCase().replace(/[-\s]/g, '') : null;
};

const buildFilters = (query = {}) => {
  const conditions = [];
  const params = {};

  const keyword = toText(query.keyword);
  if (keyword) {
    params.keyword = `%${keyword}%`;
    conditions.push('(s.sku_id LIKE @keyword OR s.name LIKE @keyword)');
  }

  return { conditions, params };
};

/**
 * 把 componentDetails 原始 JSON 解析成统一结构。
 */
function parseComponents(raw) {
  if (!Array.isArray(raw)) return [];
  return raw
    .map((item) => {
      if (!item || typeof item !== 'object') return null;
      const barcode = toText(item.barcode);
      const code = toText(item.code);
      const name = toText(item.name) || barcode || code;
      return {
        barcode: barcode || code,
        code,
        name,
        role: toText(item.role) || toText(item.assetType),
        qty: toNumber(item.quantity) ?? 1,
      };
    })
    .filter(Boolean);
}

/**
 * 将业务中台组合商品明细整理成按 MKH 成品编码查找的 BOM。
 * 同一成品、同一配件出现多行时合并数量，避免下钻重复展示。
 */
function groupBusinessBomRows(rows = []) {
  const grouped = new Map();

  rows.forEach((row) => {
    const skuCode = toText(row.comboSkuId);
    const skuKey = normalizeCode(skuCode);
    const componentCode = toText(row.componentSkuId);
    const componentKey = normalizeCode(componentCode);
    if (!skuCode || !skuKey || !componentCode || !componentKey) return;

    if (!grouped.has(skuKey)) {
      grouped.set(skuKey, {
        skuCode,
        components: new Map(),
      });
    }

    const entry = grouped.get(skuKey);
    const previous = entry.components.get(componentKey);
    const qty = toNumber(row.qty) ?? 1;
    if (previous) {
      previous.qty += qty;
      if (!previous.name) previous.name = toText(row.componentName) || componentCode;
      return;
    }

    entry.components.set(componentKey, {
      barcode: componentCode,
      code: componentCode,
      name: toText(row.componentName) || componentCode,
      role: null,
      qty,
    });
  });

  const bySku = new Map();
  const entries = [];
  grouped.forEach((entry, skuKey) => {
    const components = Array.from(entry.components.values());
    bySku.set(skuKey, components);
    entries.push({
      skuCode: entry.skuCode,
      spu: null,
      productName: entry.skuCode,
      components,
    });
  });

  return { bySku, bySpuPrefix: [], entries };
}

/**
 * 将聚水潭正式商品 BOM 明细整理成按成品编码查找的结构。
 * 同一 BOM 中重复的配件编码会合并数量；外部配件编码为空时忽略该行，
 * 避免把聚水潭内部数字 ID 当成可展示、可查库存的配件编码。
 */
function groupOfficialBomRows(rows = []) {
  const grouped = new Map();

  rows.forEach((row) => {
    const skuCode = toText(row.skuId);
    const skuKey = normalizeCode(skuCode);
    const componentCode = toText(row.componentSkuId);
    const componentKey = normalizeCode(componentCode);
    if (!skuCode || !skuKey || !componentCode || !componentKey) return;

    if (!grouped.has(skuKey)) {
      grouped.set(skuKey, {
        skuCode,
        components: new Map(),
      });
    }

    const entry = grouped.get(skuKey);
    const previous = entry.components.get(componentKey);
    const qty = toNumber(row.qty) ?? 1;
    if (previous) {
      previous.qty += qty;
      if (!previous.name) previous.name = toText(row.componentName) || componentCode;
      return;
    }

    entry.components.set(componentKey, {
      barcode: componentCode,
      code: componentCode,
      name: toText(row.componentName) || componentCode,
      role: null,
      qty,
    });
  });

  const bySku = new Map();
  const entries = [];
  grouped.forEach((entry, skuKey) => {
    const components = Array.from(entry.components.values());
    bySku.set(skuKey, components);
    entries.push({
      skuCode: entry.skuCode,
      spu: null,
      productName: entry.skuCode,
      components,
    });
  });

  return { bySku, bySpuPrefix: [], entries };
}

/**
 * 读取聚水潭正式 BOM 主表中的成品编码索引。
 * 主表只有约四千行，只传输 sku_id；用于全局统计与来源优先级判断。
 */
async function loadOfficialBomIndex() {
  const now = Date.now();
  if (officialBomIndexCache?.value && officialBomIndexCache.expiresAt > now) {
    return officialBomIndexCache.value;
  }
  if (officialBomIndexCache?.pending) return officialBomIndexCache.pending;

  const pending = cloudDatabase.query(
    `SELECT h.sku_id AS skuId
     FROM rpt.jst_skuBomInfo h WITH (NOLOCK)
     WHERE h.sku_id LIKE N'MKH%'`,
    {},
    { requestTimeout: 180000 }
  ).then((rows) => {
    const bySku = new Map();
    rows.forEach((row) => {
      const key = normalizeCode(row.skuId);
      if (key) bySku.set(key, []);
    });
    return { bySku, bySpuPrefix: [], entries: [] };
  });

  officialBomIndexCache = { pending, value: null, expiresAt: 0 };
  try {
    const value = await pending;
    officialBomIndexCache = { pending: null, value, expiresAt: Date.now() + BOM_CACHE_TTL_MS };
    return value;
  } catch (error) {
    officialBomIndexCache = null;
    throw error;
  }
}

/**
 * 按当前页面或单品所需 SKU 批量读取正式 BOM 明细。
 * 单次最多接收 MAX_PAGE_SIZE 个 SKU，并缓存每个 SKU 的结果（包括空结果），
 * 避免把远端约 4.9 万条明细在每次缓存刷新时全部传回应用服务器。
 */
async function loadOfficialBomForSkus(skuIds = []) {
  const requested = Array.from(new Map(
    skuIds
      .map((skuId) => [normalizeCode(skuId), toText(skuId)])
      .filter(([key, value]) => key && value)
  ).entries()).slice(0, MAX_PAGE_SIZE);
  const now = Date.now();
  const missing = requested.filter(([key]) => {
    const cached = officialBomDetailCache.get(key);
    return !cached || cached.expiresAt <= now;
  });

  if (missing.length > 0) {
    const params = {};
    const placeholders = missing.map(([, skuId], index) => {
      params[`officialSku${index}`] = skuId;
      return `@officialSku${index}`;
    });
    const rows = await cloudDatabase.query(
      `SELECT
         i.sku_id           AS skuId,
         i.map_outer_sku_id AS componentSkuId,
         i.map_name         AS componentName,
         i.rm_qty           AS qty
       FROM rpt.jst_skuBomItem i WITH (NOLOCK)
       WHERE i.sku_id IN (${placeholders.join(', ')})
         AND NULLIF(LTRIM(RTRIM(i.map_outer_sku_id)), N'') IS NOT NULL
         AND EXISTS (
           SELECT 1
           FROM rpt.jst_skuBomInfo h WITH (NOLOCK)
           WHERE h.sku_id = i.sku_id
         )`,
      params,
      { requestTimeout: 180000 }
    );
    const grouped = groupOfficialBomRows(rows);
    const expiresAt = Date.now() + OFFICIAL_BOM_DETAIL_CACHE_TTL_MS;
    missing.forEach(([key]) => {
      officialBomDetailCache.set(key, {
        components: grouped.bySku.get(key) || [],
        expiresAt,
      });
    });
  }

  const bySku = new Map();
  requested.forEach(([key]) => {
    const cached = officialBomDetailCache.get(key);
    if (cached?.components?.length) bySku.set(key, cached.components);
  });
  return { bySku, bySpuPrefix: [], entries: [] };
}

/**
 * 从业务中台读取 MKH 组合商品 BOM，作为正式商品 BOM 缺失时的降级来源。
 */
async function loadBusinessBom() {
  const now = Date.now();
  if (businessBomCache?.value && businessBomCache.expiresAt > now) {
    return businessBomCache.value;
  }
  if (businessBomCache?.pending) return businessBomCache.pending;

  const pending = Promise.all([
    cloudDatabase.query(
      `SELECT
         c.combine_sku_id AS comboSkuId,
         c.src_sku_id     AS componentSkuId,
         c.qty            AS qty,
         s.name           AS componentName
       FROM JSDataMiddlePlatform.dbo.jst_comboProductItem c
       LEFT JOIN dbo.jst_sku s ON s.sku_id = c.src_sku_id
       WHERE c.combine_sku_id LIKE N'MKH%'
       ORDER BY c.combine_sku_id, c.Id`,
      {},
      { requestTimeout: 180000 }
    ),
    cloudDatabase.query(
      `SELECT s.sku_id AS skuId, s.name AS productName
       FROM dbo.jst_sku s
       WHERE ${MKH_WHERE}`,
      {},
      { requestTimeout: 180000 }
    ),
  ]).then(([rows, productRows]) => {
    const bom = groupBusinessBomRows(rows);
    const productNames = new Map();
    productRows.forEach((row) => {
      const key = normalizeCode(row.skuId);
      if (key) productNames.set(key, toText(row.productName));
    });
    bom.existingSkuKeys = new Set(productNames.keys());
    bom.entries.forEach((entry) => {
      entry.productName = productNames.get(normalizeCode(entry.skuCode)) || entry.productName;
    });
    return bom;
  });

  businessBomCache = { pending, value: null, expiresAt: 0 };
  try {
    const value = await pending;
    businessBomCache = { pending: null, value, expiresAt: Date.now() + BOM_CACHE_TTL_MS };
    return value;
  } catch (error) {
    businessBomCache = null;
    throw error;
  }
}

/**
 * 从产品资料系统数据库读取全部「有配件明细」的模块化商品。
 * 返回 { bySku: Map, bySpuPrefix: Array, entries: Array }
 * 失败时返回空结构并降级（页面照常展示列表，只是配件列为 0）。
 */
async function loadPgBom() {
  const now = Date.now();
  if (productBomCache?.value && productBomCache.expiresAt > now) {
    return productBomCache.value;
  }
  if (productBomCache?.pending) return productBomCache.pending;

  const empty = { bySku: new Map(), bySpuPrefix: [], entries: [] };
  const sql = `
    SELECT
      p.id                                          AS product_id,
      p.spu                                         AS spu,
      COALESCE(s->>'skuCode', s->>'barcode')        AS sku_code,
      s->'componentDetails'                         AS components
    FROM public."IntakeNonIntegratedProduct" p
    CROSS JOIN LATERAL jsonb_array_elements(COALESCE(p.payload->'skuItems', '[]'::jsonb)) s
    WHERE jsonb_array_length(COALESCE(s->'componentDetails', '[]'::jsonb)) > 0`;

  const pending = (async () => {
    let rows = [];
    try {
      rows = await productDb.query(sql);
    } catch (error) {
      console.warn('[MkhBom] 读取产品资料系统数据库失败，配件 BOM 降级:', error.message);
      return empty;
    }

    // 商品名称（资料库档案表，取不到不影响主流程）
    const nameMap = new Map();
    try {
      const nameRows = await productDb.query(
        `SELECT id, "productName" FROM public."IntakeNonIntegratedProductProfile" WHERE "productName" IS NOT NULL`);
      nameRows.forEach((row) => nameMap.set(toText(row.id), toText(row.productName)));
    } catch (error) {
      console.warn('[MkhBom] 读取资料库商品名称失败（忽略）:', error.message);
    }

    const bySku = new Map();
    const bySpuPrefix = [];
    const entries = [];

    rows.forEach((row) => {
      const components = parseComponents(row.components);
      if (components.length === 0) return;

      const skuCode = toText(row.sku_code);
      const spu = toText(row.spu);
      const skuKey = normalizeCode(skuCode);
      if (skuKey) bySku.set(skuKey, components);

      const spuKey = normalizeCode(spu);
      if (spuKey) bySpuPrefix.push({ prefix: spuKey, components, spu });

      entries.push({
        skuCode,
        spu,
        productName: nameMap.get(toText(row.product_id)) || spu || skuCode,
        components,
      });
    });

    // 前缀长优先，避免短前缀抢先命中
    bySpuPrefix.sort((a, b) => b.prefix.length - a.prefix.length);

    return { bySku, bySpuPrefix, entries };
  })();

  productBomCache = { pending, value: null, expiresAt: 0 };
  try {
    const value = await pending;
    productBomCache = { pending: null, value, expiresAt: Date.now() + BOM_CACHE_TTL_MS };
    return value;
  } catch (error) {
    productBomCache = null;
    throw error;
  }
}

/**
 * 按编码匹配配件：先精确 SKU，再退化到 SPU 前缀。
 */
function matchComponents(bom, skuId) {
  const key = normalizeCode(skuId);
  if (!key) return null;

  const exact = bom.bySku.get(key);
  if (exact) return { components: exact, matchType: 'sku' };

  const hit = bom.bySpuPrefix.find((entry) => key.startsWith(entry.prefix));
  if (hit) return { components: hit.components, matchType: 'spu' };

  return null;
}

function matchBomSources(officialBom, businessBom, productBom, skuId) {
  const officialMatch = matchComponents(officialBom, skuId);
  if (officialMatch) return { ...officialMatch, dataSource: 'official_bom' };

  const businessMatch = matchComponents(businessBom, skuId);
  if (businessMatch) return { ...businessMatch, dataSource: 'business_bom' };

  const productMatch = matchComponents(productBom, skuId);
  if (productMatch) return { ...productMatch, dataSource: 'product_db' };

  return null;
}

function summarizeConfiguredBoms(officialBom, businessBom, productBom) {
  const summary = { official: 0, business: 0, product: 0, total: 0 };
  (businessBom?.existingSkuKeys || new Set()).forEach((skuKey) => {
    if (matchComponents(officialBom, skuKey)) {
      summary.official += 1;
      summary.total += 1;
      return;
    }
    if (matchComponents(businessBom, skuKey)) {
      summary.business += 1;
      summary.total += 1;
      return;
    }
    if (matchComponents(productBom, skuKey)) {
      summary.product += 1;
      summary.total += 1;
    }
  });
  return summary;
}

const sumQty = (components) => components.reduce((sum, item) => sum + (toNumber(item.qty) || 0), 0);

function matchesPackSku(componentCode, packSkuCode) {
  const component = toText(componentCode)?.toUpperCase();
  const packSku = toText(packSkuCode)?.toUpperCase();
  if (!component || !packSku) return false;
  return packSku === component || packSku.startsWith(`${component}-`);
}

function formatPackLocation(row) {
  const warehouseName = toText(row.warehouseName);
  const warehouseId = toText(row.warehouseId);
  const warehouse = warehouseName || (warehouseId ? `仓库 ${warehouseId}` : '');
  const binGroup = toText(row.binGroup);
  const bin = toText(row.bin);
  const packId = toText(row.packId);
  const position = [binGroup, bin].filter(Boolean).join(' / ')
    || (packId ? `箱号 ${packId}` : '');
  return [warehouse, position].filter(Boolean).join(' · ');
}

function buildPackLocationMap(rows, componentCodes) {
  const locations = new Map(componentCodes.map((code) => [code, new Set()]));

  rows.forEach((row) => {
    const componentCode = componentCodes.find((code) => matchesPackSku(code, row.skuId));
    if (!componentCode) return;
    const location = formatPackLocation(row);
    if (location) locations.get(componentCode).add(location);
  });

  const result = new Map();
  locations.forEach((values, code) => {
    const all = [...values];
    if (!all.length) return;
    const visible = all.slice(0, 10);
    result.set(code, all.length > visible.length
      ? `${visible.join('、')} 等 ${all.length} 个位置`
      : visible.join('、'));
  });
  return result;
}

/**
 * 列表：指定仓库的 MKH 模块化成品 + BOM 配件种类/数量。
 * BOM 数据只做明细匹配，不向商品列表追加无仓库档案的编码。
 */
async function getMkhBomList(query = {}) {
  const page = Math.max(1, Number.parseInt(query.page, 10) || 1);
  const requestedSize = Number.parseInt(query.pageSize, 10) || DEFAULT_PAGE_SIZE;
  const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, requestedSize));
  const { conditions, params } = buildFilters(query);

  const whereSql = conditions.length
    ? `FROM dbo.jst_sku s WHERE ${MKH_WHERE} AND ${conditions.join(' AND ')}`
    : `FROM dbo.jst_sku s WHERE ${MKH_WHERE}`;

  const sortField = String(query.sortField || 'skuId');
  const sortOrder = String(query.sortOrder || 'ASC').toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
  const orderSql = sortField === 'skuId' ? `s.sku_id ${sortOrder}` : `s.sku_id ASC`;

  const offset = (page - 1) * pageSize;
  const [businessRows, totalRows, officialBomIndex, businessBom, productBom] = await Promise.all([
    cloudDatabase.query(
      `SELECT
         s.sku_id     AS skuId,
         s.name       AS productName,
         s.category   AS category,
         s.other_10   AS material
       ${whereSql}
       ORDER BY ${orderSql}
       OFFSET ${offset} ROWS FETCH NEXT ${pageSize} ROWS ONLY`,
      params,
      { requestTimeout: 180000 }
    ),
    cloudDatabase.query(
      `SELECT COUNT_BIG(*) AS total ${whereSql}`,
      params,
      { requestTimeout: 180000 }
    ),
    loadOfficialBomIndex(),
    loadBusinessBom(),
    loadPgBom(),
  ]);
  const officialBom = await loadOfficialBomForSkus(businessRows.map((row) => row.skuId));
  const bomSummary = summarizeConfiguredBoms(officialBomIndex, businessBom, productBom);
  const [totalRow] = totalRows;

  const mapped = businessRows.map((row) => {
    const skuId = toText(row.skuId);
    const matched = matchBomSources(officialBom, businessBom, productBom, skuId);
    const components = matched?.components || [];

    return {
      skuId,
      productName: toText(row.productName),
      category: toText(row.category),
      material: toText(row.material),
      accessoryCount: components.length,
      accessoryQtySum: sumQty(components),
      bomConfigured: components.length > 0 ? '已配置' : '未配置',
      bomMatchType: matched?.matchType || null,
      bomDataSource: matched?.dataSource || null,
      source: 'business_db',
    };
  });

  return {
    rows: mapped,
    total: Number(totalRow?.total || 0),
    bomRowCount: bomSummary.total,
    bomOfficialRowCount: bomSummary.official,
    bomBusinessRowCount: bomSummary.business,
    bomProductDbRowCount: bomSummary.product,
    bomExtraCount: 0,
    bomReady: bomSummary.total > 0,
    page,
    pageSize,
    configuredInPage: mapped.filter((row) => row.accessoryCount > 0).length,
  };
}

/**
 * 明细：单个 MKH 成品的配件清单
 *   结构按业务模板：配件明细 | 数量 | 配件仓位
 */
async function getMkhBomDetail(mkhSkuId) {
  const skuId = toText(mkhSkuId);
  if (!skuId) {
    const error = new Error('缺少 MKH 商品编码');
    error.statusCode = 400;
    throw error;
  }

  const comboRows = await cloudDatabase.query(
    `SELECT s.sku_id AS skuId, s.name AS productName, s.category AS category
     FROM dbo.jst_sku s
     WHERE s.sku_id = @mkhSkuId AND ${MKH_WHERE}`,
    { mkhSkuId: skuId },
    { requestTimeout: 120000 }
  );

  const combo = comboRows[0] ? {
    skuId: toText(comboRows[0].skuId),
    productName: toText(comboRows[0].productName),
    category: toText(comboRows[0].category),
  } : null;

  if (!combo) {
    const error = new Error('未找到指定仓库的该 MKH 商品');
    error.statusCode = 404;
    throw error;
  }

  const [officialBom, businessBom, productBom] = await Promise.all([
    loadOfficialBomForSkus([skuId]),
    loadBusinessBom(),
    loadPgBom(),
  ]);
  const matched = matchBomSources(officialBom, businessBom, productBom, skuId);
  const components = matched?.components || [];

  const codes = components.map((item) => item.barcode).filter(Boolean);
  const stockMap = new Map();
  const locationMap = new Map();
  const now = Date.now();
  const uncachedCodes = codes.filter((code) => {
    const cached = componentLocationCache.get(normalizeCode(code));
    if (!cached || cached.expiresAt <= now) return true;
    stockMap.set(code, cached.stock);
    if (cached.location) locationMap.set(code, cached.location);
    return false;
  });

  if (uncachedCodes.length > 0) {
    const placeholders = uncachedCodes.map((_, index) => `@c${index}`).join(', ');
    const codeParams = Object.fromEntries(uncachedCodes.map((code, index) => [`c${index}`, code]));
    let stockQuerySucceeded = false;
    let packQuerySucceeded = false;

    try {
      const stockRows = await cloudDatabase.query(
        `SELECT i.sku_id AS skuId, SUM(i.qty) AS qty
         FROM rpt.jst_inventoryInfo i WITH (NOLOCK)
         WHERE i.sku_id IN (${placeholders})
         GROUP BY i.sku_id`,
        codeParams,
        { requestTimeout: 180000 }
      );
      stockRows.forEach((row) => {
        const code = uncachedCodes.find((candidate) => normalizeCode(candidate) === normalizeCode(row.skuId));
        if (!code) return;
        stockMap.set(code, (stockMap.get(code) || 0) + (toNumber(row.qty) ?? 0));
      });
      stockQuerySucceeded = true;
    } catch (error) {
      console.warn('[MkhBom] 配件库存查询降级:', error.message);
    }

    try {
      const locationParams = {};
      const locationConditions = uncachedCodes.map((code, index) => {
        locationParams[`lc${index}`] = code;
        locationParams[`lp${index}`] = `${code}-%`;
        return `(p.sku_id = @lc${index} OR p.sku_id LIKE @lp${index})`;
      });
      const locRows = await cloudDatabase.query(
        `SELECT p.sku_id AS skuId,
                p.pack_id AS packId,
                p.wh_id AS warehouseId,
                p.bin AS bin,
                p.bin_group AS binGroup,
                SUM(p.qty) AS qty
         FROM rpt.jst_packInventoryInfo p WITH (NOLOCK)
         WHERE ${locationConditions.join(' OR ')}
         GROUP BY p.sku_id, p.pack_id, p.wh_id, p.bin, p.bin_group
         HAVING SUM(p.qty) > 0`,
        locationParams,
        { requestTimeout: 120000 }
      );
      buildPackLocationMap(locRows, uncachedCodes).forEach((location, code) => {
        locationMap.set(code, location);
      });
      packQuerySucceeded = true;
    } catch (error) {
      console.warn('[MkhBom] 配件箱号/仓位查询降级:', error.message);
    }

    if (stockQuerySucceeded && packQuerySucceeded) {
      const expiresAt = Date.now() + COMPONENT_LOCATION_CACHE_TTL_MS;
      uncachedCodes.forEach((code) => {
        componentLocationCache.set(normalizeCode(code), {
          stock: stockMap.get(code) ?? 0,
          location: locationMap.get(code) || null,
          expiresAt,
        });
      });
    }
  }

  const items = components.map((component, index) => ({
    index: index + 1,
    skuId: component.barcode,
    barcode: component.barcode,
    skuName: component.name,
    role: component.role,
    qty: toNumber(component.qty) ?? 0,
    location: locationMap.get(component.barcode) || null,
    stock: stockMap.get(component.barcode) ?? 0,
  }));

  return {
    skuId: toText(combo.skuId),
    productName: toText(combo.productName),
    category: toText(combo.category),
    items,
    bomReady: items.length > 0,
    bomMatchType: matched?.matchType || null,
    bomDataSource: matched?.dataSource || null,
  };
}

module.exports = {
  getMkhBomList,
  getMkhBomDetail,
  _private: {
    normalizeCode,
    groupOfficialBomRows,
    groupBusinessBomRows,
    matchComponents,
    matchBomSources,
    summarizeConfiguredBoms,
    matchesPackSku,
    formatPackLocation,
    buildPackLocationMap,
  },
};