const { spawn, exec, execFile } = require('child_process');
const path = require('path');
const fs = require('fs');

/**
 * Java 运行器 - 用于调用便携式 JRE 运行 Java 程序
 */
class JavaRunner {
  constructor() {
    // 在开发与打包后均可解析到应用根目录下的 jre 目录
    // 开发环境：项目根目录
    // 打包后：应用根目录（最终交付目录）
    const isDev = !process.resourcesPath;
    const baseDir = isDev 
      ? path.join(__dirname, '..') 
      : path.dirname(process.resourcesPath);
    this.baseDir = baseDir;
    this.jrePath = path.join(baseDir, 'jre');
    this.binPath = path.join(this.jrePath, 'bin');
    this.javaExe = path.join(this.binPath, 'java.exe');
    this.javaRuntimeDir = path.join(this.baseDir, 'java');
    this.processRecordPath = path.join(this.javaRuntimeDir, '.running-process.json');
  }

  normalizeComparablePath(target = '') {
    return String(target).replace(/"/g, '').replace(/\//g, '\\').toLowerCase();
  }

  execFileCommand(command, args = []) {
    return new Promise((resolve, reject) => {
      execFile(command, args, { encoding: 'utf8', windowsHide: true }, (error, stdout, stderr) => {
        if (error) {
          const err = new Error(error.message || stderr || stdout || 'Command execution failed');
          err.code = error.code;
          err.stdout = stdout;
          err.stderr = stderr;
          reject(err);
        } else {
          resolve({ stdout, stderr });
        }
      });
    });
  }

  getRecordedJavaProcess() {
    try {
      if (!fs.existsSync(this.processRecordPath)) {
        return null;
      }
      return JSON.parse(fs.readFileSync(this.processRecordPath, 'utf-8'));
    } catch (error) {
      console.warn('[Java] Failed to read process record:', error);
      return null;
    }
  }

  recordJavaProcess(record = {}) {
    try {
      fs.mkdirSync(this.javaRuntimeDir, { recursive: true });
      fs.writeFileSync(this.processRecordPath, JSON.stringify(record, null, 2), 'utf-8');
    } catch (error) {
      console.warn('[Java] Failed to record process metadata:', error);
    }
  }

  cleanupJavaProcessRecord() {
    try {
      if (fs.existsSync(this.processRecordPath)) {
        fs.unlinkSync(this.processRecordPath);
      }
    } catch (error) {
      console.warn('[Java] Failed to cleanup process record:', error);
    }
  }

  async getProcessInfoByPid(pid) {
    if (!pid) {
      return null;
    }

    try {
      const script = `$proc = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($proc) { [PSCustomObject]@{ executablePath = $proc.ExecutablePath; commandLine = $proc.CommandLine; name = $proc.Name } | ConvertTo-Json -Compress }`;
      const { stdout } = await this.execFileCommand('powershell.exe', ['-NoProfile', '-Command', script]);
      const raw = (stdout || '').trim();
      return raw ? JSON.parse(raw) : null;
    } catch (error) {
      return null;
    }
  }

  async isOwnJavaProcess(pid, record = this.getRecordedJavaProcess()) {
    const processInfo = await this.getProcessInfoByPid(pid);
    if (!processInfo) {
      return false;
    }

    const executablePath = this.normalizeComparablePath(processInfo.executablePath);
    const commandLine = this.normalizeComparablePath(processInfo.commandLine);
    const expectedJavaExe = this.normalizeComparablePath(this.javaExe);
    const expectedJarPath = this.normalizeComparablePath((record && record.jarPath) || this.currentJarPath || '');

    if (executablePath !== expectedJavaExe) {
      return false;
    }

    if (!expectedJarPath) {
      return true;
    }

    // 关键校验：仅当命令行仍指向当前应用自己的 JAR 时，才允许清理。
    return commandLine.includes(expectedJarPath);
  }

  async findPidsByPort(port) {
    return new Promise(resolve => {
      exec(`netstat -ano | findstr :${port}`, (error, stdout) => {
        if (error || !stdout) {
          resolve([]);
          return;
        }

        const pids = new Set();
        stdout.trim().split('\n').forEach(line => {
          const parts = line.trim().split(/\s+/);
          const pid = parts[parts.length - 1];
          if (pid && pid !== '0') {
            pids.add(Number(pid));
          }
        });

        resolve(Array.from(pids).filter(Boolean));
      });
    });
  }

  async killProcessByPid(pid, label = 'Java') {
    return new Promise(resolve => {
      exec(`taskkill /F /T /PID ${pid}`, error => {
        if (error) {
          console.warn(`[${label}] Failed to kill PID ${pid}:`, error);
        } else {
          console.log(`[${label}] Killed PID ${pid}`);
        }
        resolve();
      });
    });
  }

  /**
   * 检查 JRE 是否存在
   */
  isJREAvailable() {
    return fs.existsSync(this.javaExe);
  }

  /**
   * 获取 Java 版本
   */
  getVersion() {
    return new Promise((resolve, reject) => {
      if (!this.isJREAvailable()) {
        reject(new Error('JRE not found at: ' + this.javaExe));
        return;
      }

      const versionProcess = spawn(this.javaExe, ['-version'], {
        stdio: ['ignore', 'pipe', 'pipe']
      });

      let output = '';
      let errorOutput = '';

      versionProcess.stdout.on('data', (data) => {
        output += data.toString();
      });

      versionProcess.stderr.on('data', (data) => {
        errorOutput += data.toString();
      });

      versionProcess.on('close', (code) => {
        if (code === 0 || errorOutput.includes('version')) {
          // Java -version 输出到 stderr
          const versionInfo = (output + errorOutput).trim();
          resolve(versionInfo);
        } else {
          reject(new Error('Failed to get Java version'));
        }
      });
    });
  }

  /**
   * 运行 JAR 文件
   * @param {string} jarPath - JAR 文件的绝对路径
   * @param {Array<string>} args - Java 程序参数
   * @param {Object} options - spawn 选项
   * @returns {ChildProcess}
   */
  runJar(jarPath, args = [], options = {}) {
    if (!this.isJREAvailable()) {
      throw new Error('JRE not found at: ' + this.javaExe);
    }

    if (!fs.existsSync(jarPath)) {
      throw new Error('JAR file not found at: ' + jarPath);
    }

    const javaArgs = ['-jar', jarPath, ...args];
    
    const defaultOptions = {
      cwd: path.dirname(jarPath),
      stdio: 'inherit'
    };

    const mergedOptions = { ...defaultOptions, ...options };

    console.log('Running Java:', this.javaExe, javaArgs.join(' '));
    return spawn(this.javaExe, javaArgs, mergedOptions);
  }

  /**
   * 运行 JAR 文件并等待完成
   * @param {string} jarPath - JAR 文件的绝对路径
   * @param {Array<string>} args - Java 程序参数
   * @param {Object} options - spawn 选项
   * @returns {Promise<number>} 退出代码
   */
  runJarAsync(jarPath, args = [], options = {}) {
    return new Promise((resolve, reject) => {
      try {
        const process = this.runJar(jarPath, args, options);
        
        process.on('close', (code) => {
          if (code === 0) {
            resolve(code);
          } else {
            reject(new Error(`Java process exited with code ${code}`));
          }
        });

        process.on('error', (error) => {
          reject(error);
        });
      } catch (error) {
        reject(error);
      }
    });
  }

  /**
   * 运行 Java 类
   * @param {string} className - Java 类名（包含包名）
   * @param {string} classPath - classpath 路径
   * @param {Array<string>} args - 程序参数
   * @param {Object} options - spawn 选项
   * @returns {ChildProcess}
   */
  runClass(className, classPath, args = [], options = {}) {
    if (!this.isJREAvailable()) {
      throw new Error('JRE not found at: ' + this.javaExe);
    }

    const javaArgs = ['-cp', classPath, className, ...args];
    
    const defaultOptions = {
      stdio: 'inherit'
    };

    const mergedOptions = { ...defaultOptions, ...options };

    console.log('Running Java:', this.javaExe, javaArgs.join(' '));
    return spawn(this.javaExe, javaArgs, mergedOptions);
  }

  /**
   * 运行 Spring Boot JAR 文件
   * @param {string} jarPath - JAR 文件的绝对路径
   * @param {string} configPath - 配置文件路径
   * @param {Object} options - 启动选项（需包含 javaPort）
   * @returns {ChildProcess}
   */
  runSpringBoot(jarPath, configPath, options = {}) {
    if (!this.isJREAvailable()) {
      throw new Error('JRE not found at: ' + this.javaExe);
    }

    if (!fs.existsSync(jarPath)) {
      throw new Error('JAR file not found at: ' + jarPath);
    }

    const javaArgs = [
      '-Dfile.encoding=UTF-8',  // 设置文件编码为UTF-8，解决中文乱码
      '-Duser.language=zh',     // 设置语言为中文
      '-Duser.region=CN',       // 设置地区为中国
    ];

    // 如果提供了 logPath，通过 JVM 系统属性传递给 logback
    if (options.logPath) {
      // Windows 路径使用正斜杠或保持原样，JVM 会自动处理
      // 方案1：转换为正斜杠（跨平台兼容）
      const normalizedLogPath = options.logPath.replace(/\\/g, '/');
      javaArgs.push(`-DlogHomeDir=${normalizedLogPath}`);
      console.log('[Java] Setting log path to:', normalizedLogPath);
      console.log('[Java] Original log path:', options.logPath);
    }

    javaArgs.push('-jar', jarPath, `--spring.config.location=${configPath}`);

    const defaultOptions = {
      cwd: path.dirname(jarPath),
      stdio: ['ignore', 'pipe', 'pipe'],
      env: {
        ...process.env,
        JAVA_TOOL_OPTIONS: '-Dfile.encoding=UTF-8'  // 额外确保UTF-8编码
      }
    };

    const mergedOptions = { ...defaultOptions, ...options };

    console.log('Running Spring Boot:', this.javaExe, javaArgs.join(' '));
    const javaProcess = spawn(this.javaExe, javaArgs, mergedOptions);
    
    // 记录PID和端口用于后续停止
    this.springBootProcess = javaProcess;
    this.currentJavaPort = options.javaPort;
    this.currentJarPath = jarPath;
    this.recordJavaProcess({
      pid: javaProcess.pid,
      port: options.javaPort || null,
      jarPath,
      javaExe: this.javaExe,
      createdAt: new Date().toISOString()
    });
    
    // 将Java端口记录到文件，供手动清理脚本使用
    if (options.javaPort) {
      this.recordJavaPort(options.javaPort);
    }
    
    // 进程退出时清理端口记录
    javaProcess.on('close', () => {
      this.cleanupJavaProcessRecord();
      this.cleanupJavaPortFile();
    });
    
    return javaProcess;
  }

  /**
   * 停止 Spring Boot 应用
   */
  async stopSpringBoot() {
    const recordedProcess = this.getRecordedJavaProcess();
    const candidateProcesses = [];

    if (this.springBootProcess && !this.springBootProcess.killed) {
      candidateProcesses.push({
        pid: this.springBootProcess.pid,
        port: this.currentJavaPort || null,
        jarPath: this.currentJarPath || null
      });
    }

    if (recordedProcess && recordedProcess.pid && !candidateProcesses.some(item => item.pid === recordedProcess.pid)) {
      candidateProcesses.push(recordedProcess);
    }

    for (const candidate of candidateProcesses) {
      const isOwnProcess = await this.isOwnJavaProcess(candidate.pid, candidate);
      if (!isOwnProcess) {
        continue;
      }

      console.log(`[Java] Stopping tracked Spring Boot process PID ${candidate.pid}`);
      await this.killProcessByPid(candidate.pid, 'Java');
      this.cleanupJavaProcessRecord();
      this.cleanupJavaPortFile();
      this.springBootProcess = null;
      this.currentJavaPort = null;
      this.currentJarPath = null;
      console.log('[Java] Spring Boot stop process completed');
      console.log('[Java] Only the current application JAR process was cleaned');
      return;
    }

    const fallbackPort = this.currentJavaPort || recordedProcess?.port || this.getRecordedJavaPort();
    if (fallbackPort) {
      const pids = await this.findPidsByPort(fallbackPort);
      for (const pid of pids) {
        const isOwnProcess = await this.isOwnJavaProcess(pid, recordedProcess || { jarPath: this.currentJarPath });
        if (!isOwnProcess) {
          continue;
        }

        console.log(`[Java] Stopping fallback JAR process on port ${fallbackPort}, PID ${pid}`);
        await this.killProcessByPid(pid, 'Java');
        this.cleanupJavaProcessRecord();
        this.cleanupJavaPortFile();
        this.springBootProcess = null;
        this.currentJavaPort = null;
        this.currentJarPath = null;
        console.log('[Java] Spring Boot stop process completed');
        console.log('[Java] Only the current application JAR process was cleaned');
        return;
      }
    }

    this.cleanupJavaProcessRecord();
    this.cleanupJavaPortFile();
    this.springBootProcess = null;
    this.currentJavaPort = null;
    this.currentJarPath = null;
    console.log('[Java] No tracked Spring Boot process found, process record cleaned');
  }
  
  /**
   * 记录Java端口到文件
   */
  recordJavaPort(port) {
    try {
      const javaDir = this.javaRuntimeDir;
      const portFilePath = path.join(javaDir, '.running-port');
      
      fs.mkdirSync(javaDir, { recursive: true });
      fs.writeFileSync(portFilePath, port.toString(), 'utf-8');
      console.log(`[Java] Port ${port} recorded to ${portFilePath}`);
    } catch (error) {
      console.warn('[Java] Failed to record port:', error);
    }
  }
  
  /**
   * 清理Java端口记录文件
   */
  cleanupJavaPortFile() {
    try {
      const portFilePath = path.join(this.javaRuntimeDir, '.running-port');
      
      if (fs.existsSync(portFilePath)) {
        fs.unlinkSync(portFilePath);
        console.log('[Java] Port record file cleaned up');
      }
    } catch (error) {
      console.warn('[Java] Failed to cleanup port record:', error);
    }
  }
  
  /**
   * 获取记录的Java运行端口
   */
  getRecordedJavaPort() {
    try {
      const recordedProcess = this.getRecordedJavaProcess();
      if (recordedProcess && recordedProcess.port) {
        return parseInt(recordedProcess.port);
      }

      const portFilePath = path.join(this.javaRuntimeDir, '.running-port');
      
      if (fs.existsSync(portFilePath)) {
        const port = fs.readFileSync(portFilePath, 'utf-8').trim();
        return parseInt(port);
      }
    } catch (error) {
      console.warn('[Java] Failed to read port record:', error);
    }
    return null;
  }

  /**
   * 获取 JRE 路径信息
   */
  getPathInfo() {
    return {
      jrePath: this.jrePath,
      binPath: this.binPath,
      javaExe: this.javaExe,
      available: this.isJREAvailable()
    };
  }
}

module.exports = JavaRunner;