#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const config = require('./config');

/**
 * PostgreSQL到达梦数据库SQL转换器
 */
class PG2DMConverter {
  constructor() {
    this.conversionLog = [];
    this.warnings = [];
    this.stats = {
      dataTypes: 0,
      sequences: 0,
      collates: 0,
      indexes: 0,
      coalesceIndexes: 0
    };
  }

  /**
   * 记录转换日志
   */
  log(message, type = 'INFO') {
    const timestamp = new Date().toISOString();
    this.conversionLog.push({ timestamp, type, message });
    console.log(`[${type}] ${message}`);
  }

  /**
   * 记录警告
   */
  warn(message) {
    this.warnings.push(message);
    this.log(message, 'WARN');
  }

  /**
   * 转换数据类型
   */
  convertDataTypes(sql) {
    let converted = sql;
    
    // 1. 转换基本类型（包括浮点类型和时间戳类型）
    const typePattern = /\b(int8|int4|int2|numeric|bool|float8|float4|float|timestamptz|text|bpchar)\b/gi;
    
    converted = converted.replace(typePattern, (match) => {
      const lowerMatch = match.toLowerCase();
      if (config.dataTypeMapping[lowerMatch]) {
        this.stats.dataTypes++;
        return config.dataTypeMapping[lowerMatch];
      }
      return match;
    });

    // 2. 处理timestamp精度参数
    // PostgreSQL: timestamp(6) 或 timestamp(0)
    // 达梦: TIMESTAMP (不支持精度参数，直接移除)
    converted = converted.replace(/\btimestamp\s*\(\s*\d+\s*\)/gi, (match) => {
      this.log(`移除timestamp精度参数: ${match} -> TIMESTAMP`);
      return `TIMESTAMP`;
    });

    // 3. 移除时区子句
    // PostgreSQL: TIMESTAMP without time zone / TIMESTAMP with time zone
    // 达梦: TIMESTAMP (不支持时区子句)
    converted = converted.replace(/TIMESTAMP\s+(without|with)\s+time\s+zone/gi, 'TIMESTAMP');
    const timezoneMatches = sql.match(/TIMESTAMP\s+(without|with)\s+time\s+zone/gi);
    if (timezoneMatches) {
      this.log(`移除 ${timezoneMatches.length} 个TIMESTAMP时区子句`);
    }

    // 4. 修正DECIMAL精度超出范围
    // 达梦DECIMAL最大精度38位，PostgreSQL可以到1000位
    converted = converted.replace(/DECIMAL\s*\((\d+)\s*,\s*(\d+)\)/gi, (match, precision, scale) => {
      const p = parseInt(precision);
      const s = parseInt(scale);
      if (p > 38) {
        this.warn(`DECIMAL(${p},${s}) 精度超出达梦限制(最大38)，已调整为DECIMAL(38,${s})`);
        return `DECIMAL(38,${s})`;
      }
      return match;
    });

    return converted;
  }

  /**
   * 转换序列为IDENTITY
   */
  convertSequences(sql) {
    let converted = sql;
    
    // 第一步：匹配完整的列定义格式
    // "id" BIGINT NOT NULL DEFAULT nextval(...)
    // 使用更宽松的正则，匹配任意数据类型
    const fullPattern = /"(\w+)"\s+([A-Z]+(?:\([^)]+\))?)\s+NOT\s+NULL\s+DEFAULT\s+nextval\s*\([^)]+\)/gi;
    
    converted = converted.replace(fullPattern, (match, colName, dataType) => {
      this.stats.sequences++;
      this.log(`转换列定义: ${colName} ${dataType} -> IDENTITY(1,1)`);
      return `"${colName}" ${dataType} IDENTITY(1, 1) NOT NULL`;
    });

    // 第二步：处理其他格式，直接移除 DEFAULT nextval(...)
    const defaultPattern = /DEFAULT\s+nextval\s*\([^)]+\)/gi;
    
    converted = converted.replace(defaultPattern, (match) => {
      this.stats.sequences++;
      this.log(`移除序列DEFAULT: ${match.substring(0, 50)}...`);
      return 'IDENTITY(1, 1)';
    });

    return converted;
  }

  /**
   * 移除COLLATE子句
   */
  removeCollate(sql) {
    let converted = sql;
    
    // 匹配所有COLLATE格式
    // COLLATE "pg_catalog"."default"
    // COLLATE "default"
    // COLLATE pg_catalog."default"
    const collatePattern1 = /COLLATE\s+"pg_catalog"\."[^"]+"/gi;
    const collatePattern2 = /COLLATE\s+"[^"]+"/gi;
    const collatePattern3 = /COLLATE\s+\w+/gi;
    
    let totalMatches = 0;
    
    const matches1 = sql.match(collatePattern1);
    if (matches1) totalMatches += matches1.length;
    
    const matches2 = sql.match(collatePattern2);
    if (matches2) totalMatches += matches2.length;
    
    if (totalMatches > 0) {
      this.stats.collates += totalMatches;
      this.log(`移除 ${totalMatches} 个COLLATE子句`);
    }

    // 按顺序移除，先移除复杂的，再移除简单的
    converted = converted.replace(collatePattern1, '');
    converted = converted.replace(collatePattern2, '');
    converted = converted.replace(collatePattern3, '');
    
    return converted;
  }

  /**
   * 移除PostgreSQL类型转换语法
   */
  removeTypeCasts(sql) {
    let converted = sql;
    
    // 移除 ::type 语法
    const typeCastPattern = /::(character\s+varying|varchar|text|integer|bigint|smallint|numeric|decimal|timestamp|date|time|boolean|regclass)/gi;
    
    const matches = sql.match(typeCastPattern);
    if (matches) {
      this.log(`移除 ${matches.length} 个PostgreSQL类型转换`);
    }
    
    converted = converted.replace(typeCastPattern, '');
    return converted;
  }

  /**
   * 移除pg_catalog模式前缀和数据类型引号
   */
  removePgCatalog(sql) {
    let converted = sql;
    
    // 移除 "pg_catalog". 前缀
    const catalogPattern = /"pg_catalog"\./gi;
    
    const matches = sql.match(catalogPattern);
    if (matches) {
      this.log(`移除 ${matches.length} 个pg_catalog前缀`);
    }
    
    converted = converted.replace(catalogPattern, '');
    
    // 转换PostgreSQL布尔值为达梦格式（在移除引号之前）
    converted = converted.replace(/\bDEFAULT\s+false\b/gi, 'DEFAULT 0');
    converted = converted.replace(/\bDEFAULT\s+true\b/gi, 'DEFAULT 1');
    
    return converted;
  }

  /**
   * 移除数据类型的引号
   */
  removeTypeQuotes(sql) {
    let converted = sql;
    
    // 移除引号中的数据类型（达梦不需要给类型加引号）
    // 1. 先处理带括号的类型：VARCHAR(8000), DECIMAL(20,6), CHAR(10)等
    converted = converted.replace(/\s"(VARCHAR|CHAR|DECIMAL|NUMERIC)\s*\([^)]+\)"\s/gi, ' $1 ');
    converted = converted.replace(/\s"(VARCHAR|CHAR|DECIMAL|NUMERIC)\s*\([^)]+\)"([,\n\r])/gi, ' $1$2');
    
    // 2. 再处理简单类型（包括不带长度的CHAR）
    converted = converted.replace(/\s"(BIGINT|INT|SMALLINT|TINYINT|VARCHAR|CHAR|TEXT|DATE|TIME|TIMESTAMP|BIT|BOOLEAN|BOOL|BLOB|CLOB|DOUBLE|REAL)"\s/gi, ' $1 ');
    converted = converted.replace(/\s"(BIGINT|INT|SMALLINT|TINYINT|VARCHAR|CHAR|TEXT|DATE|TIME|TIMESTAMP|BIT|BOOLEAN|BOOL|BLOB|CLOB|DOUBLE|REAL)"([,\n\r])/gi, ' $1$2');
    
    this.log('移除数据类型引号');
    
    return converted;
  }

  /**
   * 移除空的或不完整的PARTITION BY子句
   */
  removeEmptyPartition(sql) {
    let converted = sql;
    let removedCount = 0;
    
    // 1. 移除 PARTITION BY LIST (column) 后面没有具体分区的情况
    // 格式: )\nPARTITION BY LIST (\n  "column"\n)\n;
    const listPattern = /\)\s*PARTITION\s+BY\s+LIST\s*\([^)]+\)\s*;/gi;
    const listMatches = converted.match(listPattern);
    if (listMatches) {
      converted = converted.replace(listPattern, ');');
      removedCount += listMatches.length;
      this.log(`移除 ${listMatches.length} 个空的PARTITION BY LIST子句`);
    }
    
    // 2. 移除 PARTITION BY RANGE (column) 后面没有具体分区的情况
    const rangePattern = /\)\s*PARTITION\s+BY\s+RANGE\s*\([^)]+\)\s*;/gi;
    const rangeMatches = converted.match(rangePattern);
    if (rangeMatches) {
      converted = converted.replace(rangePattern, ');');
      removedCount += rangeMatches.length;
      this.log(`移除 ${rangeMatches.length} 个空的PARTITION BY RANGE子句`);
    }
    
    // 3. 移除 PARTITION BY HASH (column) 后面没有具体分区的情况
    const hashPattern = /\)\s*PARTITION\s+BY\s+HASH\s*\([^)]+\)\s*;/gi;
    const hashMatches = converted.match(hashPattern);
    if (hashMatches) {
      converted = converted.replace(hashPattern, ');');
      removedCount += hashMatches.length;
      this.log(`移除 ${hashMatches.length} 个空的PARTITION BY HASH子句`);
    }
    
    // 4. 移除空括号的PARTITION BY
    converted = converted.replace(/\)\s*PARTITION\s+BY\s+\([^)]*\)\s*;/gi, ');\n');
    
    if (removedCount > 0) {
      this.log(`总共移除 ${removedCount} 个空的PARTITION BY子句`);
    }
    
    return converted;
  }

  /**
   * 移除所有COMMENT语句（达梦不支持COMMENT ON语法）
   */
  removeIndexComments(sql) {
    let converted = sql;
    let totalRemoved = 0;
    
    // 1. 移除 COMMENT ON COLUMN
    const columnPattern = /COMMENT\s+ON\s+COLUMN\s+"[^"]+"\."[^"]+"\."[^"]+"\s+IS\s+'[^']*'\s*;/gi;
    const columnMatches = sql.match(columnPattern);
    if (columnMatches) {
      converted = converted.replace(columnPattern, '');
      totalRemoved += columnMatches.length;
      this.log(`移除 ${columnMatches.length} 个列注释`);
    }
    
    // 2. 移除 COMMENT ON TABLE
    const tablePattern = /COMMENT\s+ON\s+TABLE\s+"[^"]+"\."[^"]+"\s+IS\s+'[^']*'\s*;/gi;
    const tableMatches = converted.match(tablePattern);
    if (tableMatches) {
      converted = converted.replace(tablePattern, '');
      totalRemoved += tableMatches.length;
      this.log(`移除 ${tableMatches.length} 个表注释`);
    }
    
    // 3. 移除 COMMENT ON INDEX
    const indexPattern = /COMMENT\s+ON\s+INDEX\s+"[^"]+"\."[^"]+"\s+IS\s+'[^']*'\s*;/gi;
    const indexMatches = converted.match(indexPattern);
    if (indexMatches) {
      converted = converted.replace(indexPattern, '');
      totalRemoved += indexMatches.length;
      this.log(`移除 ${indexMatches.length} 个索引注释`);
    }
    
    if (totalRemoved > 0) {
      this.log(`总共移除 ${totalRemoved} 个COMMENT语句（达梦不支持）`);
      // 清理可能产生的多余空行
      converted = converted.replace(/\n\n\n+/g, '\n\n');
    }
    
    return converted;
  }

  /**
   * 移除分区附加语句（达梦不支持ATTACH PARTITION）
   */
  removeAttachPartition(sql) {
    let converted = sql;
    
    // 匹配 ALTER TABLE ... ATTACH PARTITION ... FOR VALUES ...;
    const attachPattern = /ALTER\s+TABLE\s+"[^"]+"\."[^"]+"\s+ATTACH\s+PARTITION\s+"[^"]+"\."[^"]+"\s+FOR\s+VALUES[^;]*;/gi;
    
    const matches = sql.match(attachPattern);
    if (matches) {
      this.log(`移除 ${matches.length} 个ATTACH PARTITION语句（达梦不支持）`);
      converted = converted.replace(attachPattern, '');
      
      // 清理多余空行
      converted = converted.replace(/\n\n\n+/g, '\n\n');
    }
    
    return converted;
  }

  /**
   * 移除与主键约束同名的唯一索引
   * PostgreSQL导出时会同时包含索引和约束，但在达梦中会冲突
   */
  removeDuplicatePrimaryKeyIndexes(sql) {
    let converted = sql;
    let removedCount = 0;
    
    // 1. 提取所有主键约束的名称
    const pkConstraintPattern = /ADD\s+CONSTRAINT\s+"([^"]+)"\s+PRIMARY\s+KEY/gi;
    const constraintNames = new Set();
    
    let match;
    while ((match = pkConstraintPattern.exec(sql)) !== null) {
      constraintNames.add(match[1]);
    }
    
    if (constraintNames.size === 0) {
      return converted;
    }
    
    // 2. 移除与这些约束同名的UNIQUE INDEX
    constraintNames.forEach(constraintName => {
      // 匹配: CREATE UNIQUE INDEX "constraint_name" ON ...;
      const indexPattern = new RegExp(
        `CREATE\\s+UNIQUE\\s+INDEX\\s+"${constraintName}"\\s+ON\\s+[^;]+;`,
        'gi'
      );
      
      const indexMatches = converted.match(indexPattern);
      if (indexMatches) {
        converted = converted.replace(indexPattern, '');
        removedCount += indexMatches.length;
        this.log(`移除与主键约束同名的唯一索引: ${constraintName}`);
      }
    });
    
    if (removedCount > 0) {
      this.log(`总共移除 ${removedCount} 个与主键同名的唯一索引`);
      // 清理多余空行
      converted = converted.replace(/\n\n\n+/g, '\n\n');
    }
    
    return converted;
  }

  /**
   * 简化索引语法
   */
  simplifyIndexSyntax(sql) {
    let converted = sql;

    // 移除USING btree/hash/gist等
    converted = converted.replace(/USING\s+\w+/gi, '');

    // 移除操作符类 "pg_catalog"."text_ops" 或 "text_ops"
    // 包括各种格式：int8_ops, text_ops, varchar_ops等
    converted = converted.replace(/"pg_catalog"\."[^"]+_ops"/gi, '');
    converted = converted.replace(/\s+"[^"]+_ops"/gi, '');

    // 移除NULLS LAST/FIRST（在移除ASC/DESC之前）
    converted = converted.replace(/\s+NULLS\s+(FIRST|LAST)/gi, '');

    // 移除ASC/DESC（如果需要保留可以注释掉）
    // converted = converted.replace(/\s+(ASC|DESC)/gi, '');

    this.stats.indexes++;
    return converted;
  }

  /**
   * 移除索引中的重复列
   */
  removeDuplicateIndexColumns(sql) {
    let converted = sql;
    
    // 匹配CREATE INDEX语句
    const indexPattern = /(CREATE\s+(?:UNIQUE\s+)?INDEX\s+"[^"]+"\s+ON\s+"[^"]+"\."[^"]+"\s*\()([\s\S]*?)(\);)/gi;
    
    converted = converted.replace(indexPattern, (match, prefix, columns, suffix) => {
      // 解析列定义
      const columnList = columns.split(',').map(col => col.trim());
      const seen = new Set();
      const uniqueColumns = [];
      
      columnList.forEach(col => {
        // 提取列名（去除ASC/DESC等）
        const colNameMatch = col.match(/"(\w+)"/);
        if (colNameMatch) {
          const colName = colNameMatch[1].toLowerCase();
          if (!seen.has(colName)) {
            seen.add(colName);
            uniqueColumns.push(col);
          } else {
            this.warn(`索引中发现重复列: ${colNameMatch[1]}，已自动移除重复项`);
          }
        } else {
          // COALESCE等表达式，直接保留
          uniqueColumns.push(col);
        }
      });
      
      return prefix + '\n  ' + uniqueColumns.join(',\n  ') + '\n' + suffix;
    });
    
    return converted;
  }

  /**
   * 处理COALESCE函数索引
   */
  processCoalesceIndexes(sql) {
    let converted = sql;
    
    // 第一步：移除PostgreSQL类型转换语法 ::type
    converted = converted.replace(/::(character\s+varying|varchar|text|integer|bigint|smallint)/gi, '');
    
    // 第二步：处理COALESCE函数索引
    const coalesceIndexPattern = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+"([^"]+)"\s+ON\s+"[^"]+"\."[^"]+"\s*\(([\s\S]*?)\);/gi;

    converted = converted.replace(coalesceIndexPattern, (match, indexName, columns) => {
      const coalesceCount = (columns.match(/COALESCE\s*\(/gi) || []).length;
      
      if (coalesceCount > 0) {
        this.stats.coalesceIndexes++;
        
        if (coalesceCount > config.coalesceThreshold) {
          this.warn(
            `索引 ${indexName} 包含 ${coalesceCount} 个COALESCE函数，可能超过达梦816字符限制，已自动简化`
          );
        } else {
          this.log(`处理索引 ${indexName} 中的 ${coalesceCount} 个COALESCE函数`);
        }

        // 移除COALESCE，保留原始列名
        // 匹配多种格式: 
        // COALESCE("col_name", '-999')
        // COALESCE(col_name, '-999')
        let simplifiedColumns = columns.replace(
          /COALESCE\s*\(\s*"?(\w+)"?\s*,\s*'[^']+'\s*\)/gi,
          '"$1"'
        );
        
        // 移除多余的空格和换行
        simplifiedColumns = simplifiedColumns.replace(/\s+/g, ' ').trim();

        return match.replace(columns, simplifiedColumns);
      }

      return match;
    });

    return converted;
  }

  /**
   * 添加转换说明注释
   */
  addConversionHeader(sql, originalFile) {
    const header = `/*
 Converted to DaMeng SQL by pg2dm-converter

 Source File          : ${path.basename(originalFile)}
 Source Server Type   : PostgreSQL
 Target Server Type   : DaMeng 8
 Conversion Date      : ${new Date().toLocaleString('zh-CN')}
 
 Conversion Summary:
 - Data Types Converted: ${this.stats.dataTypes}
 - Sequences -> IDENTITY: ${this.stats.sequences}
 - COLLATE Clauses Removed: ${this.stats.collates}
 - Indexes Simplified: ${this.stats.indexes}
 - COALESCE Indexes Processed: ${this.stats.coalesceIndexes}
*/

`;
    return header + sql;
  }

  /**
   * 主转换方法
   */
  convert(sql, originalFile = 'input.sql') {
    this.log('开始转换PostgreSQL SQL到达梦语法');

    let converted = sql;

    // 1. 移除pg_catalog模式前缀（必须在最前面）
    this.log('步骤1: 移除pg_catalog模式前缀...');
    converted = this.removePgCatalog(converted);

    // 2. 转换数据类型
    this.log('步骤2: 转换数据类型...');
    converted = this.convertDataTypes(converted);

    // 3. 转换序列为IDENTITY
    this.log('步骤3: 转换序列为IDENTITY...');
    converted = this.convertSequences(converted);

    // 4. 移除PostgreSQL类型转换
    this.log('步骤4: 移除PostgreSQL类型转换...');
    converted = this.removeTypeCasts(converted);

    // 5. 移除COLLATE子句
    this.log('步骤5: 移除COLLATE子句...');
    converted = this.removeCollate(converted);

    // 6. 移除数据类型引号
    this.log('步骤6: 移除数据类型引号...');
    converted = this.removeTypeQuotes(converted);

    // 7. 移除空的PARTITION BY子句
    this.log('步骤7: 移除空的PARTITION BY子句...');
    converted = this.removeEmptyPartition(converted);

    // 8. 简化索引语法
    this.log('步骤8: 简化索引语法...');
    converted = this.simplifyIndexSyntax(converted);

    // 9. 移除索引中的重复列
    this.log('步骤9: 移除索引中的重复列...');
    converted = this.removeDuplicateIndexColumns(converted);

    // 10. 处理COALESCE函数索引
    this.log('步骤10: 处理COALESCE函数索引...');
    converted = this.processCoalesceIndexes(converted);

    // 11. 移除索引注释（达梦不支持COMMENT ON INDEX）
    this.log('步骤11: 移除索引注释...');
    converted = this.removeIndexComments(converted);

    // 12. 移除分区附加语句（达梦不支持ATTACH PARTITION）
    this.log('步骤12: 移除分区附加语句...');
    converted = this.removeAttachPartition(converted);

    // 13. 移除与主键约束同名的唯一索引（避免冲突）
    this.log('步骤13: 移除与主键约束同名的唯一索引...');
    converted = this.removeDuplicatePrimaryKeyIndexes(converted);

    // 14. 添加转换说明
    if (config.output.addConversionComment) {
      converted = this.addConversionHeader(converted, originalFile);
    }

    this.log('转换完成！');
    return converted;
  }

  /**
   * 生成转换日志文件
   */
  generateLogFile(outputPath) {
    const logContent = {
      timestamp: new Date().toISOString(),
      stats: this.stats,
      warnings: this.warnings,
      logs: this.conversionLog
    };

    const logFile = outputPath.replace('.sql', '_conversion.log.json');
    fs.writeFileSync(logFile, JSON.stringify(logContent, null, 2));
    this.log(`转换日志已保存: ${logFile}`);
  }
}

/**
 * 确保目录存在
 */
function ensureDir(dirPath) {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
  }
}

/**
 * 转换单个文件
 */
function convertSingleFile(inputFile, outputFile) {
  // 读取输入文件
  console.log(`\n读取文件: ${inputFile}`);
  const sqlContent = fs.readFileSync(inputFile, 'utf8');

  // 转换
  const converter = new PG2DMConverter();
  const convertedSql = converter.convert(sqlContent, inputFile);

  // 确定输出文件路径
  if (!outputFile) {
    outputFile = path.join(
      './output',
      path.basename(inputFile, '.sql') + '_dm.sql'
    );
  }

  // 写入输出文件
  ensureDir(path.dirname(outputFile));
  fs.writeFileSync(outputFile, convertedSql, 'utf8');
  console.log(`✓ 转换完成: ${outputFile}`);

  // 生成日志
  if (config.output.generateLog) {
    converter.generateLogFile(outputFile);
  }

  // 显示警告
  if (converter.warnings.length > 0) {
    console.log('⚠ 警告信息:');
    converter.warnings.forEach((warn, i) => {
      console.log(`  ${i + 1}. ${warn}`);
    });
  }

  // 显示统计
  console.log('转换统计:');
  console.log(`  - 数据类型转换: ${converter.stats.dataTypes}`);
  console.log(`  - 序列转IDENTITY: ${converter.stats.sequences}`);
  console.log(`  - COLLATE移除: ${converter.stats.collates}`);
  console.log(`  - 索引简化: ${converter.stats.indexes}`);
  console.log(`  - COALESCE索引处理: ${converter.stats.coalesceIndexes}`);

  return { success: true, warnings: converter.warnings.length };
}

/**
 * 批量转换目录下所有SQL文件
 */
function batchConvert(inputDir) {
  console.log(`\n📁 批量转换目录: ${inputDir}`);
  console.log('='.repeat(50));

  // 读取目录下所有.sql文件
  const files = fs.readdirSync(inputDir)
    .filter(file => file.toLowerCase().endsWith('.sql'))
    .map(file => path.join(inputDir, file));

  if (files.length === 0) {
    console.log(`\n⚠ 目录中没有找到.sql文件: ${inputDir}`);
    return;
  }

  console.log(`\n找到 ${files.length} 个SQL文件`);

  let successCount = 0;
  let failCount = 0;
  let totalWarnings = 0;

  // 逐个转换
  files.forEach((file, index) => {
    try {
      console.log(`\n[${index + 1}/${files.length}] 处理: ${path.basename(file)}`);
      console.log('-'.repeat(50));
      
      const result = convertSingleFile(file, null);
      successCount++;
      totalWarnings += result.warnings;
    } catch (error) {
      console.error(`✗ 转换失败: ${error.message}`);
      failCount++;
    }
  });

  // 显示总结
  console.log('\n' + '='.repeat(50));
  console.log('📊 批量转换完成');
  console.log('='.repeat(50));
  console.log(`✓ 成功: ${successCount} 个文件`);
  if (failCount > 0) {
    console.log(`✗ 失败: ${failCount} 个文件`);
  }
  if (totalWarnings > 0) {
    console.log(`⚠ 总警告: ${totalWarnings} 条`);
  }
  console.log(`📂 输出目录: ./output`);
}

/**
 * 主函数
 */
function main() {
  const args = process.argv.slice(2);
  
  // 确保input和output目录存在
  ensureDir('./input');
  ensureDir('./output');

  // 无参数：批量处理input目录
  if (args.length === 0) {
    if (fs.existsSync('./input')) {
      batchConvert('./input');
    } else {
      console.log(`
PostgreSQL到达梦数据库SQL转换器
======================================

使用方法:
  node converter.js                           # 批量转换input目录下所有.sql文件
  node converter.js <input-file.sql>          # 转换单个文件
  node converter.js <input-dir>               # 批量转换指定目录
  node converter.js <input-file> <output>     # 指定输出文件

示例:
  node converter.js                           # 批量转换input/*.sql
  node converter.js input/schema.sql          # 转换单个文件
  node converter.js ./mydata                  # 批量转换mydata目录
  node converter.js input/schema.sql output/schema_dm.sql

说明:
  - 批量模式会自动在output目录生成 *_dm.sql 文件
  - 会自动生成转换日志文件 *_conversion.log.json
  - 批量模式会显示详细的进度和统计信息
      `);
    }
    return;
  }

  const inputPath = args[0];
  
  // 检查路径是否存在
  if (!fs.existsSync(inputPath)) {
    console.error(`✗ 错误: 路径不存在: ${inputPath}`);
    process.exit(1);
  }

  // 检查是文件还是目录
  const stat = fs.statSync(inputPath);
  
  if (stat.isDirectory()) {
    // 批量转换目录
    batchConvert(inputPath);
  } else if (stat.isFile()) {
    // 单个文件转换
    const outputFile = args[1];
    try {
      convertSingleFile(inputPath, outputFile);
      console.log('\n✓ 转换成功！');
    } catch (error) {
      console.error(`\n✗ 转换失败: ${error.message}`);
      console.error(error.stack);
      process.exit(1);
    }
  } else {
    console.error(`✗ 错误: 不支持的路径类型: ${inputPath}`);
    process.exit(1);
  }
}

// 运行主函数
if (require.main === module) {
  main();
}

module.exports = PG2DMConverter;