// 测试修复后的 {remark} 替换逻辑
console.log('=== 测试修复后的 {remark} 替换逻辑 ===\n');

// 模拟数据库中的模板（实际配置）
const databaseTemplate = `订单号: {orderNo}
时间: {orderTime}
商品: {goodsList}
合计: {totalAmount}
备注1: {remark}
收货人姓名: {receiverName}
地址: {address}
联系电话: {phone}`;

// 模拟打印内容中的模板（实际打印出来的）
const printedTemplate = `订单号: {orderNo}
时间: {orderTime}
商品: {goodsList}
合计: {payAmount}
备注: {remark}
收货人姓名: {receiverName}
地址: {address}
联系电话: {receiverPhone}`;

// 模拟变量
const variables = {
  orderNo: 'ORD20251210112844577127',
  orderTime: '2025-12-10 19:28:44',
  goodsList: '洗护产品6 × 1 = ¥0.01',
  totalAmount: '¥0.01',
  payAmount: '¥0.01',
  remark: '测试备注',
  receiverName: '1',
  address: '1',
  phone: '13100000000',
  receiverPhone: '13100000000'
};

// 修复后的替换逻辑
function robustReplace(template, variables, tenantId = 1) {
  let content = template;
  console.log(`[租户${tenantId}] 模板变量替换前:`, {
    templateContainsRemark: template.includes('{remark}'),
    templatePreview: template.substring(0, 100) + (template.length > 100 ? '...' : '')
  });

  // 使用更健壮的替换方法，处理各种格式的占位符
  for (const [key, value] of Object.entries(variables)) {
    // 处理多种格式的占位符：{key}、{ key }、{{key}}等
    const patterns = [
      `{${key}}`,           // 标准格式
      `{ ${key} }`,         // 有空格
      `{{${key}}}`,         // 双大括号
      `{{ ${key} }}`,       // 双大括号有空格
      `{${key} }`,          // 右空格
      `{ ${key}}`,          // 左空格
    ];

    for (const pattern of patterns) {
      if (content.includes(pattern)) {
        content = content.split(pattern).join(value);
        console.log(`[租户${tenantId}] 替换变量 ${key} (模式: ${pattern}): ${value}`);
      }
    }
  }

  // 清理未替换的变量（特别是remark）
  // 使用正则表达式匹配各种格式的{remark}
  const remarkPatterns = [
    /\{remark\}/g,
    /\{\s*remark\s*\}/g,
    /\{\{remark\}\}/g,
    /\{\{\s*remark\s*\}\}/g,
  ];

  let hasUnreplacedRemark = false;
  for (const pattern of remarkPatterns) {
    if (pattern.test(content)) {
      hasUnreplacedRemark = true;
      console.log(`[租户${tenantId}] 模板中仍有未替换的remark占位符(模式: ${pattern.source})，使用默认值替换`);
      content = content.replace(pattern, variables.remark || '无备注');
    }
  }

  // 记录是否有未替换的remark
  if (hasUnreplacedRemark) {
    console.log(`[租户${tenantId}] 清理了未替换的remark占位符`);
  }

  console.log(`[租户${tenantId}] 模板变量替换后，是否还有{remark}:`, content.includes('{remark}') || content.includes('{ remark }'));

  return content;
}

// 测试1: 数据库模板
console.log('\n=== 测试1: 数据库模板 (备注1: {remark}) ===');
const result1 = robustReplace(databaseTemplate, variables);
console.log('\n替换结果:');
console.log(result1);

// 测试2: 打印模板
console.log('\n\n=== 测试2: 打印模板 (备注: {remark}) ===');
const result2 = robustReplace(printedTemplate, variables);
console.log('\n替换结果:');
console.log(result2);

// 测试3: 空备注
console.log('\n\n=== 测试3: 空备注测试 ===');
const emptyVariables = {
  ...variables,
  remark: null
};
const result3 = robustReplace(printedTemplate, emptyVariables);
console.log('\n替换结果:');
console.log(result3);

// 测试4: 有空格的情况
console.log('\n\n=== 测试4: 有空格的情况 ===');
const spacedTemplate = `订单号: { orderNo }
时间: {orderTime }
商品: { goodsList }
合计: {totalAmount }
备注: { remark }
收货人姓名: {receiverName}
地址: { address }
联系电话: { phone }`;
const result4 = robustReplace(spacedTemplate, variables);
console.log('\n替换结果:');
console.log(result4);

// 测试5: 双大括号情况
console.log('\n\n=== 测试5: 双大括号情况 ===');
const doubleBraceTemplate = `订单号: {{orderNo}}
时间: {{orderTime}}
商品: {{goodsList}}
合计: {{totalAmount}}
备注: {{remark}}
收货人姓名: {{receiverName}}
地址: {{address}}
联系电话: {{phone}}`;
const result5 = robustReplace(doubleBraceTemplate, variables);
console.log('\n替换结果:');
console.log(result5);