const database = require('../config/database');
const xlsx = require('xlsx');

const PRODUCT_CODE_TABLE = 'product_code_items';
const PRODUCT_CODE_STYLE_TABLE = 'product_code_style_registry';
const MAX_BATCH_PRODUCTS = 50;
const MAX_BATCH_SKUS = 200;
const MAX_DELETE_PRODUCT_CODES = 500;
const PRODUCT_CODE_EXPORT_COLUMNS = [
  { key: 'operationCenter', title: '运营中心' },
  { key: 'centerAbbr', title: '中心缩写' },
  { key: 'categoryAbbr', title: '类目缩写' },
  { key: 'serialNumber', title: '序号' },
  { key: 'currentSequence', title: '目前编写序号' },
  { key: 'styleCode', title: '款式编码' },
  { key: 'productCode', title: '商品编码' },
  { key: 'productName', title: '商品名称' },
  { key: 'colorSpec', title: '颜色及规格' },
  { key: 'brand', title: '品牌' },
  { key: 'categoryName', title: '分类' },
  { key: 'virtualCategory', title: '虚拟分类' },
  { key: 'productTag', title: '商品标签' },
  { key: 'productStatus', title: '商品状态' },
  { key: 'inventorySync', title: '库存同步' },
  { key: 'productAttribute', title: '商品属性' },
  { key: 'weight', title: '重量kg' },
  { key: 'lengthCm', title: '长cm' },
  { key: 'widthCm', title: '宽cm' },
  { key: 'heightCm', title: '高cm' },
  { key: 'volume', title: '体积' },
  { key: 'unit', title: '单位' },
  { key: 'otherAttr7', title: '其它属性7' },
  { key: 'otherAttr5', title: '其它属性5' },
  { key: 'createdByName', title: '创建人' },
  { key: 'createdAt', title: '创建时间' },
];
const BATCH_IMPORT_TEMPLATE_FIELDS = [
  { key: 'operationCenter', title: '运营中心', rule: '必填，仅支持模板辅助表中的选项，填写其它内容将无法导入' },
  { key: 'categoryName', title: '分类', rule: '必填，仅支持模板辅助表中的选项，填写其它内容将无法导入' },
  { key: 'productIndex', title: '商品序号', rule: '必填，仅用于归并同一款式的多个规格，不是系统真实序号；真实序号会按系统当前最大值自动顺延生成' },
  { key: 'productName', title: '商品名称', rule: '必填，每一行填写当前规格对应的商品名称；同一商品序号下可不同' },
  { key: 'colorName', title: '颜色', rule: '必填，例如原木色' },
  { key: 'lengthCm', title: '长cm', rule: '选填，单位厘米；如填写则必须大于 0' },
  { key: 'widthCm', title: '宽cm', rule: '选填，单位厘米；如填写则必须大于 0' },
  { key: 'heightCm', title: '高cm', rule: '选填，单位厘米；如填写则必须大于 0' },
  { key: 'weight', title: '重量kg', rule: '选填，单位kg' },
];

const FIXED_VALUES = {
  brand: '一件代发',
  virtualCategory: 'ODM',
  productTag: '1688一件代发',
  productStatus: '启用',
  inventorySync: '否',
  productAttribute: '成品',
  unit: '个',
  otherAttr5: '销售',
};

const OPERATION_CENTER_OPTIONS = [
  { name: '事业一部', abbreviation: 'A1' },
  { name: '事业二部', abbreviation: 'A2' },
  { name: '事业三部', abbreviation: 'A3' },
  { name: '事业四部', abbreviation: 'A4' },
  { name: '运营中心B', abbreviation: 'B1' },
  { name: '运营中心C', abbreviation: 'C1' },
  { name: '运营中心G', abbreviation: 'G1' },
];

const CATEGORY_OPTIONS = [
  { name: '住宅家具 - 书架', abbreviation: 'SJ' },
  { name: '住宅家具 - 电脑桌', abbreviation: 'DNZ' },
  { name: '住宅家具 - 鞋柜', abbreviation: 'XG' },
  { name: '住宅家具 - 床头柜', abbreviation: 'CTG' },
  { name: '住宅家具 - 书桌', abbreviation: 'SZ' },
  { name: '住宅家具 - 餐边柜', abbreviation: 'CBG' },
  { name: '住宅家具 - 矮凳', abbreviation: 'AD' },
  { name: '住宅家具 - 茶几', abbreviation: 'CJ' },
  { name: '住宅家具 - 书柜', abbreviation: 'SG' },
  { name: '住宅家具 - 厨房置物架/角架', abbreviation: 'CFZW' },
  { name: '住宅家具 - 角几/边几', abbreviation: 'BJ' },
  { name: '住宅家具 - 餐桌', abbreviation: 'CZ' },
  { name: '住宅家具 - 梳妆台/桌', abbreviation: 'SZT' },
  { name: '住宅家具 - 懒人沙发', abbreviation: 'LRSF' },
  { name: '住宅家具 - 书桌收纳置物架', abbreviation: 'SJ' },
  { name: '住宅家具 - 电视柜', abbreviation: 'DSG' },
  { name: '住宅家具 - 换鞋凳', abbreviation: 'HXD' },
  { name: '住宅家具 - 搁板/置物架', abbreviation: 'ZWJ' },
  { name: '住宅家具 - 衣帽架', abbreviation: 'YMJ' },
  { name: '住宅家具 - 厨房储物架/厨房置物架', abbreviation: 'CFZW' },
  { name: '住宅家具 - 电脑椅', abbreviation: 'DNY' },
  { name: '住宅家具 - 餐椅', abbreviation: 'CY' },
  { name: '住宅家具 - 化妆镜', abbreviation: 'HZJ' },
  { name: '商业/办公家具 - 文具边柜', abbreviation: 'BG' },
  { name: '住宅家具 - 鞋架', abbreviation: 'XJ' },
  { name: '其他 - 配件', abbreviation: 'PJ' },
  { name: '住宅家具 - 斗柜', abbreviation: 'DG' },
  { name: '住宅家具 - 家居收纳产品', abbreviation: 'SN' },
  { name: '住宅家具 - 角柜', abbreviation: 'JG' },
  { name: '住宅家具 - 花架/花几', abbreviation: 'HJ' },
  { name: '住宅家具 - 办公升降台/升降桌', abbreviation: 'DNZ' },
  { name: '住宅家具 - 折叠桌', abbreviation: 'ZDZ' },
  { name: '商业/办公家具 - 组合/屏风工作位', abbreviation: 'GZW' },
  { name: '住宅家具 - 穿衣镜', abbreviation: 'CYJ' },
  { name: '住宅家具 - 功能沙发', abbreviation: 'GNSF' },
  { name: '住宅家具 - 梳妆凳', abbreviation: 'SZD' },
  { name: '住宅家具 - 布艺沙发', abbreviation: 'BYSF' },
  { name: '住宅家具 - 办公桌', abbreviation: 'DNZ' },
  { name: '住宅家具 - 折叠床/午休床', abbreviation: 'ZDC' },
  { name: '住宅家具 - 折叠椅/躺椅', abbreviation: 'ZDY' },
  { name: '住宅家具 - 电竞椅', abbreviation: 'DJY' },
  { name: '住宅家具 - 沙发床', abbreviation: 'SFC' },
  { name: '住宅家具 - 衣柜', abbreviation: 'YG' },
  { name: '住宅家具 - 收纳洞洞板', abbreviation: 'DDB' },
  { name: '住宅家具 - 飘窗柜', abbreviation: 'PCG' },
  { name: '住宅家具 - 床垫类', abbreviation: 'CD' },
  { name: '住宅家具 - 门厅/玄关柜/玄关架', abbreviation: 'XGG' },
  { name: '住宅家具 - 其它家具配件', abbreviation: 'PJ' },
  { name: '住宅家具 - 卫浴/置物用具', abbreviation: 'WYZW' },
  { name: '住宅家具 - 折叠床', abbreviation: 'ZDC' },
  { name: '商业/办公家具 - 演讲台', abbreviation: 'YJT' },
  { name: '住宅家具 - 休闲椅', abbreviation: 'XXY' },
  { name: '其他 - 福利品', abbreviation: 'FL' },
  { name: '住宅家具 - 家用梯', abbreviation: 'TZ' },
  { name: '住宅家具 - 收纳柜', abbreviation: 'SN' },
  { name: '住宅家具 - 板木结合床', abbreviation: 'BMC' },
  { name: '住宅家具 - 儿童餐椅', abbreviation: 'CY' },
  { name: '商业/办公家具 - 会议桌', abbreviation: 'HYZ' },
  { name: '住宅家具 - 洞洞板', abbreviation: 'DDB' },
  { name: '住宅家具 - 衣物洗/晒/护理用具', abbreviation: 'QT' },
  { name: '住宅家具 - 炕几', abbreviation: 'KJ' },
  { name: '商业/办公家具 - 前台/接待台（新增）', abbreviation: 'QT' },
  { name: '住宅家具 - 平板手推车/工具车', abbreviation: 'QT' },
  { name: '住宅家具 - 收纳筐', abbreviation: 'SN' },
  { name: '其他 - 虚拟产品', abbreviation: 'XN' },
  { name: '住宅家具 - 电动升降桌', abbreviation: 'SJZ' },
  { name: '住宅家具 - 窝/屋/帐篷', abbreviation: 'QT' },
  { name: '其他 - 赠品', abbreviation: 'ZP' },
  { name: '住宅家具 - 酒吧椅', abbreviation: 'JBY' },
  { name: '住宅家具 - 主机箱托架', abbreviation: 'QT' },
  { name: '住宅家具 - 吊柜/壁柜', abbreviation: 'DG' },
  { name: '住宅家具 - 儿童学习椅', abbreviation: 'XXY' },
  { name: '住宅家具 - 儿童学习桌', abbreviation: 'XXZ' },
  { name: '住宅家具 - 实木床', abbreviation: 'SMC' },
  { name: '住宅家具 - 其它凳子', abbreviation: 'DZ' },
];

const TEMPLATE_FIELDS = [
  { key: 'operationCenter', title: '运营中心', rule: '选择，选项见【辅助表-勿动】D列' },
  { key: 'centerAbbr', title: '中心缩写', rule: '用A列匹配【辅助表-勿动】D-F列' },
  { key: 'categoryAbbr', title: '类目缩写', rule: '用K列匹配【辅助表-勿动】A-B列' },
  { key: 'serialNumber', title: '序号', rule: '当下输入的序号=目前编写序号+1，填入后目前编写序号会变' },
  { key: 'currentSequence', title: '目前编写序号', rule: '按中心缩写+类目缩写取当前最大序号' },
  { key: 'styleCode', title: '款式编码', rule: 'DF- + 中心缩写 + 类目缩写 + 4位序号' },
  { key: 'productCode', title: '商品编码', rule: '款式编码 + 2位SKU序号' },
  { key: 'productName', title: '商品名称', rule: '必填，运营填写' },
  { key: 'colorSpec', title: '颜色及规格', rule: '运营填写，格式可写为：颜色；长/宽/高，单位为厘米；长宽高可留空' },
  { key: 'brand', title: '品牌', rule: '固定内容下拉' },
  { key: 'categoryName', title: '分类', rule: '选择，选项见【辅助表-勿动】A列' },
  { key: 'virtualCategory', title: '虚拟分类', rule: '固定内容下拉' },
  { key: 'productTag', title: '商品标签', rule: '固定内容下拉' },
  { key: 'productStatus', title: '商品状态', rule: '固定内容下拉' },
  { key: 'inventorySync', title: '库存同步', rule: '固定内容下拉' },
  { key: 'productAttribute', title: '商品属性', rule: '固定内容下拉' },
  { key: 'weight', title: '重量', rule: '选填，单位为kg' },
  { key: 'lengthCm', title: '长', rule: '选填，运营填写单位是厘米；如填写则必须大于 0' },
  { key: 'widthCm', title: '宽', rule: '选填，运营填写单位是厘米；如填写则必须大于 0' },
  { key: 'heightCm', title: '高', rule: '选填，运营填写单位是厘米；如填写则必须大于 0' },
  { key: 'volume', title: '体积', rule: '长*宽*高；长宽高为空时可留空' },
  { key: 'unit', title: '单位', rule: '固定内容下拉' },
  { key: 'otherAttr7', title: '其它属性7', rule: '等于商品编码' },
  { key: 'otherAttr5', title: '其它属性5', rule: '固定内容下拉' },
];

const centerMap = new Map(OPERATION_CENTER_OPTIONS.map((item) => [item.name, item]));
const categoryMap = new Map(CATEGORY_OPTIONS.map((item) => [item.name, item]));
const fieldTitleMap = new Map(TEMPLATE_FIELDS.map((field) => [field.title, field]));
const batchImportFieldTitleMap = new Map(BATCH_IMPORT_TEMPLATE_FIELDS.map((field) => [field.title, field]));

function parsePositiveInt(value, fallback, maxValue = 200) {
  const parsed = Number.parseInt(value, 10);
  if (!Number.isFinite(parsed) || parsed <= 0) {
    return fallback;
  }
  return Math.min(parsed, maxValue);
}

function normalizeString(value) {
  return String(value || '').trim();
}

function parseListParam(value) {
  if (!value) {
    return [];
  }

  if (Array.isArray(value)) {
    return [...new Set(value.flatMap((item) => String(item).split(',')).map((item) => item.trim()).filter(Boolean))];
  }

  return [...new Set(String(value).split(',').map((item) => item.trim()).filter(Boolean))];
}

function normalizeDateTimeFilter(value, label, endOfDay = false) {
  const raw = normalizeString(value);
  if (!raw) {
    return '';
  }

  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
    return `${raw} ${endOfDay ? '23:59:59' : '00:00:00'}`;
  }

  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(raw)) {
    return `${raw}:${endOfDay ? '59' : '00'}`;
  }

  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(raw)) {
    return raw;
  }

  const error = new Error(`${label}格式不正确`);
  error.status = 400;
  throw error;
}

function padNumber(value, length) {
  return String(value).padStart(length, '0');
}

function buildStyleCode(centerAbbr, categoryAbbr, serialNumber) {
  return `DF-${centerAbbr}${categoryAbbr}${padNumber(serialNumber, 4)}`;
}

function buildProductCode(styleCode, skuIndex) {
  return `${styleCode}${padNumber(skuIndex, 2)}`;
}

function isProductCodeConflictError(error) {
  if (!error) {
    return false;
  }

  if (String(error.code || '') === 'ER_DUP_ENTRY') {
    return true;
  }

  const message = String(error.message || '').toLowerCase();
  return (
    message.includes('duplicate entry')
    || message.includes('uk_product_code_items_product_code')
    || message.includes('uk_product_code_style_registry_style_code')
    || message.includes('uk_product_code_style_registry_center_category_serial')
  );
}

function buildProductCodeStyleRow({ center, category, serialNumber, styleCode, user = {} }) {
  return {
    operation_center: center.name,
    center_abbr: center.abbreviation,
    category_abbr: category.abbreviation,
    serial_number: serialNumber,
    style_code: styleCode,
    category_name: category.name,
    created_by_user_id: user.sub || null,
    created_by_username: user.username || '',
    created_by_name: user.name || user.username || '',
    created_department_id: user.departmentId || null,
    created_department_name: user.departmentName || '',
  };
}

async function syncProductCodeStyleRegistryGroup(centerAbbr, categoryAbbr) {
  const conflictingRows = await database.local.query(
    `SELECT
       serial_number AS serialNumber,
       GROUP_CONCAT(DISTINCT style_code ORDER BY style_code SEPARATOR ', ') AS styleCodes
     FROM ${PRODUCT_CODE_TABLE}
     WHERE center_abbr = ? AND category_abbr = ?
     GROUP BY serial_number
     HAVING COUNT(DISTINCT style_code) > 1
     ORDER BY serial_number
     LIMIT 5`,
    [centerAbbr, categoryAbbr]
  );

  if (conflictingRows.length) {
    const summary = conflictingRows
      .map((row) => `序号 ${row.serialNumber} 对应多个款式编码：${row.styleCodes}`)
      .join('；');
    const error = new Error(`检测到 ${centerAbbr}/${categoryAbbr} 下存在序号与款式编码不一致的数据，${summary}。请检查导入文件或先修正历史数据后再导入`);
    error.status = 400;
    throw error;
  }

  await database.local.query(
    `DELETE FROM ${PRODUCT_CODE_STYLE_TABLE}
     WHERE center_abbr = ? AND category_abbr = ?`,
    [centerAbbr, categoryAbbr]
  );

  await database.local.query(
    `INSERT INTO ${PRODUCT_CODE_STYLE_TABLE} (
       operation_center,
       center_abbr,
       category_abbr,
       serial_number,
       style_code,
       category_name,
       created_by_user_id,
       created_by_username,
       created_by_name,
       created_department_id,
       created_department_name,
       created_at,
       updated_at
     )
     SELECT
       MIN(operation_center) AS operation_center,
       center_abbr,
       category_abbr,
       serial_number,
       style_code,
       MIN(category_name) AS category_name,
       MAX(created_by_user_id) AS created_by_user_id,
       MAX(created_by_username) AS created_by_username,
       MAX(created_by_name) AS created_by_name,
       MAX(created_department_id) AS created_department_id,
       MAX(created_department_name) AS created_department_name,
       MIN(created_at) AS created_at,
       MAX(updated_at) AS updated_at
     FROM ${PRODUCT_CODE_TABLE}
     WHERE center_abbr = ? AND category_abbr = ?
     GROUP BY center_abbr, category_abbr, serial_number, style_code`,
    [centerAbbr, categoryAbbr]
  );
}

function parseSerialFromStyleCode(styleCode) {
  const matched = normalizeString(styleCode).match(/(\d{4})$/);
  return matched ? Number(matched[1]) : 0;
}

function deriveStyleCodeFromProductCode(productCode) {
  const raw = normalizeString(productCode);
  return raw.length > 2 ? raw.slice(0, -2) : '';
}

function parseOptionalPositiveDecimal(value, fieldName) {
  if (value === null || value === undefined || value === '') {
    return null;
  }

  const parsed = Number(value);
  if (!Number.isFinite(parsed) || parsed <= 0) {
    const error = new Error(`${fieldName}必须大于 0`);
    error.status = 400;
    throw error;
  }
  return parsed;
}

function parseOptionalDecimal(value, fieldName) {
  if (value === null || value === undefined || value === '') {
    return null;
  }

  const parsed = Number(value);
  if (!Number.isFinite(parsed) || parsed < 0) {
    const error = new Error(`${fieldName}不能小于 0`);
    error.status = 400;
    throw error;
  }
  return parsed;
}

function formatDimension(value) {
  const fixed = Number(value).toFixed(2);
  return fixed.replace(/\.?0+$/, '');
}

function hasDimensionValue(value) {
  if (value === null || value === undefined || value === '') {
    return false;
  }

  return Number.isFinite(Number(value));
}

function buildVolume(lengthCm, widthCm, heightCm) {
  if (!hasDimensionValue(lengthCm) || !hasDimensionValue(widthCm) || !hasDimensionValue(heightCm)) {
    return null;
  }

  return Number((Number(lengthCm) * Number(widthCm) * Number(heightCm)).toFixed(4));
}

function buildColorSpec(sku) {
  const explicit = normalizeString(sku.colorSpec);
  if (explicit) {
    return explicit;
  }

  const colorName = normalizeString(sku.colorName);
  const dimensions = [
    { label: '长', value: sku.lengthCm },
    { label: '宽', value: sku.widthCm },
    { label: '高', value: sku.heightCm },
  ].filter((item) => hasDimensionValue(item.value));

  let sizeText = '';
  if (dimensions.length === 3) {
    sizeText = dimensions.map((item) => formatDimension(item.value)).join('/');
  } else if (dimensions.length > 0) {
    sizeText = dimensions.map((item) => `${item.label}${formatDimension(item.value)}`).join('/');
  }

  if (colorName && sizeText) {
    return `${colorName}；${sizeText}`;
  }

  return colorName || sizeText;
}

function resolveOperationCenter(operationCenter) {
  const center = centerMap.get(normalizeString(operationCenter));
  if (!center) {
    const error = new Error('请选择有效的运营中心');
    error.status = 400;
    throw error;
  }
  return center;
}

function resolveCategory(categoryName) {
  const category = categoryMap.get(normalizeString(categoryName));
  if (!category) {
    const error = new Error('请选择有效的分类');
    error.status = 400;
    throw error;
  }
  return category;
}

function normalizeSkuItems(rawItems, ownerLabel = '') {
  const items = Array.isArray(rawItems) ? rawItems : [];
  if (items.length === 0) {
    const error = new Error(`${ownerLabel || '请'}至少填写一个商品规格`);
    error.status = 400;
    throw error;
  }

  return items.map((rawItem, index) => {
    const label = ownerLabel ? `${ownerLabel}第 ${index + 1} 个规格` : `第 ${index + 1} 个规格`;
    const productName = normalizeString(rawItem.productName || rawItem.defaultProductName);
    const lengthCm = parseOptionalPositiveDecimal(rawItem.lengthCm, `${label}的长`);
    const widthCm = parseOptionalPositiveDecimal(rawItem.widthCm, `${label}的宽`);
    const heightCm = parseOptionalPositiveDecimal(rawItem.heightCm, `${label}的高`);
    const weight = parseOptionalDecimal(rawItem.weight, `${label}的重量`);
    const colorName = normalizeString(rawItem.colorName);

    if (!productName) {
      const error = new Error(`${label}请填写商品名称`);
      error.status = 400;
      throw error;
    }

    if (!normalizeString(rawItem.colorSpec) && !colorName) {
      const error = new Error(`${label}请填写颜色`);
      error.status = 400;
      throw error;
    }

    return {
      productName,
      colorName,
      colorSpec: normalizeString(rawItem.colorSpec),
      weight,
      lengthCm,
      widthCm,
      heightCm,
      volume: buildVolume(lengthCm, widthCm, heightCm),
    };
  });
}

function normalizeCreateProduct(rawProduct = {}, index = 0) {
  return {
    skuItems: normalizeSkuItems(
      (Array.isArray(rawProduct.skuItems) ? rawProduct.skuItems : []).map((item) => ({
        ...item,
        defaultProductName: rawProduct.productName,
      })),
      `第 ${index + 1} 个商品`
    ),
  };
}

function normalizeCreateProducts(payload = {}) {
  const rawProducts = Array.isArray(payload.products)
    ? payload.products
    : [{
      productName: payload.productName,
      skuItems: payload.skuItems,
    }];

  if (rawProducts.length === 0) {
    const error = new Error('请至少填写一个商品');
    error.status = 400;
    throw error;
  }

  if (rawProducts.length > MAX_BATCH_PRODUCTS) {
    const error = new Error(`单次最多批量新增 ${MAX_BATCH_PRODUCTS} 个商品`);
    error.status = 400;
    throw error;
  }

  const products = rawProducts.map(normalizeCreateProduct);
  const skuCount = products.reduce((sum, product) => sum + product.skuItems.length, 0);
  if (skuCount > MAX_BATCH_SKUS) {
    const error = new Error(`单次最多批量新增 ${MAX_BATCH_SKUS} 个商品规格`);
    error.status = 400;
    throw error;
  }

  return products;
}

function buildWhereClause(filters = {}) {
  const clauses = [];
  const values = [];

  const keyword = normalizeString(filters.keyword);
  if (keyword) {
    clauses.push('(product_name LIKE ? OR product_code LIKE ? OR style_code LIKE ? OR color_spec LIKE ?)');
    values.push(`%${keyword}%`, `%${keyword}%`, `%${keyword}%`, `%${keyword}%`);
  }

  const operationCenter = normalizeString(filters.operationCenter);
  if (operationCenter) {
    clauses.push('operation_center = ?');
    values.push(operationCenter);
  }

  const categoryName = normalizeString(filters.categoryName);
  if (categoryName) {
    clauses.push('category_name = ?');
    values.push(categoryName);
  }

  const productStatus = normalizeString(filters.productStatus);
  if (productStatus) {
    clauses.push('product_status = ?');
    values.push(productStatus);
  }

  const createdByNames = parseListParam(filters.createdByNames);
  if (createdByNames.length) {
    clauses.push('created_by_name IN (?)');
    values.push(createdByNames);
  }

  const createdAtStart = normalizeDateTimeFilter(filters.createdAtStart, '创建开始时间');
  if (createdAtStart) {
    clauses.push('created_at >= ?');
    values.push(createdAtStart);
  }

  const createdAtEnd = normalizeDateTimeFilter(filters.createdAtEnd, '创建结束时间', true);
  if (createdAtEnd) {
    clauses.push('created_at <= ?');
    values.push(createdAtEnd);
  }

  return {
    whereSql: clauses.length ? `WHERE ${clauses.join(' AND ')}` : '',
    values,
  };
}

function mapProductCodeRow(row) {
  return {
    id: row.id,
    operationCenter: row.operationCenter,
    centerAbbr: row.centerAbbr,
    categoryAbbr: row.categoryAbbr,
    serialNumber: row.serialNumber,
    currentSequence: row.currentSequence,
    styleCode: row.styleCode,
    productCode: row.productCode,
    productName: row.productName,
    colorSpec: row.colorSpec,
    brand: row.brand,
    categoryName: row.categoryName,
    virtualCategory: row.virtualCategory,
    productTag: row.productTag,
    productStatus: row.productStatus,
    inventorySync: row.inventorySync,
    productAttribute: row.productAttribute,
    weight: row.weight,
    lengthCm: row.lengthCm,
    widthCm: row.widthCm,
    heightCm: row.heightCm,
    volume: row.volume,
    unit: row.unit,
    otherAttr7: row.otherAttr7,
    otherAttr5: row.otherAttr5,
    createdByName: row.createdByName,
    createdAt: row.createdAt,
    updatedAt: row.updatedAt,
  };
}

async function getProductCodeMeta() {
  const createdByRows = await database.local.query(
    `SELECT created_by_name AS createdByName
     FROM ${PRODUCT_CODE_TABLE}
     WHERE TRIM(COALESCE(created_by_name, '')) <> ''
     GROUP BY created_by_name
     ORDER BY MAX(created_at) DESC, created_by_name ASC`
  );

  return {
    templateFields: TEMPLATE_FIELDS,
    operationCenters: OPERATION_CENTER_OPTIONS,
    categories: CATEGORY_OPTIONS,
    createdByNames: createdByRows.map((row) => normalizeString(row.createdByName)).filter(Boolean),
    fixedValues: FIXED_VALUES,
  };
}

function formatExportDateTime(value) {
  if (!value) {
    return '';
  }

  const date = value instanceof Date ? value : new Date(value);
  if (Number.isNaN(date.getTime())) {
    return String(value);
  }

  const year = date.getFullYear();
  const month = padNumber(date.getMonth() + 1, 2);
  const day = padNumber(date.getDate(), 2);
  const hours = padNumber(date.getHours(), 2);
  const minutes = padNumber(date.getMinutes(), 2);
  const seconds = padNumber(date.getSeconds(), 2);
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}

async function queryProductCodeRows(filters = {}) {
  const { whereSql, values } = buildWhereClause(filters);
  const rows = await database.local.query(
    `SELECT
       id,
       operation_center AS operationCenter,
       center_abbr AS centerAbbr,
       category_abbr AS categoryAbbr,
       serial_number AS serialNumber,
       current_sequence AS currentSequence,
       style_code AS styleCode,
       product_code AS productCode,
       product_name AS productName,
       color_spec AS colorSpec,
       brand,
       category_name AS categoryName,
       virtual_category AS virtualCategory,
       product_tag AS productTag,
       product_status AS productStatus,
       inventory_sync AS inventorySync,
       product_attribute AS productAttribute,
       weight,
       length_cm AS lengthCm,
       width_cm AS widthCm,
       height_cm AS heightCm,
       volume,
       unit,
       other_attr7 AS otherAttr7,
       other_attr5 AS otherAttr5,
       created_by_name AS createdByName,
       created_at AS createdAt,
       updated_at AS updatedAt
     FROM ${PRODUCT_CODE_TABLE}
     ${whereSql}
     ORDER BY created_at DESC, id DESC`,
    values
  );

  return rows.map(mapProductCodeRow);
}

function buildProductCodeImportTemplateBuffer() {
  const headers = TEMPLATE_FIELDS.map((field) => field.title);
  const rules = TEMPLATE_FIELDS.map((field) => field.rule);
  const example = [
    '事业一部',
    'A1',
    'DNZ',
    1,
    1,
    'DF-A1DNZ0001',
    'DF-A1DNZ000101',
    '示例电脑桌',
    '原木色',
    FIXED_VALUES.brand,
    '住宅家具 - 电脑桌',
    FIXED_VALUES.virtualCategory,
    FIXED_VALUES.productTag,
    FIXED_VALUES.productStatus,
    FIXED_VALUES.inventorySync,
    FIXED_VALUES.productAttribute,
    12.5,
    '',
    '',
    '',
    '',
    FIXED_VALUES.unit,
    'DF-A1DNZ000101',
    FIXED_VALUES.otherAttr5,
  ];

  const templateSheet = xlsx.utils.aoa_to_sheet([rules, headers, example]);
  templateSheet['!cols'] = headers.map((title) => ({ wch: Math.max(12, Math.min(28, title.length * 2 + 8)) }));

  const helperRows = [
    ['类目', '缩写', '', '运营中心', '缩写'],
  ];
  const maxRows = Math.max(CATEGORY_OPTIONS.length, OPERATION_CENTER_OPTIONS.length);
  for (let index = 0; index < maxRows; index += 1) {
    helperRows.push([
      CATEGORY_OPTIONS[index]?.name || '',
      CATEGORY_OPTIONS[index]?.abbreviation || '',
      '',
      OPERATION_CENTER_OPTIONS[index]?.name || '',
      OPERATION_CENTER_OPTIONS[index]?.abbreviation || '',
    ]);
  }
  const helperSheet = xlsx.utils.aoa_to_sheet(helperRows);
  helperSheet['!cols'] = [{ wch: 36 }, { wch: 10 }, { wch: 4 }, { wch: 18 }, { wch: 10 }];

  const workbook = xlsx.utils.book_new();
  xlsx.utils.book_append_sheet(workbook, templateSheet, '测款导入模板');
  xlsx.utils.book_append_sheet(workbook, helperSheet, '辅助表-勿动');

  return xlsx.write(workbook, { type: 'buffer', bookType: 'xlsx' });
}

function buildProductCodeBatchImportTemplateBuffer() {
  const headers = BATCH_IMPORT_TEMPLATE_FIELDS.map((field) => field.title);
  const rules = BATCH_IMPORT_TEMPLATE_FIELDS.map((field) => field.rule);
  const examples = [
    ['事业一部', '住宅家具 - 电脑桌', 1, '80cm电脑桌-原木色', '原木色', 120, 60, 75, 12.5],
    ['事业一部', '住宅家具 - 电脑桌', 1, '80cm电脑桌-胡桃色', '胡桃色', '', '', '', 12.8],
    ['事业二部', '住宅家具 - 书架', 1, '五层书架-白色', '白色', 80, 30, 180, 16],
  ];
  const sheet = xlsx.utils.aoa_to_sheet([rules, headers, ...examples]);
  sheet['!cols'] = headers.map((title, index) => ({
    wch: Math.max(12, Math.min(26, title.length * 2 + (index === 1 ? 12 : 8))),
  }));

  const helperRows = [
    ['分类', '缩写', '', '运营中心', '缩写'],
  ];
  const maxRows = Math.max(CATEGORY_OPTIONS.length, OPERATION_CENTER_OPTIONS.length);
  for (let index = 0; index < maxRows; index += 1) {
    helperRows.push([
      CATEGORY_OPTIONS[index]?.name || '',
      CATEGORY_OPTIONS[index]?.abbreviation || '',
      '',
      OPERATION_CENTER_OPTIONS[index]?.name || '',
      OPERATION_CENTER_OPTIONS[index]?.abbreviation || '',
    ]);
  }
  const helperSheet = xlsx.utils.aoa_to_sheet(helperRows);
  helperSheet['!cols'] = [{ wch: 36 }, { wch: 10 }, { wch: 4 }, { wch: 18 }, { wch: 10 }];

  const workbook = xlsx.utils.book_new();
  xlsx.utils.book_append_sheet(workbook, sheet, '批量新增模板');
  xlsx.utils.book_append_sheet(workbook, helperSheet, '辅助表-勿动');
  return xlsx.write(workbook, { type: 'buffer', bookType: 'xlsx' });
}

function getCellText(value) {
  if (value === null || value === undefined) {
    return '';
  }

  if (value instanceof Date) {
    return value.toISOString();
  }

  return String(value).trim();
}

function parseImportNumber(value, fieldName, { required = false, min = null } = {}) {
  const raw = getCellText(value).replace(/,/g, '');
  if (!raw) {
    if (required) {
      const error = new Error(`${fieldName}不能为空`);
      error.status = 400;
      throw error;
    }
    return null;
  }

  const parsed = Number(raw);
  if (!Number.isFinite(parsed)) {
    const error = new Error(`${fieldName}必须是数字`);
    error.status = 400;
    throw error;
  }

  if (min !== null && parsed < min) {
    const error = new Error(`${fieldName}不能小于 ${min}`);
    error.status = 400;
    throw error;
  }

  return parsed;
}

function selectImportSheet(workbook) {
  const preferredNames = ['编码模板', '测款导入模板', '商品编码模板'];
  const sheetName = preferredNames.find((name) => workbook.SheetNames.includes(name)) || workbook.SheetNames[0];
  return {
    sheetName,
    sheet: workbook.Sheets[sheetName],
  };
}

function selectBatchImportSheet(workbook) {
  const preferredNames = ['批量新增模板', '批量新增商品模板', '测款批量新增模板'];
  const sheetName = preferredNames.find((name) => workbook.SheetNames.includes(name)) || workbook.SheetNames[0];
  return {
    sheetName,
    sheet: workbook.Sheets[sheetName],
  };
}

function findHeaderRow(rows) {
  return rows.findIndex((row) => {
    const titles = new Set((row || []).map((value) => getCellText(value)));
    return titles.has('运营中心') && titles.has('商品编码') && titles.has('分类');
  });
}

function findBatchImportHeaderRow(rows) {
  return rows.findIndex((row) => {
    const titles = new Set((row || []).map((value) => getCellText(value)));
    return titles.has('运营中心')
      && titles.has('分类')
      && titles.has('商品序号')
      && titles.has('商品名称')
      && titles.has('颜色')
      && titles.has('长cm')
      && titles.has('宽cm')
      && titles.has('高cm');
  });
}

function readImportRows(buffer) {
  const workbook = xlsx.read(buffer, {
    type: 'buffer',
    cellDates: true,
    cellFormula: true,
    raw: true,
  });
  const { sheetName, sheet } = selectImportSheet(workbook);
  if (!sheet) {
    const error = new Error('未识别到可导入的工作表');
    error.status = 400;
    throw error;
  }

  const rows = xlsx.utils.sheet_to_json(sheet, { header: 1, defval: '', raw: true });
  const headerRowIndex = findHeaderRow(rows);
  if (headerRowIndex < 0) {
    const error = new Error('导入文件缺少表头行，请使用“测款导入模板”或原“编码模板”格式');
    error.status = 400;
    throw error;
  }

  const headers = rows[headerRowIndex].map((value) => getCellText(value));
  const dataRows = rows.slice(headerRowIndex + 1);

  return {
    sheetName,
    headers,
    headerRowIndex,
    dataRows,
  };
}

function readBatchImportRows(buffer) {
  const workbook = xlsx.read(buffer, {
    type: 'buffer',
    cellDates: true,
    cellFormula: true,
    raw: true,
  });
  const { sheetName, sheet } = selectBatchImportSheet(workbook);
  if (!sheet) {
    const error = new Error('未识别到可导入的工作表');
    error.status = 400;
    throw error;
  }

  const rows = xlsx.utils.sheet_to_json(sheet, { header: 1, defval: '', raw: true });
  const headerRowIndex = findBatchImportHeaderRow(rows);
  if (headerRowIndex < 0) {
    const error = new Error('导入文件缺少批量新增表头，请使用“批量新增模板”');
    error.status = 400;
    throw error;
  }

  const headers = rows[headerRowIndex].map((value) => getCellText(value));
  const dataRows = rows.slice(headerRowIndex + 1);

  return {
    sheetName,
    headers,
    dataRows,
  };
}

function buildHeaderIndexes(headers) {
  return headers.reduce((acc, title, index) => {
    if (fieldTitleMap.has(title)) {
      acc[fieldTitleMap.get(title).key] = index;
    }
    return acc;
  }, {});
}

function buildBatchImportHeaderIndexes(headers) {
  return headers.reduce((acc, title, index) => {
    if (batchImportFieldTitleMap.has(title)) {
      acc[batchImportFieldTitleMap.get(title).key] = index;
    }
    return acc;
  }, {});
}

function getImportValue(row, indexes, key) {
  const index = indexes[key];
  return index === undefined ? '' : row[index];
}

function createProductCodeImportValidationError({ sheetName, headers, rowErrors }) {
  const error = new Error(`导入校验失败，共 ${rowErrors.length} 行存在问题`);
  error.status = 400;
  error.code = 'PRODUCT_CODE_IMPORT_VALIDATION_FAILED';
  error.details = {
    sheetName,
    headers,
    rowErrors,
  };
  return error;
}

function normalizeImportedRows(buffer, user = {}) {
  const { sheetName, headers, dataRows, headerRowIndex } = readImportRows(buffer);
  const indexes = buildHeaderIndexes(headers);
  const uploadStyleCounters = new Map();
  const missingProductCodeRows = [];
  const normalizedRows = [];
  const seenProductCodes = new Set();
  const rowErrors = [];

  dataRows.forEach((row, rowOffset) => {
    const rowNumber = headerRowIndex + rowOffset + 2;
    const hasValue = row.some((value) => getCellText(value));
    if (!hasValue) {
      return;
    }

    try {
      const operationCenter = getCellText(getImportValue(row, indexes, 'operationCenter'));
      const categoryName = getCellText(getImportValue(row, indexes, 'categoryName'));
      const productName = getCellText(getImportValue(row, indexes, 'productName'));
      const colorSpec = getCellText(getImportValue(row, indexes, 'colorSpec'));

      if (!operationCenter || !categoryName || !productName || !colorSpec) {
        const error = new Error(`第 ${rowNumber} 行缺少必填字段：运营中心、分类、商品名称、颜色及规格`);
        error.status = 400;
        throw error;
      }

      const center = resolveOperationCenter(operationCenter);
      const category = resolveCategory(categoryName);
      let styleCode = getCellText(getImportValue(row, indexes, 'styleCode')).toUpperCase();
      let productCode = getCellText(getImportValue(row, indexes, 'productCode')).toUpperCase();
      let serialNumber = parseImportNumber(getImportValue(row, indexes, 'serialNumber'), `第 ${rowNumber} 行序号`, { min: 1 });

      if (!styleCode && productCode) {
        styleCode = deriveStyleCodeFromProductCode(productCode);
      }

      if (!serialNumber && styleCode) {
        serialNumber = parseSerialFromStyleCode(styleCode);
      }

      if (!serialNumber) {
        const error = new Error(`第 ${rowNumber} 行缺少序号或有效款式编码`);
        error.status = 400;
        throw error;
      }

      const expectedStyleCode = buildStyleCode(center.abbreviation, category.abbreviation, serialNumber);
      if (styleCode && styleCode !== expectedStyleCode) {
        const error = new Error(`第 ${rowNumber} 行款式编码与运营中心、分类、序号不匹配，应为 ${expectedStyleCode}`);
        error.status = 400;
        throw error;
      }
      styleCode = expectedStyleCode;

      if (productCode) {
        const derivedStyleCode = deriveStyleCodeFromProductCode(productCode).toUpperCase();
        if (derivedStyleCode !== expectedStyleCode) {
          const error = new Error(`第 ${rowNumber} 行商品编码与运营中心、分类、序号不匹配，应以 ${expectedStyleCode} 开头`);
          error.status = 400;
          throw error;
        }
        const suffix = Number(productCode.slice(-2));
        if (!Number.isInteger(suffix) || suffix < 1) {
          const error = new Error(`第 ${rowNumber} 行商品编码后两位必须是大于 0 的 SKU 序号`);
          error.status = 400;
          throw error;
        }
      }

      if (!productCode) {
        const currentCount = uploadStyleCounters.get(styleCode) || 0;
        const nextCount = currentCount + 1;
        uploadStyleCounters.set(styleCode, nextCount);
        productCode = buildProductCode(styleCode, nextCount);
        missingProductCodeRows.push({ styleCode, productCode });
      } else {
        const suffix = Number(productCode.slice(-2));
        if (Number.isFinite(suffix) && suffix > (uploadStyleCounters.get(styleCode) || 0)) {
          uploadStyleCounters.set(styleCode, suffix);
        }
      }

      if (seenProductCodes.has(productCode)) {
        const error = new Error(`第 ${rowNumber} 行商品编码 ${productCode} 在文件内重复`);
        error.status = 400;
        throw error;
      }
      seenProductCodes.add(productCode);

      const lengthCm = parseImportNumber(getImportValue(row, indexes, 'lengthCm'), `第 ${rowNumber} 行长`, { min: 0.01 });
      const widthCm = parseImportNumber(getImportValue(row, indexes, 'widthCm'), `第 ${rowNumber} 行宽`, { min: 0.01 });
      const heightCm = parseImportNumber(getImportValue(row, indexes, 'heightCm'), `第 ${rowNumber} 行高`, { min: 0.01 });
      const weight = parseImportNumber(getImportValue(row, indexes, 'weight'), `第 ${rowNumber} 行重量`, { min: 0 });
      const volume = parseImportNumber(getImportValue(row, indexes, 'volume'), `第 ${rowNumber} 行体积`, { min: 0 })
        ?? buildVolume(lengthCm, widthCm, heightCm);
      const currentSequence = parseImportNumber(getImportValue(row, indexes, 'currentSequence'), `第 ${rowNumber} 行目前编写序号`, { min: 0 })
        || serialNumber;

      normalizedRows.push({
        operation_center: center.name,
        center_abbr: center.abbreviation,
        category_abbr: category.abbreviation,
        serial_number: serialNumber,
        current_sequence: currentSequence,
        style_code: styleCode,
        product_code: productCode,
        product_name: productName,
        color_spec: colorSpec,
        brand: getCellText(getImportValue(row, indexes, 'brand')) || FIXED_VALUES.brand,
        category_name: category.name,
        virtual_category: getCellText(getImportValue(row, indexes, 'virtualCategory')) || FIXED_VALUES.virtualCategory,
        product_tag: getCellText(getImportValue(row, indexes, 'productTag')) || FIXED_VALUES.productTag,
        product_status: getCellText(getImportValue(row, indexes, 'productStatus')) || FIXED_VALUES.productStatus,
        inventory_sync: getCellText(getImportValue(row, indexes, 'inventorySync')) || FIXED_VALUES.inventorySync,
        product_attribute: getCellText(getImportValue(row, indexes, 'productAttribute')) || FIXED_VALUES.productAttribute,
        weight,
        length_cm: lengthCm,
        width_cm: widthCm,
        height_cm: heightCm,
        volume,
        unit: getCellText(getImportValue(row, indexes, 'unit')) || FIXED_VALUES.unit,
        other_attr7: getCellText(getImportValue(row, indexes, 'otherAttr7')) || productCode,
        other_attr5: getCellText(getImportValue(row, indexes, 'otherAttr5')) || FIXED_VALUES.otherAttr5,
        created_by_user_id: user.sub || null,
        created_by_username: user.username || '',
        created_by_name: user.name || user.username || '',
        created_department_id: user.departmentId || null,
        created_department_name: user.departmentName || '',
      });
    } catch (error) {
      rowErrors.push({
        excelRowNumber: rowNumber,
        errorMessage: error.message || `第 ${rowNumber} 行导入失败`,
        rowData: headers.reduce((acc, header, index) => {
          acc[header] = getCellText(row[index]);
          return acc;
        }, {}),
      });
    }
  });

  if (rowErrors.length) {
    throw createProductCodeImportValidationError({
      sheetName,
      headers,
      rowErrors,
    });
  }

  if (normalizedRows.length === 0) {
    const error = new Error('导入文件没有可导入的数据行');
    error.status = 400;
    throw error;
  }

  return {
    sheetName,
    headers,
    rows: normalizedRows,
    generatedProductCodeCount: missingProductCodeRows.length,
  };
}

function normalizeBatchImportProducts(buffer) {
  const { sheetName, headers, dataRows } = readBatchImportRows(buffer);
  const indexes = buildBatchImportHeaderIndexes(headers);
  const groupMap = new Map();
  const groupOrder = [];

  dataRows.forEach((row, rowOffset) => {
    const rowNumber = rowOffset + 1;
    const hasValue = row.some((value) => getCellText(value));
    if (!hasValue) {
      return;
    }

    const operationCenter = getCellText(getImportValue(row, indexes, 'operationCenter'));
    if (!operationCenter) {
      const error = new Error(`第 ${rowNumber} 行运营中心不能为空`);
      error.status = 400;
      throw error;
    }
    let center;
    try {
      center = resolveOperationCenter(operationCenter);
    } catch (_error) {
      const error = new Error(`第 ${rowNumber} 行运营中心无效，请使用模板中的选项填写`);
      error.status = 400;
      throw error;
    }

    const categoryName = getCellText(getImportValue(row, indexes, 'categoryName'));
    if (!categoryName) {
      const error = new Error(`第 ${rowNumber} 行分类不能为空`);
      error.status = 400;
      throw error;
    }
    let category;
    try {
      category = resolveCategory(categoryName);
    } catch (_error) {
      const error = new Error(`第 ${rowNumber} 行分类无效，请使用模板中的选项填写`);
      error.status = 400;
      throw error;
    }

    const groupKey = `${center.name}|||${category.name}`;
    if (!groupMap.has(groupKey)) {
      groupMap.set(groupKey, {
        operationCenter: center.name,
        categoryName: category.name,
        productMap: new Map(),
        productOrder: [],
        skuCount: 0,
      });
      groupOrder.push(groupKey);
    }
    const group = groupMap.get(groupKey);

    const productIndex = parseImportNumber(getImportValue(row, indexes, 'productIndex'), `第 ${rowNumber} 行商品序号`, {
      required: true,
      min: 1,
    });
    if (!Number.isInteger(productIndex)) {
      const error = new Error(`第 ${rowNumber} 行商品序号必须是整数`);
      error.status = 400;
      throw error;
    }

    const productName = getCellText(getImportValue(row, indexes, 'productName'));
    if (!productName) {
      const error = new Error(`第 ${rowNumber} 行商品名称不能为空`);
      error.status = 400;
      throw error;
    }

    const colorName = getCellText(getImportValue(row, indexes, 'colorName'));
    if (!colorName) {
      const error = new Error(`第 ${rowNumber} 行颜色不能为空`);
      error.status = 400;
      throw error;
    }

    const skuItem = {
      productName,
      colorName,
      lengthCm: parseImportNumber(getImportValue(row, indexes, 'lengthCm'), `第 ${rowNumber} 行长`, { min: 0.01 }),
      widthCm: parseImportNumber(getImportValue(row, indexes, 'widthCm'), `第 ${rowNumber} 行宽`, { min: 0.01 }),
      heightCm: parseImportNumber(getImportValue(row, indexes, 'heightCm'), `第 ${rowNumber} 行高`, { min: 0.01 }),
      weight: parseImportNumber(getImportValue(row, indexes, 'weight'), `第 ${rowNumber} 行重量`, { min: 0 }),
    };

    if (!group.productMap.has(productIndex)) {
      group.productMap.set(productIndex, {
        skuItems: [],
      });
      group.productOrder.push(productIndex);
    }

    const product = group.productMap.get(productIndex);
    product.skuItems.push(skuItem);
    group.skuCount += 1;
  });

  if (groupOrder.length === 0) {
    const error = new Error('导入文件没有可导入的商品数据');
    error.status = 400;
    throw error;
  }

  let totalProductCount = 0;
  let totalSkuCount = 0;
  const groups = groupOrder.map((groupKey) => {
    const group = groupMap.get(groupKey);
    const products = group.productOrder.map((key) => group.productMap.get(key));

    if (products.length > MAX_BATCH_PRODUCTS) {
      const error = new Error(`${group.operationCenter} / ${group.categoryName} 单次最多批量新增 ${MAX_BATCH_PRODUCTS} 个商品`);
      error.status = 400;
      throw error;
    }

    if (group.skuCount > MAX_BATCH_SKUS) {
      const error = new Error(`${group.operationCenter} / ${group.categoryName} 单次最多批量新增 ${MAX_BATCH_SKUS} 个商品规格`);
      error.status = 400;
      throw error;
    }

    totalProductCount += products.length;
    totalSkuCount += group.skuCount;

    return {
      operationCenter: group.operationCenter,
      categoryName: group.categoryName,
      products,
      productCount: products.length,
      skuCount: group.skuCount,
    };
  });

  return {
    sheetName,
    groups,
    groupCount: groups.length,
    productCount: totalProductCount,
    skuCount: totalSkuCount,
  };
}

async function importProductCodeWorkbook(buffer, user = {}) {
  const { sheetName, rows, generatedProductCodeCount } = normalizeImportedRows(buffer, user);
  const productCodes = rows.map((row) => row.product_code);
  const existingRows = await database.local.query(
    `SELECT product_code AS productCode
     FROM ${PRODUCT_CODE_TABLE}
     WHERE product_code IN (?)`,
    [productCodes]
  );
  const existingSet = new Set(existingRows.map((row) => row.productCode));
  const columns = [
    'operation_center',
    'center_abbr',
    'category_abbr',
    'serial_number',
    'current_sequence',
    'style_code',
    'product_code',
    'product_name',
    'color_spec',
    'brand',
    'category_name',
    'virtual_category',
    'product_tag',
    'product_status',
    'inventory_sync',
    'product_attribute',
    'weight',
    'length_cm',
    'width_cm',
    'height_cm',
    'volume',
    'unit',
    'other_attr7',
    'other_attr5',
    'created_by_user_id',
    'created_by_username',
    'created_by_name',
    'created_department_id',
    'created_department_name',
  ];
  const updateColumns = columns.filter((column) => !column.startsWith('created_by') && column !== 'product_code');
  const placeholders = columns.map(() => '?').join(', ');
  const quotedColumns = columns.map((column) => `\`${column}\``).join(', ');
  const updateClause = updateColumns.map((column) => `\`${column}\` = VALUES(\`${column}\`)`).join(', ');
  const groups = new Set();

  for (const row of rows) {
    await database.local.query(
      `INSERT INTO ${PRODUCT_CODE_TABLE} (${quotedColumns})
       VALUES (${placeholders})
       ON DUPLICATE KEY UPDATE ${updateClause}, updated_at = CURRENT_TIMESTAMP`,
      columns.map((column) => row[column])
    );
    groups.add(`${row.center_abbr}|||${row.category_abbr}`);
  }

  for (const groupKey of groups) {
    const [centerAbbr, categoryAbbr] = groupKey.split('|||');
    await database.local.query(
      `UPDATE ${PRODUCT_CODE_TABLE} target
       JOIN (
         SELECT center_abbr, category_abbr, MAX(serial_number) AS max_serial
         FROM ${PRODUCT_CODE_TABLE}
         WHERE center_abbr = ? AND category_abbr = ?
         GROUP BY center_abbr, category_abbr
       ) seq ON target.center_abbr = seq.center_abbr AND target.category_abbr = seq.category_abbr
       SET target.current_sequence = seq.max_serial
       WHERE target.center_abbr = ? AND target.category_abbr = ?`,
      [centerAbbr, categoryAbbr, centerAbbr, categoryAbbr]
    );
    await syncProductCodeStyleRegistryGroup(centerAbbr, categoryAbbr);
  }

  const updatedCount = rows.filter((row) => existingSet.has(row.product_code)).length;

  return {
    sheetName,
    totalRows: rows.length,
    insertedRows: rows.length - updatedCount,
    updatedRows: updatedCount,
    generatedProductCodeCount,
  };
}

async function importProductCodeBatchWorkbook(buffer, _payload = {}, user = {}) {
  const { sheetName, groups, groupCount, productCount, skuCount } = normalizeBatchImportProducts(buffer);
  const results = [];

  for (const group of groups) {
    const result = await createProductCodeBatch({
      operationCenter: group.operationCenter,
      categoryName: group.categoryName,
      products: group.products,
    }, user);
    results.push({
      operationCenter: group.operationCenter,
      categoryName: group.categoryName,
      productCount: result.productCount,
      skuCount: result.skuCount,
      startSerial: result.startSerial,
      endSerial: result.endSerial,
    });
  }

  return {
    sheetName,
    groupCount,
    importedProductCount: productCount,
    importedSkuCount: skuCount,
    groups: results,
  };
}

async function deleteAllProductCodeItems() {
  const connection = await database.local.pool.getConnection();

  try {
    const [itemSummaryRows] = await connection.query(
      `SELECT
         COUNT(*) AS totalRows,
         COUNT(DISTINCT style_code) AS styleCount
       FROM ${PRODUCT_CODE_TABLE}`
    );
    const [styleSummaryRows] = await connection.query(
      `SELECT COUNT(*) AS totalStyles
       FROM ${PRODUCT_CODE_STYLE_TABLE}`
    );

    await connection.beginTransaction();
    const [itemDeleteResult] = await connection.query(`DELETE FROM ${PRODUCT_CODE_TABLE}`);
    const [styleDeleteResult] = await connection.query(`DELETE FROM ${PRODUCT_CODE_STYLE_TABLE}`);
    await connection.commit();

    return {
      deletedRows: Number(itemDeleteResult.affectedRows || itemSummaryRows[0]?.totalRows || 0),
      deletedStyleRows: Number(styleDeleteResult.affectedRows || styleSummaryRows[0]?.totalStyles || 0),
      totalRows: Number(itemSummaryRows[0]?.totalRows || 0),
      styleCount: Number(itemSummaryRows[0]?.styleCount || 0),
    };
  } catch (error) {
    try {
      await connection.rollback();
    } catch (_rollbackError) {
      // Ignore rollback failures so the original error can be returned.
    }
    throw error;
  } finally {
    connection.release();
  }
}

async function deleteProductCodeItemsByCodes(productCodes = []) {
  const normalizedCodes = Array.from(new Set(
    (Array.isArray(productCodes) ? productCodes : [])
      .map((item) => normalizeString(item))
      .filter(Boolean)
  ));

  if (!normalizedCodes.length) {
    const error = new Error('请选择要删除的商品编码');
    error.status = 400;
    throw error;
  }

  if (normalizedCodes.length > MAX_DELETE_PRODUCT_CODES) {
    const error = new Error(`单次最多删除 ${MAX_DELETE_PRODUCT_CODES} 个商品编码`);
    error.status = 400;
    throw error;
  }

  const connection = await database.local.pool.getConnection();

  try {
    await connection.beginTransaction();

    const [matchedRows] = await connection.query(
      `SELECT id, product_code AS productCode, style_code AS styleCode
       FROM ${PRODUCT_CODE_TABLE}
       WHERE product_code IN (?)
       FOR UPDATE`,
      [normalizedCodes]
    );

    const matchedCodes = matchedRows.map((row) => normalizeString(row.productCode));
    const matchedCodeSet = new Set(matchedCodes);
    const styleCodes = Array.from(new Set(
      matchedRows
        .map((row) => normalizeString(row.styleCode))
        .filter(Boolean)
    ));

    let deletedRows = 0;
    let deletedStyleRows = 0;

    if (matchedCodes.length) {
      const [itemDeleteResult] = await connection.query(
        `DELETE FROM ${PRODUCT_CODE_TABLE}
         WHERE product_code IN (?)`,
        [matchedCodes]
      );
      deletedRows = Number(itemDeleteResult.affectedRows || matchedCodes.length || 0);

      if (styleCodes.length) {
        const [styleDeleteResult] = await connection.query(
          `DELETE registry
           FROM ${PRODUCT_CODE_STYLE_TABLE} registry
           LEFT JOIN ${PRODUCT_CODE_TABLE} items
             ON items.style_code = registry.style_code
           WHERE registry.style_code IN (?)
             AND items.id IS NULL`,
          [styleCodes]
        );
        deletedStyleRows = Number(styleDeleteResult.affectedRows || 0);
      }
    }

    await connection.commit();

    return {
      requestedCodes: normalizedCodes,
      matchedCodes,
      notFoundCodes: normalizedCodes.filter((code) => !matchedCodeSet.has(code)),
      deletedRows,
      deletedStyleRows,
    };
  } catch (error) {
    try {
      await connection.rollback();
    } catch (_rollbackError) {
      // Ignore rollback failures so the original error can be returned.
    }
    throw error;
  } finally {
    connection.release();
  }
}

async function getProductCodeSequence({ operationCenter, categoryName }) {
  const center = resolveOperationCenter(operationCenter);
  const category = resolveCategory(categoryName);
  const rows = await database.local.query(
    `SELECT COALESCE(MAX(serial_number), 0) AS currentSequence
     FROM ${PRODUCT_CODE_TABLE}
     WHERE center_abbr = ? AND category_abbr = ?`,
    [center.abbreviation, category.abbreviation]
  );
  const currentSequence = Number(rows[0]?.currentSequence || 0);
  const nextSerial = currentSequence + 1;
  const styleCode = buildStyleCode(center.abbreviation, category.abbreviation, nextSerial);

  return {
    operationCenter: center.name,
    centerAbbr: center.abbreviation,
    categoryName: category.name,
    categoryAbbr: category.abbreviation,
    currentSequence,
    nextSerial,
    styleCode,
    firstProductCode: buildProductCode(styleCode, 1),
  };
}

async function listProductCodes(filters = {}) {
  const page = parsePositiveInt(filters.page, 1, 100000);
  const pageSize = parsePositiveInt(filters.pageSize, 20, 100);
  const offset = (page - 1) * pageSize;
  const { whereSql, values } = buildWhereClause(filters);

  const rows = await database.local.query(
    `SELECT
       id,
       operation_center AS operationCenter,
       center_abbr AS centerAbbr,
       category_abbr AS categoryAbbr,
       serial_number AS serialNumber,
       current_sequence AS currentSequence,
       style_code AS styleCode,
       product_code AS productCode,
       product_name AS productName,
       color_spec AS colorSpec,
       brand,
       category_name AS categoryName,
       virtual_category AS virtualCategory,
       product_tag AS productTag,
       product_status AS productStatus,
       inventory_sync AS inventorySync,
       product_attribute AS productAttribute,
       weight,
       length_cm AS lengthCm,
       width_cm AS widthCm,
       height_cm AS heightCm,
       volume,
       unit,
       other_attr7 AS otherAttr7,
       other_attr5 AS otherAttr5,
       created_by_name AS createdByName,
       created_at AS createdAt,
       updated_at AS updatedAt
     FROM ${PRODUCT_CODE_TABLE}
     ${whereSql}
     ORDER BY created_at DESC, id DESC
     LIMIT ? OFFSET ?`,
    [...values, pageSize, offset]
  );

  const countRows = await database.local.query(
    `SELECT COUNT(*) AS total FROM ${PRODUCT_CODE_TABLE} ${whereSql}`,
    values
  );

  const summaryRows = await database.local.query(
    `SELECT
       COUNT(*) AS totalRows,
       COUNT(DISTINCT style_code) AS styleCount,
       COUNT(DISTINCT category_name) AS categoryCount,
       COUNT(DISTINCT operation_center) AS centerCount,
       MAX(created_at) AS latestCreatedAt
     FROM ${PRODUCT_CODE_TABLE}`
  );

  return {
    rows: rows.map(mapProductCodeRow),
    total: Number(countRows[0]?.total || 0),
    page,
    pageSize,
    summary: {
      totalRows: Number(summaryRows[0]?.totalRows || 0),
      styleCount: Number(summaryRows[0]?.styleCount || 0),
      categoryCount: Number(summaryRows[0]?.categoryCount || 0),
      centerCount: Number(summaryRows[0]?.centerCount || 0),
      latestCreatedAt: summaryRows[0]?.latestCreatedAt || null,
    },
  };
}

async function buildProductCodeExportBuffer(filters = {}) {
  const rows = await queryProductCodeRows(filters);
  const headerRow = PRODUCT_CODE_EXPORT_COLUMNS.map((column) => column.title);
  const bodyRows = rows.map((row) => PRODUCT_CODE_EXPORT_COLUMNS.map((column) => {
    const value = row[column.key];
    if (column.key === 'createdAt') {
      return formatExportDateTime(value);
    }
    return value === null || value === undefined ? '' : value;
  }));
  const worksheet = xlsx.utils.aoa_to_sheet([headerRow, ...bodyRows]);
  worksheet['!cols'] = PRODUCT_CODE_EXPORT_COLUMNS.map((column) => ({
    wch: Math.max(12, Math.min(28, column.title.length * 2 + 8)),
  }));

  const workbook = xlsx.utils.book_new();
  xlsx.utils.book_append_sheet(workbook, worksheet, '测款数据');
  return {
    buffer: xlsx.write(workbook, { type: 'buffer', bookType: 'xlsx' }),
    totalRows: rows.length,
  };
}

async function createProductCodeBatch(payload = {}, user = {}) {
  const center = resolveOperationCenter(payload.operationCenter);
  const category = resolveCategory(payload.categoryName);
  const products = normalizeCreateProducts(payload);
  const lockName = `product-code:${center.abbreviation}:${category.abbreviation}`;
  const connection = await database.local.pool.getConnection();
  let lockAcquired = false;

  try {
    const [lockRows] = await connection.query('SELECT GET_LOCK(?, 10) AS locked', [lockName]);
    lockAcquired = Number(lockRows[0]?.locked || 0) === 1;
    if (!lockAcquired) {
      const error = new Error('当前分类正在生成编码，请稍后重试');
      error.status = 409;
      throw error;
    }

    await connection.beginTransaction();
    const [sequenceRows] = await connection.query(
      `SELECT COALESCE(MAX(serial_number), 0) AS currentSequence
       FROM ${PRODUCT_CODE_TABLE}
       WHERE center_abbr = ? AND category_abbr = ?`,
      [center.abbreviation, category.abbreviation]
    );
    const currentSequence = Number(sequenceRows[0]?.currentSequence || 0);
    const startSerial = currentSequence + 1;
    const endSerial = currentSequence + products.length;
    const createdProducts = [];
    const createdRows = [];

    for (let productIndex = 0; productIndex < products.length; productIndex += 1) {
      const product = products[productIndex];
      const serialNumber = startSerial + productIndex;
      const styleCode = buildStyleCode(center.abbreviation, category.abbreviation, serialNumber);
      const styleRow = buildProductCodeStyleRow({
        center,
        category,
        serialNumber,
        styleCode,
        user,
      });
      const styleColumns = Object.keys(styleRow);
      const stylePlaceholders = styleColumns.map(() => '?').join(', ');
      const quotedStyleColumns = styleColumns.map((column) => `\`${column}\``).join(', ');
      await connection.query(
        `INSERT INTO ${PRODUCT_CODE_STYLE_TABLE} (${quotedStyleColumns}) VALUES (${stylePlaceholders})`,
        Object.values(styleRow)
      );
      const productRows = [];

      for (let skuIndex = 0; skuIndex < product.skuItems.length; skuIndex += 1) {
        const sku = product.skuItems[skuIndex];
        const productCode = buildProductCode(styleCode, skuIndex + 1);
        const colorSpec = buildColorSpec(sku);
        const rowData = {
          operation_center: center.name,
          center_abbr: center.abbreviation,
          category_abbr: category.abbreviation,
          serial_number: serialNumber,
          current_sequence: endSerial,
          style_code: styleCode,
          product_code: productCode,
          product_name: sku.productName,
          color_spec: colorSpec,
          brand: FIXED_VALUES.brand,
          category_name: category.name,
          virtual_category: FIXED_VALUES.virtualCategory,
          product_tag: FIXED_VALUES.productTag,
          product_status: FIXED_VALUES.productStatus,
          inventory_sync: FIXED_VALUES.inventorySync,
          product_attribute: FIXED_VALUES.productAttribute,
          weight: sku.weight,
          length_cm: sku.lengthCm,
          width_cm: sku.widthCm,
          height_cm: sku.heightCm,
          volume: sku.volume,
          unit: FIXED_VALUES.unit,
          other_attr7: productCode,
          other_attr5: FIXED_VALUES.otherAttr5,
          created_by_user_id: user.sub || null,
          created_by_username: user.username || '',
          created_by_name: user.name || user.username || '',
          created_department_id: user.departmentId || null,
          created_department_name: user.departmentName || '',
        };
        const columns = Object.keys(rowData);
        const placeholders = columns.map(() => '?').join(', ');
        const quotedColumns = columns.map((column) => `\`${column}\``).join(', ');
        const [insertResult] = await connection.query(
          `INSERT INTO ${PRODUCT_CODE_TABLE} (${quotedColumns}) VALUES (${placeholders})`,
          Object.values(rowData)
        );
        const createdRow = {
          id: insertResult.insertId,
          operationCenter: center.name,
          centerAbbr: center.abbreviation,
          categoryAbbr: category.abbreviation,
          serialNumber,
          currentSequence: endSerial,
          styleCode,
          productCode,
          productName: sku.productName,
          colorSpec,
          brand: FIXED_VALUES.brand,
          categoryName: category.name,
          virtualCategory: FIXED_VALUES.virtualCategory,
          productTag: FIXED_VALUES.productTag,
          productStatus: FIXED_VALUES.productStatus,
          inventorySync: FIXED_VALUES.inventorySync,
          productAttribute: FIXED_VALUES.productAttribute,
          weight: sku.weight,
          lengthCm: sku.lengthCm,
          widthCm: sku.widthCm,
          heightCm: sku.heightCm,
          volume: sku.volume,
          unit: FIXED_VALUES.unit,
          otherAttr7: productCode,
          otherAttr5: FIXED_VALUES.otherAttr5,
        };
        productRows.push(createdRow);
        createdRows.push(createdRow);
      }

      createdProducts.push({
        serialNumber,
        styleCode,
        skuCount: productRows.length,
        rows: productRows,
      });
    }

    await connection.query(
      `UPDATE ${PRODUCT_CODE_TABLE}
       SET current_sequence = ?
       WHERE center_abbr = ? AND category_abbr = ?`,
      [endSerial, center.abbreviation, category.abbreviation]
    );

    await connection.commit();

    return {
      currentSequence,
      startSerial,
      endSerial,
      productCount: createdProducts.length,
      skuCount: createdRows.length,
      products: createdProducts,
      rows: createdRows,
    };
  } catch (error) {
    try {
      await connection.rollback();
    } catch (_rollbackError) {
      // Ignore rollback failures so the original error can be returned.
    }
    if (isProductCodeConflictError(error)) {
      const conflictError = new Error('编码已存在或序号已被其它操作占用，请刷新后重试');
      conflictError.status = 409;
      throw conflictError;
    }
    throw error;
  } finally {
    if (lockAcquired) {
      try {
        await connection.query('SELECT RELEASE_LOCK(?)', [lockName]);
      } catch (_releaseError) {
        // MySQL releases named locks when the connection closes; this is best-effort cleanup.
      }
    }
    connection.release();
  }
}

async function createProductCodes(payload = {}, user = {}) {
  const batchResult = await createProductCodeBatch({
    operationCenter: payload.operationCenter,
    categoryName: payload.categoryName,
    products: [{
      productName: payload.productName,
      skuItems: payload.skuItems,
    }],
  }, user);
  const product = batchResult.products[0];

  return {
    currentSequence: batchResult.currentSequence,
    serialNumber: product.serialNumber,
    styleCode: product.styleCode,
    rows: product.rows,
  };
}

module.exports = {
  PRODUCT_CODE_TABLE,
  getProductCodeMeta,
  buildProductCodeImportTemplateBuffer,
  buildProductCodeBatchImportTemplateBuffer,
  buildProductCodeExportBuffer,
  getProductCodeSequence,
  listProductCodes,
  createProductCodes,
  createProductCodeBatch,
  importProductCodeWorkbook,
  importProductCodeBatchWorkbook,
  deleteAllProductCodeItems,
  deleteProductCodeItemsByCodes,
};