/*
  CommonJS runtime for applying translations from Excel to source code.
*/
const path = require('node:path');
const fs = require('node:fs');
const { Project, SyntaxKind, Node } = require('ts-morph');
const XLSX = require('xlsx');

const WORKDIR = process.cwd();
const TRANSLATES_FILE = path.join(WORKDIR, 'scripts', 'translates.xlsx');
const REPORT_FILE = path.join(WORKDIR, 'scripts', 'translation-report.json');
const CONFLICTS_FILE = path.join(WORKDIR, 'scripts', 'translation-conflicts.xlsx');

// 统计信息
const stats = {
  total: 0,
  success: 0,
  conflicts: 0,
  fileNotFound: 0,
  textNotFound: 0,
  multipleMatches: 0
};

// 冲突列表
const conflicts = [];

// 成功替换列表
const successfulReplacements = [];

function loadTranslations() {
  console.log('📖 读取翻译数据...');
  const wb = XLSX.readFile(TRANSLATES_FILE);
  const ws = wb.Sheets[wb.SheetNames[0]];
  const data = XLSX.utils.sheet_to_json(ws, { defval: '' });
  
  // 筛选出需要替换的条目
  let translations = data.filter(row => 
    row.text && 
    row.corrected_text && 
    row.text !== row.corrected_text
  );
  
  // 去重：按 file + line + text 去重，保留第一个
  const seen = new Set();
  translations = translations.filter(row => {
    const key = `${row.file}:${row.line}:${row.text}`;
    if (seen.has(key)) {
      return false;
    }
    seen.add(key);
    return true;
  });
  
  console.log(`📊 找到 ${translations.length} 条需要替换的翻译（已去重）`);
  stats.total = translations.length;
  
  return translations;
}

function groupByFile(translations) {
  const groups = new Map();
  for (const translation of translations) {
    const filePath = path.join(WORKDIR, translation.file);
    if (!groups.has(filePath)) {
      groups.set(filePath, []);
    }
    groups.get(filePath).push(translation);
  }
  return groups;
}

function findTextInNode(node, targetText, kind) {
  if (!node) return null;
  
  // 处理 JSX 文本节点
  if (Node.isJsxText(node)) {
    const text = node.getText().replace(/\s+/g, ' ').trim();
    if (text === targetText) return node;
  }
  
  // 处理字符串字面量
  if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
    const text = node.getLiteralText();
    if (text === targetText) return node;
  }
  
  // 处理 JSX 表达式中的字符串
  if (Node.isJsxExpression(node)) {
    const expr = node.getExpression();
    if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
      const text = expr.getLiteralText();
      if (text === targetText) return node;
    }
  }
  
  return null;
}

function findTextInFile(sourceFile, translation) {
  const { text, line, kind } = translation;
  const matches = [];
  
  sourceFile.forEachDescendant((node) => {
    // 根据 kind 类型进行不同的匹配
    if (kind === 'text') {
      // 查找 JSX 文本节点
      if (Node.isJsxText(node)) {
        const nodeText = node.getText().replace(/\s+/g, ' ').trim();
        if (nodeText === text) {
          matches.push({ node, type: 'jsx-text', line: node.getStartLineNumber() });
        }
      }
      // 查找 JSX 表达式中的字符串
      if (Node.isJsxExpression(node)) {
        const expr = node.getExpression();
        if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
          const nodeText = expr.getLiteralText();
          if (nodeText === text) {
            matches.push({ node: expr, type: 'jsx-expression', line: node.getStartLineNumber() });
          }
        }
      }
    } else if (['placeholder', 'title', 'alt', 'label', 'aria'].includes(kind)) {
      // 查找 JSX 属性
      if (Node.isJsxAttribute(node)) {
        const name = node.getNameNode().getText().toLowerCase();
        const value = getStringFromInitializer(node);
        if (value === text) {
          matches.push({ node, type: 'jsx-attribute', line: node.getStartLineNumber() });
        }
      }
    } else if (['toast', 'dialog', 'error', 'validation'].includes(kind)) {
      // 查找函数调用中的字符串参数
      if (Node.isCallExpression(node)) {
        const args = node.getArguments();
        for (const arg of args) {
          if (Node.isStringLiteral(arg) || Node.isNoSubstitutionTemplateLiteral(arg)) {
            const nodeText = arg.getLiteralText();
            if (nodeText === text) {
              matches.push({ node: arg, type: 'function-arg', line: node.getStartLineNumber() });
            }
          }
        }
      }
    }
  });
  
  return matches;
}

function getStringFromInitializer(attr) {
  const init = attr.getInitializer();
  if (!init) return undefined;
  if (Node.isStringLiteral(init) || Node.isNoSubstitutionTemplateLiteral(init)) {
    return init.getLiteralText();
  }
  if (Node.isJsxExpression(init)) {
    const expr = init.getExpression();
    if (!expr) return undefined;
    if (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr)) {
      return expr.getLiteralText();
    }
  }
  return undefined;
}

function replaceText(node, newText, type) {
  try {
    if (type === 'jsx-text') {
      // JSX 文本节点需要特殊处理，保持空白字符
      const originalText = node.getText();
      const newTextWithWhitespace = originalText.replace(/\S+/g, newText);
      node.replaceWithText(newTextWithWhitespace);
    } else if (type === 'jsx-expression' || type === 'function-arg') {
      // 字符串字面量
      if (Node.isStringLiteral(node)) {
        node.replaceWithText(`"${newText}"`);
      } else if (Node.isNoSubstitutionTemplateLiteral(node)) {
        node.replaceWithText(`\`${newText}\``);
      }
    } else if (type === 'jsx-attribute') {
      // JSX 属性值
      const init = node.getInitializer();
      if (init) {
        if (Node.isStringLiteral(init)) {
          init.replaceWithText(`"${newText}"`);
        } else if (Node.isNoSubstitutionTemplateLiteral(init)) {
          init.replaceWithText(`\`${newText}\``);
        } else if (Node.isJsxExpression(init)) {
          const expr = init.getExpression();
          if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
            if (Node.isStringLiteral(expr)) {
              expr.replaceWithText(`"${newText}"`);
            } else {
              expr.replaceWithText(`\`${newText}\``);
            }
          }
        }
      }
    }
    return true;
  } catch (error) {
    console.error(`❌ 替换失败: ${error.message}`);
    return false;
  }
}

function processFile(filePath, translations) {
  if (!fs.existsSync(filePath)) {
    console.log(`❌ 文件不存在: ${path.relative(WORKDIR, filePath)}`);
    translations.forEach(t => {
      conflicts.push({
        ...t,
        conflictType: 'FILE_NOT_FOUND',
        conflictReason: '文件不存在'
      });
    });
    stats.fileNotFound += translations.length;
    return;
  }

  console.log(`📝 处理文件: ${path.relative(WORKDIR, filePath)}`);
  
  try {
    const project = new Project({ 
      tsConfigFilePath: path.join(WORKDIR, 'tsconfig.json'), 
      skipAddingFilesFromTsConfig: true 
    });
    const sourceFile = project.addSourceFileAtPath(filePath);
    
    for (const translation of translations) {
      const { text, corrected_text, line, kind } = translation;
      
      // 首先在指定行附近查找
      let matches = findTextInFile(sourceFile, translation);
      
      // 如果没找到，在整个文件中搜索
      if (matches.length === 0) {
        matches = findTextInFile(sourceFile, translation);
      }
      
      if (matches.length === 0) {
        conflicts.push({
          ...translation,
          conflictType: 'TEXT_NOT_FOUND_IN_FILE',
          conflictReason: '在文件中找不到匹配的文本'
        });
        stats.textNotFound++;
        continue;
      }
      
      if (matches.length > 1) {
        conflicts.push({
          ...translation,
          conflictType: 'MULTIPLE_MATCHES',
          conflictReason: `找到 ${matches.length} 个匹配项，需要人工确认`
        });
        stats.multipleMatches++;
        continue;
      }
      
      // 执行替换
      const match = matches[0];
      const success = replaceText(match.node, corrected_text, match.type);
      
      if (success) {
        successfulReplacements.push({
          ...translation,
          actualLine: match.line,
          replacementType: match.type
        });
        stats.success++;
        console.log(`✅ 替换成功: "${text}" -> "${corrected_text}" (行 ${match.line})`);
      } else {
        conflicts.push({
          ...translation,
          conflictType: 'REPLACEMENT_FAILED',
          conflictReason: '替换操作失败'
        });
        stats.conflicts++;
      }
    }
    
    // 保存修改后的文件
    sourceFile.saveSync();
    
  } catch (error) {
    console.error(`❌ 处理文件失败: ${filePath}`, error.message);
    translations.forEach(t => {
      conflicts.push({
        ...t,
        conflictType: 'PARSE_ERROR',
        conflictReason: `文件解析失败: ${error.message}`
      });
    });
    stats.conflicts += translations.length;
  }
}

function generateReport() {
  console.log('\n📊 生成报告...');
  
  // 生成成功替换报告
  const report = {
    timestamp: new Date().toISOString(),
    stats,
    successfulReplacements,
    conflicts: conflicts.map(c => ({
      file: c.file,
      line: c.line,
      text: c.text,
      corrected_text: c.corrected_text,
      conflictType: c.conflictType,
      conflictReason: c.conflictReason
    }))
  };
  
  fs.writeFileSync(REPORT_FILE, JSON.stringify(report, null, 2));
  console.log(`📄 成功替换报告已保存: ${REPORT_FILE}`);
  
  // 生成冲突报告 Excel
  if (conflicts.length > 0) {
    const conflictRows = conflicts.map(c => ({
      file: c.file,
      line: c.line,
      text: c.text,
      corrected_text: c.corrected_text,
      conflictType: c.conflictType,
      conflictReason: c.conflictReason,
      route: c.route,
      componentOrFn: c.componentOrFn,
      kind: c.kind,
      keyOrLocator: c.keyOrLocator
    }));
    
    const ws = XLSX.utils.json_to_sheet(conflictRows);
    const wb = XLSX.utils.book_new();
    XLSX.utils.book_append_sheet(wb, ws, 'conflicts');
    XLSX.writeFile(wb, CONFLICTS_FILE);
    console.log(`📄 冲突报告已保存: ${CONFLICTS_FILE}`);
  }
}

function printSummary() {
  console.log('\n📈 处理完成！');
  console.log(`总翻译条目: ${stats.total}`);
  console.log(`✅ 成功替换: ${stats.success}`);
  console.log(`❌ 文件不存在: ${stats.fileNotFound}`);
  console.log(`❌ 文本未找到: ${stats.textNotFound}`);
  console.log(`❌ 多处匹配: ${stats.multipleMatches}`);
  console.log(`❌ 其他冲突: ${stats.conflicts}`);
  console.log(`\n成功率: ${((stats.success / stats.total) * 100).toFixed(1)}%`);
}

async function main() {
  console.log('🚀 开始应用翻译...\n');
  
  try {
    // 1. 读取翻译数据
    const translations = loadTranslations();
    
    // 2. 按文件分组
    const fileGroups = groupByFile(translations);
    
    // 3. 处理每个文件
    for (const [filePath, fileTranslations] of fileGroups) {
      processFile(filePath, fileTranslations);
    }
    
    // 4. 生成报告
    generateReport();
    
    // 5. 打印总结
    printSummary();
    
  } catch (error) {
    console.error('❌ 执行失败:', error);
    process.exitCode = 1;
  }
}

main();