/* 
 * CaelLab BY-SA Code License 
 * Copyright (c) 2026 Yunyun(云云) By 虚舟实验室(CaelLab) / CaelLabGameTS 

 * Source: https://github.com/yunyun-3782/GoodPlanCraftLauncher 
 */



const { app, BrowserWindow, ipcMain, net, dialog, Menu, shell } = require('electron');
const path = require('path');
const { spawn, spawnSync } = require('child_process');
const fs = require('fs');
const os = require('os');
const { tmpdir } = require('os');
const { pipeline } = require('stream/promises');

process.env.TZ = 'Asia/Shanghai';

app.commandLine.appendSwitch('js-flags', '--compile-hints-always');
app.commandLine.appendSwitch('disk-cache-size', '134217728');

function formatTimestamp() {
  const now = new Date();
  const year = now.getFullYear();
  const month = String(now.getMonth() + 1).padStart(2, '0');
  const day = String(now.getDate()).padStart(2, '0');
  const hours = String(now.getHours()).padStart(2, '0');
  const minutes = String(now.getMinutes()).padStart(2, '0');
  const seconds = String(now.getSeconds()).padStart(2, '0');
  const ms = String(now.getMilliseconds()).padStart(3, '0');
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
}

function checkDebuggerAttached() {
  try {
    if (process.execArgv.some(arg => arg.includes('--inspect') || arg.includes('--debug-brk'))) {
      return true;
    }
    if (process.env.ELECTRON_ENABLE_STACK_DUMPING) {
      return true;
    }
  } catch (e) {}
  return false;
}


let isDeveloperMode = false;

let BASE_DIR;
let GAME_DIR;
let CACHE_DIR;
let LOG_DIR;
let LOG_FILE;
let APP_VERSION;
let CONFIG_DIR;

const DEFAULT_SETTINGS = {
  game: {
    memory: '2',
    playerName: 'GPCL_Player',
    javaPath: '',
    jvmArgs: '',
    windowMode: 'windowed'
  },
  appearance: {
    theme: 'light',
    scale: '110',
    playStartupAnimation: true,
    skipSplash: false
  },
  download: {
    maxConcurrent: 64,
    javaMirror: 'tsinghua',
    customJavaMirror: ''
  },
  advanced: {
    autoCheckUpdate: true,
    preventMultipleLaunch: true,
    autoClearLogs: true,
    logRetentionValue: 7,
    logRetentionUnit: 'day',
    developerMode: false
  }
};

function parseIni(text) {
  const result = {};
  let currentSection = null;
  const lines = text.split(/\r?\n/);
  for (const line of lines) {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith(';') || trimmed.startsWith('#')) {
      continue;
    }
    const sectionMatch = trimmed.match(/^\[(.+)\]$/);
    if (sectionMatch) {
      currentSection = sectionMatch[1].toLowerCase();
      if (!result[currentSection]) {
        result[currentSection] = {};
      }
      continue;
    }
    const keyValueMatch = trimmed.match(/^([^=]+)=(.*)$/);
    if (keyValueMatch && currentSection) {
      const key = keyValueMatch[1].trim();
      let value = keyValueMatch[2].trim();
      if (value.toLowerCase() === 'true') {
        value = true;
      } else if (value.toLowerCase() === 'false') {
        value = false;
      } else {
        const num = Number(value);
        if (!isNaN(num)) {
          value = num;
        }
      }
      result[currentSection][key] = value;
    }
  }
  return result;
}

function stringifyIni(obj) {
  let result = '';
  for (const [section, sectionData] of Object.entries(obj)) {
    result += `[${section}]\n`;
    for (const [key, value] of Object.entries(sectionData)) {
      result += `${key}=${value}\n`;
    }
    result += '\n';
  }
  return result.trim();
}

function mergeWithDefaults(settings) {
  const merged = JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
  for (const [section, sectionData] of Object.entries(settings)) {
    if (merged[section]) {
      for (const [key, value] of Object.entries(sectionData)) {
        if (key in merged[section]) {
          merged[section][key] = value;
        }
      }
    }
  }
  return merged;
}

function loadSettings() {
  try {
    const configPath = path.join(BASE_DIR, 'gpcl', 'config', 'setting.ini');
    if (fs.existsSync(configPath)) {
      const content = fs.readFileSync(configPath, 'utf8');
      const parsed = parseIni(content);
      const merged = mergeWithDefaults(parsed);
      writeLog('配置已加载');
      return merged;
    }
  } catch (e) {
    writeLog(`加载配置失败: ${e.message}`);
  }
  writeLog('使用默认配置');
  return JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
}

function saveSettings(settings) {
  try {
    const configDir = path.join(BASE_DIR, 'gpcl', 'config');
    const configPath = path.join(configDir, 'setting.ini');
    if (!fs.existsSync(configDir)) {
      fs.mkdirSync(configDir, { recursive: true });
    }
    const content = stringifyIni(settings);
    fs.writeFileSync(configPath, content, 'utf8');
    writeLog('配置已保存');
    return true;
  } catch (e) {
    writeLog(`保存配置失败: ${e.message}`);
    return false;
  }
}

function initPaths() {
  BASE_DIR = app.getPath('userData');
  GAME_DIR = path.join(BASE_DIR, '.minecraft');
  CACHE_DIR = path.join(BASE_DIR, 'gpcl', 'cache');
  LOG_DIR = path.join(BASE_DIR, 'gpcl', 'log');
  CONFIG_DIR = path.join(BASE_DIR, 'gpcl', 'config');
  const startupTime = new Date().toISOString().replace(/:/g, '-').replace('.', '_');
  LOG_FILE = path.join(LOG_DIR, `${startupTime}.log`);

  const requiredDirs = [
    path.join(BASE_DIR, 'gpcl', 'config'),
    path.join(BASE_DIR, 'gpcl', 'users'),
    LOG_DIR,
    CACHE_DIR
  ];

  for (const dir of requiredDirs) {
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }
  }
}

function cleanupExpiredLogs() {
  try {
    const settings = loadSettings();
    const autoClearLogs = settings.advanced?.autoClearLogs;
    
    if (!autoClearLogs) {
      writeLog('[日志清理] 自动清理日志已禁用');
      return;
    }

    const retentionValue = settings.advanced?.logRetentionValue || 7;
    const retentionUnit = settings.advanced?.logRetentionUnit || 'day';

    // 计算过期时间
    const now = Date.now();
    let expireTime;
    
    switch (retentionUnit) {
      case 'hour':
        expireTime = now - retentionValue * 60 * 60 * 1000;
        break;
      case 'day':
        expireTime = now - retentionValue * 24 * 60 * 60 * 1000;
        break;
      case 'month':
        expireTime = now - retentionValue * 30 * 24 * 60 * 60 * 1000;
        break;
      case 'year':
        expireTime = now - retentionValue * 365 * 24 * 60 * 60 * 1000;
        break;
      default:
        expireTime = now - retentionValue * 24 * 60 * 60 * 1000;
    }

    if (!fs.existsSync(LOG_DIR)) {
      writeLog('[日志清理] 日志目录不存在');
      return;
    }

    const files = fs.readdirSync(LOG_DIR);
    let cleanedCount = 0;

    for (const file of files) {
      if (!file.endsWith('.log')) continue;
      
      const filePath = path.join(LOG_DIR, file);
      try {
        const stat = fs.statSync(filePath);
        if (stat.mtime.getTime() < expireTime) {
          fs.unlinkSync(filePath);
          cleanedCount++;
        }
      } catch (e) {
        writeLog(`[日志清理] 清理文件失败: ${file} - ${e.message}`);
      }
    }

    if (cleanedCount > 0) {
      writeLog(`[日志清理] 已清理 ${cleanedCount} 个过期日志文件`);
    } else {
      writeLog('[日志清理] 没有需要清理的过期日志');
    }
  } catch (e) {
    writeLog(`[日志清理] 清理过程出错: ${e.message}`);
  }
}

let mainWindow;
APP_VERSION = require('./package.json').version;

function writeLog(message) {
  const timestamp = formatTimestamp();
  const logLine = `[${timestamp}] ${message}\n`;
  try {
    if (LOG_FILE) {
      fs.appendFileSync(LOG_FILE, logLine, 'utf8');
    }
    console.log(`[${timestamp}] LOG:`, message);
  } catch (e) {
    console.error(`[${formatTimestamp()}] 写入日志失败:`, e);
  }
}

let isDownloading = false;
let currentDownloadVersion = null;
let shouldCancelDownload = false;
let currentDownloadType = null; // 'game' or 'java'
let currentDownloadPath = null; // 下载的文件或文件夹路径
let javaDownloadResolve = null; // Java下载对话框的Promise resolve
let javaDownloadReject = null; // Java下载对话框的Promise reject
let isJavaDownloading = false; // Java下载中标志

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1000,
    height: 700,
    minWidth: 800,
    minHeight: 600,
    maxWidth: 1920,
    maxHeight: 1080,
    frame: false,
    title: 'GoodPlanCraftLauncher',
    icon: path.join(__dirname, 'gpcl', 'logo.ico'),
    backgroundColor: '#0d0d15',
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
      devTools: true
    }
  });

  try { Menu.setApplicationMenu(null); } catch (e) {}
  mainWindow.setMenuBarVisibility(false);
  mainWindow.setAutoHideMenuBar(true);

  mainWindow.loadFile(path.join(__dirname, 'renderer', 'splash.html'));

  // 关闭窗口前拦截
  mainWindow.on('close', (event) => {
    if (isDownloading || isJavaDownloading) {
      event.preventDefault();
      // 发送询问到渲染进程
      mainWindow.webContents.send('confirm-close-while-downloading');
    }
  });

  mainWindow.webContents.on('before-input-event', (event, input) => {
    if (isDeveloperMode) return;
    const key = input.key && input.key.toLowerCase();
    const ctrlOrCmd = input.control || input.meta;
    if ((ctrlOrCmd && key === 'r') || input.key === 'F5') event.preventDefault();
    if ((input.control && input.shift && key === 'i') || input.key === 'F12' || (input.meta && input.alt && key === 'i')) event.preventDefault();
  });

  mainWindow.webContents.on('context-menu', (e) => {
    if (!isDeveloperMode) e.preventDefault();
  });
}

app.on('web-contents-created', (event, contents) => {
  try {
    contents.on('context-menu', (e) => {
      if (!isDeveloperMode) e.preventDefault();
    });
    contents.on('before-input-event', (event, input) => {
      if (isDeveloperMode) return;
      const key = input.key && input.key.toLowerCase();
      const ctrlOrCmd = input.control || input.meta;
      if ((ctrlOrCmd && key === 'r') || input.key === 'F5') event.preventDefault();
      if ((input.control && input.shift && key === 'i') || input.key === 'F12' || (input.meta && input.alt && key === 'i')) event.preventDefault();
    });
  } catch (e) {}
});

// 单实例锁：当检测到第二个实例时，凸显已有窗口
app.on('second-instance', () => {
  if (mainWindow) {
    if (mainWindow.isMinimized()) mainWindow.restore();
    mainWindow.focus();
  }
});

function createGPCLShortcut() {
  try {
    const startMenuDir = path.join(app.getPath('appData'), 'Microsoft', 'Windows', 'Start Menu', 'Programs');
    const shortcutPath = path.join(startMenuDir, 'GPCL.lnk');
    
    if (fs.existsSync(shortcutPath)) {
      return;
    }
    
    if (app.isPackaged) {
      const exePath = process.execPath;
      shell.writeShortcutLink(shortcutPath, 'create', {
        target: exePath,
        description: 'GoodPlanCraftLauncher - Minecraft 启动器',
        icon: exePath,
        iconIndex: 0
      });
      writeLog('[快捷方式] 已创建 GPCL 快捷方式');
    }
  } catch (e) {
    writeLog(`[快捷方式] 创建 GPCL 快捷方式失败: ${e.message}`);
  }
}

app.whenReady().then(() => {
  // 检测是否是 electron-builder 的测试运行
  const isTesting = process.argv.includes('--squirrel-install') || 
                    process.argv.includes('--squirrel-obsolete') ||
                    process.argv.includes('--squirrel-updated') ||
                    process.argv.includes('--testing');
  
  if (isTesting) {
    console.log('[启动] 检测到构建测试模式，跳过窗口创建');
    app.quit();
    return;
  }

  // 提前初始化 BASE_DIR 以读取配置文件
  BASE_DIR = app.getPath('userData');

  // 检查是否启用防止多次启动
  let preventMultipleLaunch = true;
  try {
    const configPath = path.join(BASE_DIR, 'gpcl', 'config', 'setting.ini');
    if (fs.existsSync(configPath)) {
      const content = fs.readFileSync(configPath, 'utf8');
      const parsed = parseIni(content);
      if (parsed.advanced) {
        if (parsed.advanced.preventMultipleLaunch === false || parsed.advanced.preventmultiplelaunch === false) {
          preventMultipleLaunch = false;
        }
      }
    }
  } catch (e) {}

  if (preventMultipleLaunch) {
    const gotLock = app.requestSingleInstanceLock();
    if (!gotLock) {
      writeLog('检测到已有实例运行，退出');
      app.quit();
      return;
    }
  }

  initPaths();
  
  cleanupExpiredLogs();
  
  try {
    const devConfigPath = path.join(BASE_DIR, 'gpcl', 'config', 'setting.ini');
    if (fs.existsSync(devConfigPath)) {
      const devContent = fs.readFileSync(devConfigPath, 'utf8');
      const devParsed = parseIni(devContent);
      if (devParsed.advanced && devParsed.advanced.developerMode === true) {
        isDeveloperMode = true;
        writeLog('[开发者模式] 启动时已启用');
      }
    }
  } catch (e) {}
  
  createGPCLShortcut();
  
  writeLog(`GPCL v${APP_VERSION} 启动`);
  console.log('日志文件路径:', LOG_FILE);
  createWindow();
});
app.on('window-all-closed', () => app.quit());

ipcMain.handle('show-message-dialog', async (_, options) => {
  if (!mainWindow) return { success: false };
  const result = await dialog.showMessageBox(mainWindow, {
    type: options.type || 'info',
    title: options.title || '提示',
    message: options.message || '',
    detail: options.detail || '',
    buttons: options.buttons || ['确定'],
    defaultId: options.defaultId || 0,
    cancelId: options.cancelId || 0,
    noLink: true
  });
  return { success: true, response: result.response };
});

// Java版本 → 官方runtime目录名映射
const JAVA_RUNTIME_MAP = {
  "8": "jre-legacy",
  "16": "java-runtime-beta",
  "17": "java-runtime-gamma",
  "21": "java-runtime-delta",
  "25": "java-runtime-epsilon"
};

// Java版本 → 下载URL的key映射
const JAVA_DOWNLOAD_KEYS = {
  "8": "jre-legacy",
  "17": "java-runtime-gamma",
  "21": "java-runtime-delta",
  "25": "java-runtime-epsilon"
};

// 可选择的Java版本列表
const JAVA_VERSIONS_AVAILABLE = ["8", "17", "21", "25"];

// 获取Java运行时目录（官方目录结构，使用绝对路径）
function getJavaRuntimeDir(javaVersion) {
  const runtimeName = JAVA_RUNTIME_MAP[javaVersion] || `jre${javaVersion}`;
  // 使用官方Minecraft运行时目录：C:\Users\用户名\AppData\Roaming\.minecraft\runtime
  return path.join(os.homedir(), 'AppData', 'Roaming', '.minecraft', 'runtime', runtimeName);
}

// 在目录中查找java.exe（自动拼接\bin\，使用java.exe以便捕获错误输出）
function findJavaExecutable(runtimeDir) {
  // 优先使用 bin\java.exe（可以捕获控制台输出用于调试）
  const javaPath = path.join(runtimeDir, 'bin', 'java.exe');
  if (fs.existsSync(javaPath)) {
    try {
      fs.accessSync(javaPath, fs.constants.R_OK);
      return javaPath;
    } catch (e) {
      return null;
    }
  }
  // 兜底：递归查找
  return findJavaExecutableInDir(runtimeDir);
}

// 检查指定版本的Java是否已安装
async function checkJavaInstalled(javaVersion) {
  const runtimeDir = getJavaRuntimeDir(javaVersion);
  if (fs.existsSync(runtimeDir)) {
    const exe = findJavaExecutable(runtimeDir);
    if (exe) {
      return { installed: true, javaPath: exe };
    }
  }
  return { installed: false, javaPath: null };
}

// 获取指定Minecraft版本所需的Java版本
function getJavaVersionForMCVersion(versionId) {
  // Minecraft 1.16及以下: Java 8
  // Minecraft 1.17: Java 16
  // Minecraft 1.18-1.20: Java 17
  // Minecraft 1.21+: Java 21
  const parts = versionId.split('.');
  let major = parseInt(parts[0], 10);
  let minor = parseInt(parts[1], 10);
  // 如果版本号是 "26" 这种没有点的格式
  if (isNaN(major)) major = 1;
  // 处理像 "26" 这种格式（没有 minor）
  if (isNaN(minor)) {
    // 26 及以上使用 Java 25
    if (major >= 26) return '25';
    // 21-25 使用 Java 21
    if (major >= 21) return '21';
    // 否则默认 Java 17
    return '17';
  }
  // 处理 1.x.x 的旧版本
  if (major === 1) {
    if (minor < 17) return '8';
    if (minor === 17) return '16';
    if (minor <= 20) return '17';
    return '21';
  }
  // 处理 2.x.x 和更大的版本（21, 24, 26, ...）
  // 26 及以上使用 Java 25
  if (major >= 26) return '25';
  // 21-25 使用 Java 21
  if (major >= 21) return '21';
  return '17';
}

// 获取版本数据中指定的Java版本
function getJavaVersionFromVersionData(versionData) {
  if (versionData?.javaVersion?.majorVersion) {
    return String(versionData.javaVersion.majorVersion);
  }
  if (versionData?.javaVersion?.component) {
    const m = versionData.javaVersion.component.match(/\d+/);
    if (m) return m[0];
  }
  return getJavaVersionForMCVersion(versionData.id);
}

// 查找本地Java运行时（只查找，不下载）
async function ensureJavaRuntime(version) {
  const javaVersion = typeof version === 'string' ? version : String(version);
  const runtimeDir = getJavaRuntimeDir(javaVersion);
  
  writeLog(`[Java] 查找 Java ${javaVersion} 运行时: ${runtimeDir}`);
  
  if (fs.existsSync(runtimeDir)) {
    const exe = findJavaExecutable(runtimeDir);
    if (exe) {
      writeLog(`[Java] 找到 Java ${javaVersion}: ${exe}`);
      return exe;
    }
  }
  
  writeLog(`[Java] 未找到 Java ${javaVersion} 运行时`);
  return null;
}

// 完整的Java运行时保证（包括下载和安装）
async function ensureJavaRuntimeWithInstall(version, mainWindow) {
  const javaVersion = typeof version === 'string' ? version : String(version);
  
  // 先检查是否已安装
  const installed = await checkJavaInstalled(javaVersion);
  if (installed.installed && installed.javaPath) {
    writeLog(`[Java] Java ${javaVersion} 已安装: ${installed.javaPath}`);
    return { success: true, javaPath: installed.javaPath };
  }
  
  // 如果未安装，触发下载流程
  writeLog(`[Java] Java ${javaVersion} 未安装，开始下载流程`);
  return null;
}

// 用户确认关闭并清理
ipcMain.handle('confirm-close-download', async () => {
  if (isDownloading && currentDownloadVersion) {
    shouldCancelDownload = true;
    
    try {
      // 清理游戏版本下载
      const versionDir = currentDownloadPath || path.join(GAME_DIR, 'versions', currentDownloadVersion);
      const cancelFilePath = path.join(versionDir, 'CancelDownload.txt');
      const cancelContent = `GoodPlanCraftLauncher ${APP_VERSION}\n取消时间：${formatTimestamp()}\n\n正确的关闭\n您在下载完成前正确地关闭了GPCL。`;
      
      if (fs.existsSync(versionDir)) {
        fs.writeFileSync(cancelFilePath, cancelContent, 'utf8');
        const files = fs.readdirSync(versionDir);
        for (const file of files) {
          const filePath = path.join(versionDir, file);
          if (file !== 'CancelDownload.txt') {
            if (fs.statSync(filePath).isDirectory()) {
              fs.rmSync(filePath, { recursive: true, force: true });
            } else {
              fs.unlinkSync(filePath);
            }
          }
        }
      }
      writeLog(`已清理游戏版本下载目录: ${versionDir}`);
    } catch (e) {
      console.error('清理下载失败:', e);
      writeLog(`清理下载失败: ${e.message}`);
    }
    
    isDownloading = false;
    currentDownloadVersion = null;
    currentDownloadType = null;
    currentDownloadPath = null;
  }
  if (mainWindow) {
    mainWindow.destroy();
  }
  return { success: true };
});

// 取消关闭
ipcMain.handle('cancel-close', () => {
  return { success: true };
});

// 取消启动游戏
let launchCancelFlag = false;
let currentGameProcess = null;
let currentGamePid = null;

function killGameProcessTree(pid) {
  try {
    const result = spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { windowsHide: true, timeout: 5000 });
    if (result.status === 0) {
      writeLog(`[启动] 已终止进程树 PID: ${pid}`);
      return true;
    }
    writeLog(`[启动] taskkill PID ${pid} 返回: ${result.status}, ${result.stderr?.toString().trim()}`);
  } catch (e) {
    writeLog(`[启动] taskkill 失败: ${e.message}`);
  }
  return false;
}

function findAndKillMinecraftJavaProcesses() {
  try {
    const script = `
      $javaProcs = Get-Process -Name "java","javaw" -ErrorAction SilentlyContinue
      if ($javaProcs) {
        foreach ($p in $javaProcs) {
          try {
            $cmdLine = (Get-CimInstance Win32_Process -Filter "ProcessId=$($p.Id)" -ErrorAction SilentlyContinue).CommandLine
            if ($cmdLine -and ($cmdLine -like '*net.minecraft*' -or $cmdLine -like '*minecraft*' -or $cmdLine -like '*forge*' -or $cmdLine -like '*fabric*' -or $cmdLine -like '*optifine*')) {
              Stop-Process -Id $p.Id -Force -ErrorAction SilentlyContinue
              Write-Output "KILLED:$($p.Id)"
            }
          } catch {}
        }
      }
    `;
    const result = spawnSync('powershell', ['-NoProfile', '-Command', script], { windowsHide: true, timeout: 8000, encoding: 'utf8' });
    const output = (result.stdout || '').trim();
    if (output) {
      const pids = output.split('\n').filter(l => l.startsWith('KILLED:')).map(l => l.replace('KILLED:', ''));
      writeLog(`[启动] 通过命令行匹配杀死了 ${pids.length} 个Minecraft Java进程: ${pids.join(', ')}`);
      return pids.length > 0;
    }
  } catch (e) {
    writeLog(`[启动] 查找Minecraft进程失败: ${e.message}`);
  }
  return false;
}

ipcMain.handle('cancel-launch', async () => {
  launchCancelFlag = true;
  writeLog('[启动] 用户取消启动');

  let killed = false;

  if (currentGameProcess) {
    try {
      const pid = currentGameProcess.pid;
      if (pid) {
        writeLog(`[启动] 尝试终止游戏进程 PID: ${pid}`);
        killed = killGameProcessTree(pid);
        try { currentGameProcess.kill(); } catch {}
      }
    } catch (e) {
      writeLog(`[启动] 终止游戏进程异常: ${e.message}`);
    }
    currentGameProcess = null;
    currentGamePid = null;
  }

  if (!killed) {
    writeLog('[启动] 未找到已保存的游戏进程，尝试通过命令行匹配查找Minecraft Java进程');
    findAndKillMinecraftJavaProcesses();
  }

  if (mainWindow) {
    mainWindow.webContents.send('game-closed', -1);
  }

  return { success: true };
});

// 检查更新（使用Node.js网络请求避免CORS问题）
const https = require('https');
ipcMain.handle('check-for-updates', async () => {
  return new Promise((resolve) => {
    const url = 'https://gamets.caellab.com/gpcl/data.json';
    writeLog('[更新] 开始检查更新...');
    
    https.get(url, (res) => {
      let data = '';
      res.setEncoding('utf8');
      
      res.on('data', (chunk) => {
        data += chunk;
      });
      
      res.on('end', () => {
        try {
          const json = JSON.parse(data);
          writeLog('[更新] 获取到数据: ' + data);
          resolve({ success: true, data: json });
        } catch (e) {
          writeLog('[更新] JSON解析失败: ' + e.message);
          resolve({ success: false, error: 'JSON解析失败: ' + e.message });
        }
      });
    }).on('error', (e) => {
      writeLog('[更新] 请求失败: ' + e.message);
      resolve({ success: false, error: e.message });
    });
  });
});

// 获取当前版本号（从package.json读取）
ipcMain.handle('get-app-version', () => {
  return APP_VERSION || app.getVersion() || '1.0.0';
});

// 打开外部链接
ipcMain.handle('open-external', (_, url) => {
  try {
    shell.openExternal(url);
    return { success: true };
  } catch (e) {
    writeLog('[外部链接] 打开失败: ' + e.message);
    return { success: false, error: e.message };
  }
});

// IPC: 卸载Java运行时
ipcMain.handle('uninstall-java', async (_, javaVersion) => {
  try {
    const runtimeDir = getJavaRuntimeDir(javaVersion);
    writeLog(`[Java] 开始卸载 Java ${javaVersion}，目录: ${runtimeDir}`);

    if (!fs.existsSync(runtimeDir)) {
      return { success: false, error: `Java ${javaVersion} 未安装` };
    }

    fs.rmSync(runtimeDir, { recursive: true, force: true });
    writeLog(`[Java] Java ${javaVersion} 已卸载，目录已删除: ${runtimeDir}`);

    if (mainWindow) {
      mainWindow.webContents.send('java-uninstalled', { javaVersion });
    }

    return { success: true };
  } catch (e) {
    writeLog(`[Java] 卸载 Java ${javaVersion} 失败: ${e.message}`);
    return { success: false, error: e.message };
  }
});

// 获取Java镜像源设置
ipcMain.handle('get-java-mirror-settings', () => {
  try {
    const settingsPath = path.join(GAME_DIR, 'settings', 'java_mirror.json');
    if (fs.existsSync(settingsPath)) {
      return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
    }
    return {
      mirror: 'tsinghua',
      customUrl: ''
    };
  } catch (e) {
    return {
      mirror: 'tsinghua',
      customUrl: ''
    };
  }
});

// 获取Java版本对应的下载URL
ipcMain.handle('get-java-download-url', async (_, javaVersion) => {
  try {
    const settingsPath = path.join(GAME_DIR, 'settings', 'java_mirror.json');
    let settings = {
      mirror: 'tsinghua',
      customUrl: ''
    };
    
    if (fs.existsSync(settingsPath)) {
      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
    }
    
    // 根据镜像源生成URL
    const url = getJavaDownloadUrl(javaVersion, settings.mirror, settings.customUrl);
    writeLog(`[Java] 获取下载URL: Java ${javaVersion} - ${url}`);
    return { success: true, url };
  } catch (e) {
    writeLog(`[Java] 获取下载URL失败: ${e.message}`);
    return { success: false, error: e.message };
  }
});

// 根据镜像源生成下载URL
function getJavaDownloadUrl(javaVersion, mirror, customUrl) {
  // 清华大学镜像
  const tsinghuaMirrors = {
    "8": "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/8/jre/x64/windows/OpenJDK8U-jre_x64_windows_hotspot_8u492b09.zip",
    "17": "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/17/jre/x64/windows/OpenJDK17U-jre_x64_windows_hotspot_17.0.19_10.zip",
    "21": "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/21/jre/x64/windows/OpenJDK21U-jre_x64_windows_hotspot_21.0.11_10.zip",
    "25": "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/25/jre/x64/windows/OpenJDK25U-jre_x64_windows_hotspot_25.0.3_9.zip"
  };
  
  // 如果使用清华大学镜像
  if (mirror === 'tsinghua') {
    return tsinghuaMirrors[javaVersion] || tsinghuaMirrors["17"];
  }
  
  // 如果使用自定义镜像
  if (mirror === 'custom' && customUrl) {
    // 替换{v}变量
    let url = customUrl;
    
    // Java版本号（8, 17, 21等）
    url = url.replace(/\{v\}/gi, javaVersion);
    
    // 完整版本号的映射
    const versionMap = {
      "8": "8u492b09",
      "17": "17.0.19_10",
      "21": "21.0.11_10",
      "25": "25.0.3_9"
    };
    url = url.replace(/\{version\}/gi, versionMap[javaVersion] || javaVersion);
    
    return url;
  }
  
  // 默认使用清华大学镜像
  return tsinghuaMirrors[javaVersion] || tsinghuaMirrors["17"];
}

// 保存Java镜像源设置
function saveJavaMirrorSettings(mirror, customUrl) {
  try {
    const settingsDir = path.join(GAME_DIR, 'settings');
    if (!fs.existsSync(settingsDir)) {
      fs.mkdirSync(settingsDir, { recursive: true });
    }
    const settingsPath = path.join(settingsDir, 'java_mirror.json');
    fs.writeFileSync(settingsPath, JSON.stringify({
      mirror,
      customUrl
    }, null, 2));
    writeLog(`[Java] 镜像源设置已保存: ${mirror}`);
    return true;
  } catch (e) {
    writeLog(`[Java] 保存镜像源设置失败: ${e.message}`);
    return false;
  }
}

// 取消下载（只清理文件，不关闭窗口）
ipcMain.handle('cancel-download-only', async () => {
  writeLog('[取消下载] 开始取消下载流程');
  
  // 设置取消标志
  shouldCancelDownload = true;
  
  // 清空下载队列
  const pendingCount = downloadQueue.length;
  downloadQueue = [];
  writeLog(`[取消下载] 已清空 ${pendingCount} 个待处理下载任务`);
  
  // 等待当前活跃的下载完成（最多等待2秒）
  const waitStart = Date.now();
  while (activeDownloads > 0 && (Date.now() - waitStart) < 2000) {
    await new Promise(r => setTimeout(r, 100));
  }
  writeLog(`[取消下载] 活跃下载数: ${activeDownloads}`);
  
  if ((isDownloading && currentDownloadVersion) || isJavaDownloading) {
    try {
      if (currentDownloadType === 'game' && currentDownloadPath) {
        // 清理游戏版本下载
        const versionDir = currentDownloadPath;
        if (fs.existsSync(versionDir)) {
          const files = fs.readdirSync(versionDir);
          for (const file of files) {
            const filePath = path.join(versionDir, file);
            try {
              if (fs.statSync(filePath).isDirectory()) {
                fs.rmSync(filePath, { recursive: true, force: true });
              } else {
                fs.unlinkSync(filePath);
              }
            } catch (e) {
              writeLog(`清理文件失败: ${filePath} - ${e.message}`);
            }
          }
        }
        writeLog(`[取消下载] 已清理游戏版本下载目录: ${versionDir}`);
      } else if (currentDownloadType === 'java' && currentDownloadPath) {
        // 清理Java下载
        const javaFile = currentDownloadPath;
        if (fs.existsSync(javaFile)) {
          try {
            fs.unlinkSync(javaFile);
            writeLog(`[取消下载] 已清理Java下载文件: ${javaFile}`);
          } catch (e) {
            writeLog(`清理Java文件失败: ${e.message}`);
          }
        }
      }
    } catch (e) {
      console.error('清理下载失败:', e);
      writeLog(`清理下载失败: ${e.message}`);
    }
    
    // 重置所有下载状态
    isDownloading = false;
    isJavaDownloading = false;
    currentDownloadVersion = null;
    currentDownloadType = null;
    currentDownloadPath = null;
    activeDownloads = 0;
    totalDownloadFiles = 0;
    completedDownloadFiles = 0;
  }
  
  // 通知渲染进程下载已取消
  for (const w of BrowserWindow.getAllWindows()) {
    w.webContents.send('download-cancelled');
  }
  
  writeLog('[取消下载] 取消下载流程完成');
  return { success: true };
});

// 显示Java版本选择对话框
ipcMain.handle('show-java-install-dialog', async (_, options) => {
  try {
    const { mcVersion, recommendedJava } = options;
    
    // 构建版本选择列表，按推荐程度排序
    const versionPriority = {
      [recommendedJava]: 0,
      "17": 1,
      "21": 2,
      "25": 3,
      "8": 4
    };
    
    const sortedVersions = [...JAVA_VERSIONS_AVAILABLE].sort((a, b) => {
      return (versionPriority[a] || 99) - (versionPriority[b] || 99);
    });
    
    const result = await new Promise((resolve, reject) => {
      javaDownloadResolve = resolve;
      javaDownloadReject = reject;
      
      // 发送消息给渲染进程显示对话框
      if (mainWindow) {
        mainWindow.webContents.send('show-java-install-dialog', {
          mcVersion,
          recommendedJava,
          availableVersions: sortedVersions
        });
      } else {
        reject(new Error('窗口未初始化'));
      }
    });
    
    return result;
  } catch (e) {
    writeLog(`Java安装对话框错误: ${e.message}`);
    return { success: false, cancelled: true };
  }
});

// 用户在对话框中选择Java版本
ipcMain.handle('select-java-version', async (_, data) => {
  const { selectedVersion, cancelled } = data;
  
  if (cancelled) {
    if (javaDownloadResolve) {
      javaDownloadResolve({ success: false, cancelled: true });
      javaDownloadResolve = null;
      javaDownloadReject = null;
    }
    return { success: false, cancelled: true };
  }
  
  if (selectedVersion && javaDownloadResolve) {
    javaDownloadResolve({ success: true, selectedVersion });
    javaDownloadResolve = null;
    javaDownloadReject = null;
    return { success: true, selectedVersion };
  }
  
  return { success: false, cancelled: true };
});

// 下载并安装Java运行时
async function downloadAndInstallJava(javaVersion) {
  const runtimeDir = getJavaRuntimeDir(javaVersion);
  
  writeLog(`[Java] 开始安装 Java ${javaVersion} 运行时`);
  
  try {
    // 检查是否已存在
    if (fs.existsSync(runtimeDir)) {
      const exe = findJavaExecutable(runtimeDir);
      if (exe) {
        writeLog(`[Java] Java ${javaVersion} 已存在，无需下载`);
        return { success: true, javaPath: exe };
      }
    }
    
    // 获取Java运行时的下载URL（支持自定义镜像源）
    const settingsPath = path.join(GAME_DIR, 'settings', 'java_mirror.json');
    let settings = { mirror: 'tsinghua', customUrl: '' };
    
    try {
      if (fs.existsSync(settingsPath)) {
        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
      }
    } catch (e) {}
    
    const downloadUrl = getJavaDownloadUrl(javaVersion, settings.mirror, settings.customUrl);
    writeLog(`[Java] 使用镜像源: ${settings.mirror}, URL: ${downloadUrl}`);
    
    // 使用Electron webContents下载（更可靠）
    const result = await downloadJavaWithWebContents(javaVersion, downloadUrl);
    return result;
    
  } catch (e) {
    writeLog(`[Java] Java ${javaVersion} 安装失败: ${e.message}`);
    
    // 清理失败的安装
    if (fs.existsSync(runtimeDir)) {
      try {
        fs.rmSync(runtimeDir, { recursive: true, force: true });
      } catch (e2) {}
    }
    
    return { success: false, error: e.message };
  }
}

// 使用Electron webContents下载Java（推荐方法）
async function downloadJavaWithWebContents(javaVersion, downloadUrl) {
  const runtimeName = JAVA_RUNTIME_MAP[javaVersion];
  const runtimeDir = getJavaRuntimeDir(javaVersion);
  const tempDir = path.join(CACHE_DIR, 'java_temp');
  const tempFile = path.join(tempDir, `java-${javaVersion}.zip`);

  if (!fs.existsSync(tempDir)) {
    fs.mkdirSync(tempDir, { recursive: true });
  }

  writeLog(`[Java] 使用Electron下载 Java ${javaVersion}: ${downloadUrl}`);

  // 设置下载路径，以便取消时能正确删除
  currentDownloadVersion = `java-${javaVersion}`;
  currentDownloadType = 'java';
  currentDownloadPath = tempFile;
  shouldCancelDownload = false;
  isJavaDownloading = true;

  return new Promise((resolve, reject) => {
    const win = BrowserWindow.getFocusedWindow() || BrowserWindow.getAllWindows()[0];
    if (!win) {
      isJavaDownloading = false;
      currentDownloadVersion = null;
      currentDownloadType = null;
      currentDownloadPath = null;
      reject(new Error('没有可用的窗口'));
      return;
    }

    // 使用webContents.downloadURL
    win.webContents.downloadURL(downloadUrl, true);

    // 监听下载开始
    win.webContents.session.once('will-download', (event, item) => {
      // 设置下载路径
      item.setSavePath(tempFile);
      
      const totalBytes = item.getTotalBytes();
      writeLog(`[Java] 开始下载，总大小: ${totalBytes} bytes`);

      // 监听进度
      item.on('updated', (event, state) => {
        if (state === 'progressing') {
          const received = item.getReceivedBytes();
          const percent = totalBytes > 0 ? Math.floor((received / totalBytes) * 100) : 0;
          
          for (const w of BrowserWindow.getAllWindows()) {
            w.webContents.send('download-progress', {
              label: `Java ${javaVersion}`,
              percent: percent,
              bytesDownloaded: received,
              current: completedDownloadFiles,
              total: totalDownloadFiles
            });
          }

          if (shouldCancelDownload) {
            item.cancel();
            writeLog(`[Java] 下载已取消`);
          }
        }
      });

      // 监听完成
      item.on('done', (event, state) => {
        if (state === 'cancelled') {
          isJavaDownloading = false;
          currentDownloadVersion = null;
          currentDownloadType = null;
          currentDownloadPath = null;
          reject(new Error('下载已取消'));
          return;
        }

        if (state === 'interrupted') {
          isJavaDownloading = false;
          currentDownloadVersion = null;
          currentDownloadType = null;
          currentDownloadPath = null;
          reject(new Error('下载中断'));
          return;
        }

        if (state === 'completed') {
          writeLog(`[Java] 下载完成，开始解压...`);
          
          // 验证文件
          const fileStats = fs.statSync(tempFile);
          const fileSize = fileStats.size;
          
          if (fileSize < 1024) {
            reject(new Error(`下载失败：文件太小 (${fileSize} bytes)`));
            return;
          }
          
          // 检查ZIP头
          const header = Buffer.alloc(4);
          const fd = fs.openSync(tempFile, 'r');
          fs.readSync(fd, header, 0, 4, 0);
          fs.closeSync(fd);
          
          if (header.toString('hex') !== '504b0304') {
            reject(new Error('下载失败：文件不是有效的ZIP格式'));
            return;
          }
          
          writeLog(`[Java] 文件验证通过，大小: ${fileSize} bytes`);
          
          // 解压
          const parentDir = path.dirname(runtimeDir);
          if (!fs.existsSync(parentDir)) {
            fs.mkdirSync(parentDir, { recursive: true });
          }
          
          if (fs.existsSync(runtimeDir)) {
            fs.rmSync(runtimeDir, { recursive: true, force: true });
          }
          
          try {
            const AdmZip = require('adm-zip');
            const zip = new AdmZip(tempFile);
            zip.extractAllTo(parentDir, false);
            writeLog(`[Java] 解压完成`);
          } catch (zipError) {
            reject(new Error(`解压失败: ${zipError.message}`));
            return;
          }
          
          // 重命名目录
          const entries = fs.readdirSync(parentDir);
          let extractedDir = null;
          for (const entry of entries) {
            const entryPath = path.join(parentDir, entry);
            if (fs.statSync(entryPath).isDirectory()) {
              if (entry.includes('jdk') || entry.includes('jre')) {
                const binPath = path.join(entryPath, 'bin', 'java.exe');
                if (fs.existsSync(binPath)) {
                  extractedDir = entryPath;
                  writeLog(`[Java] 找到目录: ${entry}`);
                  break;
                }
              }
            }
          }
          
          if (extractedDir && extractedDir !== runtimeDir) {
            if (fs.existsSync(runtimeDir)) {
              fs.rmSync(runtimeDir, { recursive: true, force: true });
            }
            fs.renameSync(extractedDir, runtimeDir);
            writeLog(`[Java] 已重命名为: ${runtimeName}`);
          }
          
          // 清理临时文件
          try {
            fs.unlinkSync(tempFile);
          } catch (e) {}
          
          // 验证安装
          const javaPath = findJavaExecutable(runtimeDir);
          if (!javaPath) {
            reject(new Error('Java运行时安装失败，未找到java.exe'));
            return;
          }
          
          writeLog(`[Java] Java ${javaVersion} 安装成功: ${javaPath}`);
          isJavaDownloading = false;
          currentDownloadVersion = null;
          currentDownloadType = null;
          currentDownloadPath = null;
          resolve({ success: true, javaPath });
        } else {
          isJavaDownloading = false;
          currentDownloadVersion = null;
          currentDownloadType = null;
          currentDownloadPath = null;
          reject(new Error(`下载失败: ${state}`));
        }
      });
    });

    // 超时处理（10分钟）
    setTimeout(() => {
      if (isJavaDownloading) {
        writeLog(`[Java] 下载超时`);
        isJavaDownloading = false;
        currentDownloadVersion = null;
        currentDownloadType = null;
        currentDownloadPath = null;
        reject(new Error('下载超时'));
      }
    }, 600000);
  }).catch((e) => {
    writeLog(`[Java] Java ${javaVersion} 安装失败: ${e.message}`);
    if (fs.existsSync(runtimeDir)) {
      try {
        fs.rmSync(runtimeDir, { recursive: true, force: true });
      } catch (e2) {}
    }
    return { success: false, error: e.message };
  });
}

// 从Minecraft元数据获取Java运行时的下载信息
async function getJavaRuntimeDownloadInfo(javaVersion) {
  try {
    const runtimeKey = JAVA_DOWNLOAD_KEYS[javaVersion];
    if (!runtimeKey) {
      writeLog(`[Java] 不支持的Java版本: ${javaVersion}`);
      return null;
    }
    
    writeLog(`[Java] 正在查找 Java ${javaVersion} (${runtimeKey}) 的下载信息...`);
    
    // 使用清华大学开源软件镜像站（TUNA）的Adoptium镜像
    const runtimeInfo = {
      "8": {
        id: "jre-legacy",
        version: "8",
        url: "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/8/jre/x64/windows/OpenJDK8U-jre_x64_windows_hotspot_8u492b09.zip"
      },
      "17": {
        id: "java-runtime-gamma",
        version: "17",
        url: "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/17/jre/x64/windows/OpenJDK17U-jre_x64_windows_hotspot_17.0.19_10.zip"
      },
      "21": {
        id: "java-runtime-delta",
        version: "21",
        url: "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/21/jre/x64/windows/OpenJDK21U-jre_x64_windows_hotspot_21.0.11_10.zip"
      },
      "25": {
        id: "java-runtime-epsilon",
        version: "25",
        url: "https://mirrors.tuna.tsinghua.edu.cn/Adoptium/25/jre/x64/windows/OpenJDK25U-jre_x64_windows_hotspot_25.0.3_9.zip"
      }
    };
    
    const javaInfo = runtimeInfo[javaVersion];
    if (javaInfo) {
      writeLog(`[Java] ✓ 找到 Java ${javaVersion} 下载信息`);
      writeLog(`[Java] URL: ${javaInfo.url}`);
      return {
        url: javaInfo.url,
        name: javaInfo.id,
        sha1: null,
        size: null
      };
    }
    
    writeLog(`[Java] ✗ 无法找到 Java ${javaVersion} 的下载信息`);
    return null;
    
  } catch (e) {
    writeLog(`[Java] 获取Java运行时下载信息失败: ${e.message}`);
    return null;
  }
}

// 获取MC版本推荐的Java版本
function getRecommendedJavaVersion(mcVersion) {
  // Minecraft 1.16.5及以下: Java 8
  // Minecraft 1.17: Java 16/17
  // Minecraft 1.18-1.20.4: Java 17
  // Minecraft 1.20.5+: Java 21
  // Minecraft 1.21+: Java 21/25
  // Minecraft 26+: Java 21

  const parts = mcVersion.split('.');
  let major = parseInt(parts[0], 10);
  let minor = parseInt(parts[1], 10);
  let patch = parts.length > 2 ? parseInt(parts[2], 10) : 0;

  // 如果版本号是 "26" 这种没有点的格式
  if (isNaN(major)) major = 1;

  // 处理像 "26" 这种格式（只有 major 没有 minor）
  if (isNaN(minor)) {
    // 26 及以上使用 Java 25
    if (major >= 26) return '25';
    // 21-25 使用 Java 21
    if (major >= 21) return '21';
    return '17';
  }

  // 处理 1.x.x 的旧版本
  if (major === 1) {
    if (minor < 17) return '8';
    if (minor === 17) return '17';
    if (minor <= 20) return '17';
    if (minor === 21 && patch <= 4) return '21';
    if (minor === 21 && patch > 4) return '21';
    if (minor >= 22) return '21';
    return '17';
  }

  // 处理 2.x.x 和更大的版本（21, 24, 26, ...）
  // 26 及以上使用 Java 25
  if (major >= 26) return '25';
  // 21-25 使用 Java 21
  if (major >= 21) return '21';
  return '17';
}

function findJavaExecutableInDir(rootDir) {
  const stack = [rootDir];
  while (stack.length > 0) {
    const current = stack.pop();
    if (!fs.existsSync(current)) continue;
    const javaw = path.join(current, 'bin', 'javaw.exe');
    const java = path.join(current, 'bin', 'java.exe');
    if (fs.existsSync(javaw)) return javaw;
    if (fs.existsSync(java)) return java;
    try {
      const entries = fs.readdirSync(current, { withFileTypes: true });
      for (const e of entries) {
        if (e.isDirectory()) stack.push(path.join(current, e.name));
      }
    } catch (e) {}
  }
  return null;
}

async function fetchText(url) {
  return new Promise((resolve, reject) => {
    let finished = false;

    const fallbackToHttps = (reason) => {
      if (finished) return;
      try {
        const https = require('https');
        const req2 = https.get(url, { timeout: 20000 }, res2 => {
          let body = '';
          res2.on('data', d => body += d);
          res2.on('end', () => { finished = true; resolve(body); });
          res2.on('error', err2 => { if (!finished) { finished = true; reject(err2); } });
        });
        req2.on('timeout', () => { req2.destroy(); if (!finished) { finished = true; reject('超时'); } });
        req2.on('error', err2 => { if (!finished) { finished = true; reject(err2); } });
      } catch (e2) {
        if (!finished) { finished = true; reject(e2); }
      }
    };

    try {
      const req = net.request(url);
      const to = setTimeout(() => { try { req.abort(); } catch {} ; fallbackToHttps('timeout'); }, 20000);

      req.on('response', res => {
        clearTimeout(to);
        let body = '';
        res.on('data', d => body += d);
        res.on('end', () => { if (!finished) { finished = true; resolve(body); } });
        res.on('error', err => { if (!finished) fallbackToHttps(err); });
      });

      req.on('error', err => { if (!finished) fallbackToHttps(err); });
      req.end();
    } catch (e) {
      fallbackToHttps(e);
    }
  });
}

let MAX_CONCURRENT = 128;
let downloadQueue = [];
let activeDownloads = 0;
let totalDownloadFiles = 0;
let completedDownloadFiles = 0;
let currentDownloadSpeed = 0;

async function downloadWithPool(url, dest, label) {
  return new Promise((resolve, reject) => {
    downloadQueue.push({ url, dest, label, resolve, reject });
    processDownloadQueue();
  });
}

async function processDownloadQueue() {
  while (downloadQueue.length > 0 && activeDownloads < MAX_CONCURRENT && !shouldCancelDownload) {
    const task = downloadQueue.shift();
    activeDownloads++;
    downloadFileInternal(task.url, task.dest, task.label)
      .then(() => {
        task.resolve();
      })
      .catch(err => {
        task.reject(err);
      })
      .finally(() => {
        activeDownloads--;
        completedDownloadFiles++;
        processDownloadQueue();
      });
  }
  
  // 如果取消下载，拒绝队列中所有剩余任务
  if (shouldCancelDownload) {
    while (downloadQueue.length > 0) {
      const task = downloadQueue.shift();
      task.reject(new Error('下载已取消'));
    }
    // 通知渲染进程下载已取消
    for (const w of BrowserWindow.getAllWindows()) {
      w.webContents.send('download-cancelled');
    }
  }
}

async function downloadFile(url, dest, label) {
  if (fs.existsSync(dest)) {
    const stat = fs.statSync(dest);
    if (stat.size > 1024) {
      for (const w of BrowserWindow.getAllWindows()) {
        w.webContents.send('download-progress', {
          label,
          percent: 100,
          current: completedDownloadFiles,
          total: totalDownloadFiles
        });
      }
      return;
    }
  }
  await downloadWithPool(url, dest, label);
}

async function downloadFileInternal(url, dest, label) {
  return new Promise((resolve, reject) => {
    const dir = path.dirname(dest);
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

    // 确保使用二进制模式写入
    const file = fs.createWriteStream(dest, { encoding: null });
    let loaded = 0;
    let total = 0;

    const fallbackToHttps = (reason) => {
      writeLog(`[下载] ${label} HTTP请求失败: ${reason}，尝试HTTPS`);
      try {
        const https = require('https');
        
        const options = {
          headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
          }
        };
        
        const req2 = https.get(url, options, res2 => {
          // 处理重定向
          if (res2.statusCode >= 300 && res2.statusCode < 400 && res2.headers.location) {
            writeLog(`[下载] ${label} 重定向到: ${res2.headers.location}`);
            file.close();
            // 递归处理重定向
            downloadFileInternal(res2.headers.location, dest, label).then(resolve).catch(reject);
            return;
          }
          
          total = parseInt(res2.headers['content-length'] || '0', 10);
          
          // 检查内容类型
          const contentType = res2.headers['content-type'] || '';
          if (!contentType.includes('zip') && !contentType.includes('octet-stream')) {
            writeLog(`[下载] ${label} 警告: 内容类型是 ${contentType}，可能不是ZIP文件`);
          }
          
          writeLog(`[下载] ${label} 开始下载，大小: ${total} bytes`);
          
          res2.on('data', d => {
            if (shouldCancelDownload) {
              req2.destroy();
              file.destroy();
              reject(new Error('下载已取消'));
              return;
            }
            loaded += d.length;
            file.write(d);
            const p = total > 0 ? Math.floor((loaded / total) * 100) : 0;
            for (const w of BrowserWindow.getAllWindows()) {
              w.webContents.send('download-progress', {
                label,
                percent: p,
                bytesDownloaded: loaded,
                current: completedDownloadFiles,
                total: totalDownloadFiles
              });
            }
          });
          res2.on('end', () => {
            file.end();
            writeLog(`[下载] ${label} 下载完成，实际大小: ${loaded} bytes`);
            resolve();
          });
          res2.on('error', err2 => {
            file.destroy();
            reject(err2);
          });
        });
        req2.on('timeout', () => { req2.destroy(); reject('超时'); });
        req2.on('error', err2 => {
          file.destroy();
          reject(err2);
        });
      } catch (e2) {
        file.destroy();
        reject(e2);
      }
    };

    try {
      const req = net.request(url);
      const to = setTimeout(() => { try { req.abort(); } catch {} ; fallbackToHttps('timeout'); }, 60000);
      
      // 设置User-Agent头
      req.setHeader('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');

      req.on('response', res => {
        clearTimeout(to);
        
        // 处理重定向
        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
          writeLog(`[下载] ${label} 重定向到: ${res.headers.location}`);
          file.close();
          // 递归处理重定向
          downloadFileInternal(res.headers.location, dest, label).then(resolve).catch(reject);
          return;
        }
        
        total = parseInt(res.headers['content-length'] || '0', 10);
        
        // 检查内容类型
        const contentType = res.headers['content-type'] || '';
        if (!contentType.includes('zip') && !contentType.includes('octet-stream')) {
          writeLog(`[下载] ${label} 警告: 内容类型是 ${contentType}，可能不是ZIP文件`);
        }
        
        writeLog(`[下载] ${label} 开始下载，大小: ${total} bytes`);
        
        res.on('data', d => {
          if (shouldCancelDownload) {
            try { req.abort(); } catch {}
            file.destroy();
            reject(new Error('下载已取消'));
            return;
          }
          loaded += d.length;
          file.write(d);
          const p = total > 0 ? Math.floor((loaded / total) * 100) : 0;
          for (const w of BrowserWindow.getAllWindows()) {
            w.webContents.send('download-progress', {
              label,
              percent: p,
              bytesDownloaded: loaded,
              current: completedDownloadFiles,
              total: totalDownloadFiles
            });
          }
        });
        res.on('end', () => {
          file.end();
          writeLog(`[下载] ${label} 下载完成，实际大小: ${loaded} bytes`);
          resolve();
        });
        res.on('error', err => {
          file.destroy();
          fallbackToHttps(err);
        });
      });

      req.on('error', err => {
        file.destroy();
        fallbackToHttps(err);
      });

      req.end();
    } catch (e) {
      file.destroy();
      fallbackToHttps(e);
    }
  });
}

// 带超时的下载包装器，超时后会抛出错误让调用方尝试下一个源
async function downloadFileInternalWithTimeout(url, dest, label, timeoutMs) {
  return new Promise((resolve, reject) => {
    let settled = false;
    const timer = setTimeout(() => {
      if (!settled) {
        settled = true;
        reject(new Error(`连接超时 (${timeoutMs / 1000}秒)`));
      }
    }, timeoutMs);

    downloadFileInternal(url, dest, label)
      .then(result => {
        if (!settled) {
          settled = true;
          clearTimeout(timer);
          resolve(result);
        }
      })
      .catch(err => {
        if (!settled) {
          settled = true;
          clearTimeout(timer);
          reject(err);
        }
      });
  });
}

async function installVersion(versionId, maxConcurrent = 20, downloadPath = null) {
  const targetDir = downloadPath || path.join(GAME_DIR, 'versions', versionId);
  const versionDir = targetDir;
  const cancelFilePath = path.join(versionDir, 'CancelDownload.txt');
  if (fs.existsSync(cancelFilePath)) {
    try { fs.unlinkSync(cancelFilePath); } catch (e) {}
  }

  // 重置取消标志
  shouldCancelDownload = false;
  isDownloading = true;
  currentDownloadVersion = versionId;
  currentDownloadType = 'game';
  currentDownloadPath = targetDir;
  writeLog(`开始下载：${versionId} 到 ${targetDir}`);

  try {
    MAX_CONCURRENT = maxConcurrent;
    downloadQueue = [];
    activeDownloads = 0;
    totalDownloadFiles = 0;
    completedDownloadFiles = 0;

    const versionDir = path.join(GAME_DIR, 'versions', versionId);
    if (!fs.existsSync(versionDir)) fs.mkdirSync(versionDir, { recursive: true });

    const versionJsonPath = path.join(versionDir, versionId + '.json');
    const versionJarPath = path.join(versionDir, versionId + '.jar');

    // 获取版本清单
    const manifest = JSON.parse(await fetchText('https://piston-meta.mojang.com/mc/game/version_manifest_v2.json'));
    const vInfo = manifest.versions.find(v => v.id === versionId);
    if (!vInfo) throw new Error('版本不存在: ' + versionId);

    // 下载版本JSON
    if (!fs.existsSync(versionJsonPath)) {
      const vData = await fetchText(vInfo.url);
      fs.writeFileSync(versionJsonPath, vData);
    }

    const versionData = JSON.parse(fs.readFileSync(versionJsonPath, 'utf8'));

    // 下载客户端JAR
    if (!fs.existsSync(versionJarPath)) {
      await downloadFile(versionData.downloads.client.url, versionJarPath, '客户端');
    }
    
    // 检查是否取消
    if (shouldCancelDownload) {
      writeLog(`下载取消：${versionId}`);
      throw new Error('下载已取消');
    }

    // 下载资源索引
    const assetIndexPath = path.join(GAME_DIR, 'assets', 'indexes', versionData.assetIndex.id + '.json');
    if (!fs.existsSync(assetIndexPath)) {
      await downloadFile(versionData.assetIndex.url, assetIndexPath, '资源索引');
    }
    
    // 检查是否取消
    if (shouldCancelDownload) {
      writeLog(`下载取消：${versionId}`);
      throw new Error('下载已取消');
    }

    // 等待资源索引下载完成并读取
    let assetIndexData;
    for (let i = 0; i < 10; i++) {
      try {
        assetIndexData = JSON.parse(fs.readFileSync(assetIndexPath, 'utf8'));
        break;
      } catch (e) {
        await new Promise(r => setTimeout(r, 500));
      }
    }
    if (!assetIndexData) throw new Error('无法读取资源索引');

    // 收集所有需要下载的文件
    const toDownload = [];

    // 资源文件
    for (const [name, obj] of Object.entries(assetIndexData.objects)) {
      const hash = obj.hash;
      const prefix = hash.substring(0, 2);
      const assetPath = path.join(GAME_DIR, 'assets', 'objects', prefix, hash);
      if (!fs.existsSync(assetPath)) {
        toDownload.push({
          url: `https://resources.download.minecraft.net/${prefix}/${hash}`,
          dest: assetPath,
          label: `资源: ${name}`
        });
      }
    }

    // 库文件
    for (const lib of versionData.libraries) {
      if (lib.downloads?.artifact) {
        const libPath = path.join(GAME_DIR, 'libraries', lib.downloads.artifact.path);
        if (!fs.existsSync(libPath)) {
          toDownload.push({
            url: lib.downloads.artifact.url,
            dest: libPath,
            label: `库: ${lib.name}`
          });
        }
      }
      if (lib.downloads?.classifiers) {
        for (const [cls, info] of Object.entries(lib.downloads.classifiers)) {
          if (cls.includes('natives-windows')) {
            const libPath = path.join(GAME_DIR, 'libraries', info.path);
            if (!fs.existsSync(libPath)) {
              toDownload.push({
                url: info.url,
                dest: libPath,
                label: `原生库: ${lib.name}`
              });
            }
          }
        }
      }
    }

    totalDownloadFiles = toDownload.length;
    completedDownloadFiles = 0;

    // 并发下载所有文件
    const downloadPromises = toDownload.map(item => downloadFile(item.url, item.dest, item.label));
    await Promise.all(downloadPromises);

    // 解压原生库
    const nativesDir = path.join(GAME_DIR, 'versions', versionId, 'natives');
    if (!fs.existsSync(nativesDir)) fs.mkdirSync(nativesDir, { recursive: true });

    for (const lib of versionData.libraries) {
      if (lib.downloads?.classifiers) {
        for (const [cls, info] of Object.entries(lib.downloads.classifiers)) {
          if (cls.includes('natives-windows')) {
            const libPath = path.join(GAME_DIR, 'libraries', info.path);
            if (fs.existsSync(libPath)) {
              const AdmZip = require('adm-zip');
              const zip = new AdmZip(libPath);
              zip.extractAllTo(nativesDir, true);
            }
          }
        }
      }
    }

    if (shouldCancelDownload) {
      writeLog(`下载取消：${versionId}`);
      throw new Error('下载已取消');
    }

    writeLog(`下载完成：${versionId}`);
    
    // 更新版本最后启动时间
    updateVersionLastPlayed(versionId, targetDir);
    
    return { success: true };
  } catch (e) {
    writeLog(`下载失败：${versionId} - ${e.message}`);
    return { success: false, error: e.message };
  } finally {
    isDownloading = false;
    currentDownloadVersion = null;
    currentDownloadType = null;
    currentDownloadPath = null;
    shouldCancelDownload = false;
    downloadQueue = [];
    activeDownloads = 0;
    totalDownloadFiles = 0;
    completedDownloadFiles = 0;
  }
}

// 更新版本的最后启动时间
function updateVersionLastPlayed(versionId, targetDir) {
  try {
    const versionDir = targetDir || path.join(GAME_DIR, 'versions', versionId);
    const gpclDir = path.join(versionDir, 'gpcl');
    const configPath = path.join(gpclDir, 'config.json');
    
    let settings = {};
    
    // 读取现有配置
    if (fs.existsSync(configPath)) {
      try {
        settings = JSON.parse(fs.readFileSync(configPath, 'utf8'));
      } catch (e) {
        settings = {};
      }
    }
    
    // 更新最后启动时间
    settings.lastPlayed = new Date().toISOString();
    
    // 确保目录存在
    if (!fs.existsSync(gpclDir)) {
      fs.mkdirSync(gpclDir, { recursive: true });
    }
    
    // 保存配置
    fs.writeFileSync(configPath, JSON.stringify(settings, null, 2), 'utf8');
    writeLog(`[版本] ${versionId} 最后启动时间已更新: ${settings.lastPlayed}`);
    
  } catch (e) {
    writeLog(`[版本] 更新 ${versionId} 最后启动时间失败: ${e.message}`);
  }
}

ipcMain.handle('scan-versions', async (_, gameDir, silent = false) => {
  const targetDir = gameDir ? path.resolve(gameDir) : GAME_DIR;
  const versionsDir = path.join(targetDir, 'versions');
  if (!fs.existsSync(versionsDir)) {
    if (!silent) writeLog('扫描本地版本：未找到versions目录');
    return [];
  }
  const entries = fs.readdirSync(versionsDir, { withFileTypes: true });
  const versions = [];
  const skippedVersions = [];
  
  for (const entry of entries) {
    if (entry.isDirectory()) {
      const versionDir = path.join(versionsDir, entry.name);
      try {
        const files = fs.readdirSync(versionDir);
        
        // 检查是否只有一个 CancelDownload.txt 文件
        if (files.length === 1 && files[0] === 'CancelDownload.txt') {
          skippedVersions.push(entry.name);
          if (!silent) writeLog(`扫描本地版本：跳过空目录 "${entry.name}"（仅包含 CancelDownload.txt）`);
          continue;
        }
        
        // 查找所有 .json 文件
        const jsonFiles = files.filter(f => f.endsWith('.json'));
        
        // 如果没有 .json 文件，跳过
        if (jsonFiles.length === 0) {
          skippedVersions.push(entry.name);
          if (!silent) writeLog(`扫描本地版本：跳过 "${entry.name}"（无 .json 文件）`);
          continue;
        }
        
        // 收集所有版本（包括原版和带模组加载器的版本）
        // 原版: 1.21.1 -> versionId = "1.21.1"
        // Forge: 1.21.1-forge -> versionId = "1.21.1-forge"
        // Fabric: 1.21.1-fabric -> versionId = "1.21.1-fabric"
        
        const baseVersionId = entry.name; // 文件夹名
        const mcVersion = baseVersionId; // MC 版本号
        
        // 总是添加原版
        if (jsonFiles.includes(`${baseVersionId}.json`)) {
          versions.push(baseVersionId);
        }
        
        // 检查是否有模组加载器版本
        for (const jsonFile of jsonFiles) {
          const jsonVersionId = jsonFile.replace('.json', '');
          // 如果不是原版，且不在列表中，添加它
          if (jsonVersionId !== baseVersionId && !versions.includes(jsonVersionId)) {
            versions.push(jsonVersionId);
          }
        }
        
      } catch (e) {
        writeLog(`扫描本地版本：读取目录 "${entry.name}" 失败 - ${e.message}`);
      }
    }
  }
  
  if (skippedVersions.length > 0 && !silent) {
    writeLog(`扫描本地版本：跳过 ${skippedVersions.length} 个无效目录 - [${skippedVersions.join(', ')}]`);
  }
  if (!silent) writeLog(`扫描本地版本：共 ${versions.length} 个版本 - [${versions.join(', ')}]`);
  return versions;
});

ipcMain.handle('get-version-manifest', async () => {
  try {
    if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
    const cacheFile = path.join(CACHE_DIR, 'version_manifest.json');

    let data;
    let fromCache = false;
    if (fs.existsSync(cacheFile)) {
      const stat = fs.statSync(cacheFile);
      const age = Date.now() - stat.mtimeMs;
      if (age < 10 * 60 * 1000) {
        data = fs.readFileSync(cacheFile, 'utf8');
        fromCache = true;
      }
    }

    if (!data) {
      try {
        data = await fetchText('https://piston-meta.mojang.com/mc/game/version_manifest_v2.json');
        fs.writeFileSync(cacheFile, data);
        writeLog('远程拉取版本列表：成功');
      } catch (e) {
        writeLog(`远程拉取版本列表：失败 - ${e.message}`);
        return [];
      }
    } else {
      writeLog(`读取本地缓存版本列表：成功`);
    }

    const parsed = JSON.parse(data);
    // 返回所有类型的版本，包括正式版、快照版、旧测试版
    writeLog(`版本列表：共 ${parsed.versions.length} 个版本`);
    return parsed.versions;
  } catch (e) {
    writeLog(`版本列表解析失败：${e.message}`);
    return [];
  }
});

ipcMain.handle('download-version', (event, versionId, maxConcurrent, downloadPath) => installVersion(versionId, maxConcurrent, downloadPath));

ipcMain.handle('download-with-modloader', (event, versionId, loaderType, loaderVersion, maxConcurrent) => 
  installVersionWithModLoader(versionId, loaderType, loaderVersion, maxConcurrent));

ipcMain.handle('get-version-config', (event, versionId) => readVersionConfig(versionId));
ipcMain.handle('get-version-display-name', (event, versionId) => generateVersionDisplayName(versionId));
ipcMain.handle('get-launch-display-name', (event, versionId) => generateLaunchDisplayName(versionId));

ipcMain.handle('delete-version', async (_, versionId) => {
  try {
    const versionDir = path.join(GAME_DIR, 'versions', versionId);
    
    if (!fs.existsSync(versionDir)) {
      return { success: false, error: '版本不存在' };
    }
    
    writeLog(`[删除版本] 开始删除版本: ${versionId}`);
    
    fs.rmSync(versionDir, { recursive: true, force: true });
    
    writeLog(`[删除版本] 版本 ${versionId} 删除成功`);
    
    return { success: true };
  } catch (e) {
    writeLog(`[删除版本] 删除版本失败: ${e.message}`);
    return { success: false, error: e.message };
  }
});

ipcMain.handle('get-version-settings', async (_, versionId) => {
  try {
    const versionDir = path.join(GAME_DIR, 'versions', versionId);
    const gpclDir = path.join(versionDir, 'gpcl');
    const configPath = path.join(gpclDir, 'config.json');
    
    if (!fs.existsSync(configPath)) {
      return { success: true, settings: null };
    }
    
    const content = fs.readFileSync(configPath, 'utf8');
    const settings = JSON.parse(content);
    
    return { success: true, settings };
  } catch (e) {
    writeLog(`[版本设置] 读取版本 ${versionId} 设置失败: ${e.message}`);
    return { success: false, error: e.message, settings: null };
  }
});

ipcMain.handle('save-version-settings', async (_, versionId, settings) => {
  try {
    const versionDir = path.join(GAME_DIR, 'versions', versionId);
    const gpclDir = path.join(versionDir, 'gpcl');
    
    if (!fs.existsSync(gpclDir)) {
      fs.mkdirSync(gpclDir, { recursive: true });
    }
    
    const configPath = path.join(gpclDir, 'config.json');
    
    // 保存设置
    fs.writeFileSync(configPath, JSON.stringify(settings, null, 2), 'utf8');
    
    writeLog(`[版本设置] 版本 ${versionId} 设置已保存`);
    
    return { success: true };
  } catch (e) {
    writeLog(`[版本设置] 保存版本 ${versionId} 设置失败: ${e.message}`);
    return { success: false, error: e.message };
  }
});

ipcMain.handle('get-game-dir', () => {
  return GAME_DIR;
});

ipcMain.handle('get-player-name', () => {
  try {
    const playerFile = path.join(app.getPath('userData'), 'gpcl', 'player.json');
    if (fs.existsSync(playerFile)) {
      const data = JSON.parse(fs.readFileSync(playerFile, 'utf8'));
      return data.name || 'GPCL_Player';
    }
  } catch (e) {
    console.error('读取玩家名失败:', e);
  }
  return 'GPCL_Player';
});

ipcMain.handle('save-player-name', (_, name) => {
  try {
    const gpclDir = path.join(app.getPath('userData'), 'gpcl');
    if (!fs.existsSync(gpclDir)) fs.mkdirSync(gpclDir, { recursive: true });
    const playerFile = path.join(gpclDir, 'player.json');
    fs.writeFileSync(playerFile, JSON.stringify({ name: name || 'GPCL_Player' }));
    return { success: true };
  } catch (e) {
    console.error('保存玩家名失败:', e);
    return { success: false, error: e.message };
  }
});

ipcMain.handle('window-minimize', () => {
  if (mainWindow) mainWindow.minimize();
  return { success: true };
});

ipcMain.handle('window-focus', () => {
  if (mainWindow) {
    if (mainWindow.isMinimized()) {
      mainWindow.restore();
    }
    mainWindow.show();
    mainWindow.focus();
  }
  return { success: true };
});

ipcMain.handle('window-close', () => {
  if (mainWindow) mainWindow.close();
  return { success: true };
});

ipcMain.handle('select-directory', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory']
  });
  if (result.canceled || result.filePaths.length === 0) {
    return null;
  }
  return result.filePaths[0];
});

// 检查指定Minecraft版本所需的Java是否已安装
ipcMain.handle('check-java', async (_, versionOrJavaVersion) => {
  try {
    // 判断是Minecraft版本号还是Java版本号
    const isMcVersion = versionOrJavaVersion && versionOrJavaVersion.match(/^\d+\.\d+/);
    
    if (isMcVersion) {
      // Minecraft版本，检查该版本需要的Java
      const versionId = versionOrJavaVersion;
      const jsonPath = path.join(GAME_DIR, 'versions', versionId, versionId + '.json');
      if (!fs.existsSync(jsonPath)) {
        return { success: false, error: '版本未下载' };
      }
      
      const versionData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
      const javaVersion = getJavaVersionFromVersionData(versionData);
      const result = await checkJavaInstalled(javaVersion);
      
      return {
        success: true,
        installed: result.installed,
        javaVersion: javaVersion,
        javaPath: result.javaPath
      };
    } else {
      // Java版本，直接检查该版本是否安装
      const javaVersion = versionOrJavaVersion;
      const result = await checkJavaInstalled(javaVersion);
      
      return {
        success: true,
        installed: result.installed,
        javaVersion: javaVersion,
        javaPath: result.javaPath
      };
    }
  } catch (e) {
    writeLog(`检查Java失败：${e.message}`);
    return { success: false, error: e.message };
  }
});

// 解析 Minecraft 启动参数模板
function parseMCArguments(template, vars) {
  let result = template;
  for (const [key, value] of Object.entries(vars)) {
    result = result.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), value);
  }
  return result;
}

// 智能分割参数（处理引号内的空格）
function splitArgs(str) {
  const args = [];
  let current = '';
  let inQuotes = false;
  for (let i = 0; i < str.length; i++) {
    const c = str[i];
    if (c === '"') {
      inQuotes = !inQuotes;
    } else if (c === ' ' && !inQuotes) {
      if (current.length > 0) {
        args.push(current);
        current = '';
      }
    } else {
      current += c;
    }
  }
  if (current.length > 0) {
    args.push(current);
  }
  return args;
}

// 检查库规则是否允许当前平台
function checkLibraryRules(rules) {
  if (!rules || rules.length === 0) return true;
  let allowed = false;
  for (const rule of rules) {
    let match = true;
    if (rule.os) {
      const platform = os.platform();
      if (rule.os.name === 'windows' && platform !== 'win32') match = false;
      if (rule.os.name === 'linux' && platform !== 'linux') match = false;
      if (rule.os.name === 'osx' && platform !== 'darwin') match = false;
    }
    if (match) {
      allowed = (rule.action === 'allow');
    }
  }
  return allowed;
}

// 构建 Minecraft 启动参数
function buildLaunchArgs(vd, gameDir, versionId, username, windowMode, memoryMB, serverIp) {
  const cp = [];
  // 优先使用 downloads.client 的 jar 路径
  const clientJar = path.join(gameDir, 'versions', versionId, `${versionId}.jar`);
  if (fs.existsSync(clientJar)) {
    cp.push(clientJar);
  }
  // 添加库（带平台规则过滤）
  let missingLibs = 0;
  for (const lib of vd.libraries || []) {
    if (!checkLibraryRules(lib.rules)) continue;
    // 普通 artifact
    if (lib.downloads?.artifact?.path) {
      const libPath = path.join(gameDir, 'libraries', lib.downloads.artifact.path);
      if (fs.existsSync(libPath)) {
        cp.push(libPath);
      } else {
        missingLibs++;
        writeLog(`[启动] 库文件缺失: ${lib.downloads.artifact.path}`);
      }
    }
    // Natives（Windows 平台）
    if (lib.downloads?.classifiers?.['natives-windows']?.path) {
      const nativePath = path.join(gameDir, 'libraries', lib.downloads.classifiers['natives-windows'].path);
      if (fs.existsSync(nativePath)) {
        cp.push(nativePath);
      } else {
        missingLibs++;
        writeLog(`[启动] Native库缺失: ${lib.downloads.classifiers['natives-windows'].path}`);
      }
    }
  }
  if (missingLibs > 0) {
    writeLog(`[启动] 警告: ${missingLibs} 个库文件缺失`);
  }

  const nativesDir = path.join(gameDir, 'versions', versionId, 'natives');
  const assetsDir = path.join(gameDir, 'assets');

  const jvmArgs = [
    `-Djava.library.path=${nativesDir}`,
    '-cp', cp.join(';'),
  ];

  // 添加内存参数
  if (memoryMB) {
    jvmArgs.unshift(`-Xmx${memoryMB}M`);
    writeLog(`[启动] 已设置最大内存: ${memoryMB}M`);
  } else {
    writeLog(`[启动] 未设置内存限制`);
  }

  const vars = {
    auth_player_name: username,
    version_name: versionId,
    game_directory: gameDir,
    assets_root: assetsDir,
    assets_index_name: vd.assetIndex?.id || vd.assets || versionId,
    auth_uuid: '00000000000000000000000000000000',
    auth_access_token: 'offline',
    auth_session: 'offline',
    user_type: 'legacy',
    user_properties: '{}',
    version_type: 'GPCL'
  };

  let gameArgs = [];

  // 新版格式 (1.13+)
  if (vd.arguments?.game) {
    for (const arg of vd.arguments.game) {
      if (typeof arg === 'string') {
        gameArgs.push(parseMCArguments(arg, vars));
      }
      // 忽略条件参数（简化处理）
    }
  }
  // 旧版格式 (1.12.2 及以下)
  else if (vd.minecraftArguments) {
    const parsed = parseMCArguments(vd.minecraftArguments, vars);
    gameArgs = splitArgs(parsed);
  }
  // 兜底
  else {
    gameArgs = [
      '--username', username,
      '--version', versionId,
      '--gameDir', gameDir,
      '--assetsDir', assetsDir,
      '--assetIndex', vd.assetIndex?.id || vd.assets || versionId,
      '--accessToken', 'offline',
      '--userType', 'legacy'
    ];
  }

  // 根据窗口模式添加参数
  if (windowMode === 'fullscreen') {
    gameArgs.push('--fullscreen');
    writeLog(`[启动] 已添加全屏参数: --fullscreen`);
  } else if (windowMode === 'borderless') {
    // 无边框窗口模式：使用全屏但无边框的分辨率
    gameArgs.push('--fullscreen');
    gameArgs.push('--width');
    gameArgs.push('1920');
    gameArgs.push('--height');
    gameArgs.push('1080');
    writeLog(`[启动] 已添加无边框窗口参数: --fullscreen --width 1920 --height 1080`);
  } else if (windowMode === 'minimized') {
    // 最小化模式，不添加特殊参数，但会在游戏启动后自动最小化
    writeLog(`[启动] 已设置最小化模式`);
  }

  // 如果有服务器IP，添加服务器连接参数
  if (serverIp && serverIp.trim()) {
    const ipParts = serverIp.trim().split(':');
    const serverAddress = ipParts[0];
    const serverPort = ipParts[1] || '25565';
    
    gameArgs.push('--server');
    gameArgs.push(serverAddress);
    gameArgs.push('--port');
    gameArgs.push(serverPort);
    
    writeLog(`[启动] 已添加服务器连接参数: --server ${serverAddress} --port ${serverPort}`);
  }

  return { jvmArgs, gameArgs, mainClass: vd.mainClass };
}

ipcMain.handle('launch-minecraft', async (_, opt) => {
  try {
    // 重置取消标志
    launchCancelFlag = false;
    
    const { versionId, username, gameDir: rawGameDir, windowMode } = opt;
    // 使用传入的路径或默认的 GAME_DIR
    const gameDir = rawGameDir ? path.resolve(rawGameDir) : GAME_DIR;
    // 窗口模式：fullscreen, windowed, borderless
    const mode = windowMode || 'windowed';
    writeLog(`启动游戏：玩家 ${username}，版本 ${versionId}，目录: ${gameDir}，窗口模式: ${mode}`);
    
    // 检查是否已取消
    if (launchCancelFlag) {
      writeLog('[启动] 用户已取消启动');
      return { success: false, error: '启动已取消', cancelled: true };
    }
    
    const jsonPath = path.join(gameDir, 'versions', versionId, `${versionId}.json`);
    if (!fs.existsSync(jsonPath)) {
      writeLog(`启动游戏失败：版本 ${versionId} 未下载`);
      return { success: false, error: '请先下载游戏' };
    }

    const vd = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
    const javaVersion = getJavaVersionFromVersionData(vd);
    
    // 检查是否已取消
    if (launchCancelFlag) {
      writeLog('[启动] 用户已取消启动');
      return { success: false, error: '启动已取消', cancelled: true };
    }
    
    // 加载设置
    const settings = loadSettings();
    let memoryMB = null;
    let actualWindowMode = mode;
    let serverIp = null;
    
    // 首先检查是否有版本特定设置
    try {
      const versionConfigPath = path.join(gameDir, 'versions', versionId, 'gpcl', 'config.json');
      if (fs.existsSync(versionConfigPath)) {
        const versionSettings = JSON.parse(fs.readFileSync(versionConfigPath, 'utf8'));
        
        // 处理内存设置
        if (versionSettings.memory && versionSettings.memory !== 'global') {
          const memoryVal = parseFloat(versionSettings.memory);
          if (!isNaN(memoryVal)) {
            if (versionSettings.memory === '0.5') {
              memoryMB = 512; // 0.5GB = 512MB
            } else {
              memoryMB = Math.floor(memoryVal * 1024);
            }
            writeLog(`[启动] 使用版本内存设置: ${memoryMB}M`);
          }
        }
        
        // 处理窗口模式设置
        if (versionSettings.windowMode && versionSettings.windowMode !== 'global') {
          actualWindowMode = versionSettings.windowMode;
          writeLog(`[启动] 使用版本窗口模式: ${actualWindowMode}`);
        }
        
        // 处理启动模式和服务器IP
        if (versionSettings.startupMode === 'join' && versionSettings.serverIp) {
          serverIp = versionSettings.serverIp;
          writeLog(`[启动] 使用版本启动模式: 加入服务器 ${serverIp}`);
        }
      }
    } catch (e) {
      writeLog(`[启动] 读取版本设置失败: ${e.message}`);
    }
    
    // 如果没有版本特定设置，使用全局设置
    if (memoryMB === null && settings.game?.memory) {
      const globalMemory = parseFloat(settings.game.memory);
      if (!isNaN(globalMemory)) {
        memoryMB = Math.floor(globalMemory * 1024);
        writeLog(`[启动] 使用全局内存设置: ${memoryMB}M`);
      }
    }
    
    // 检查是否已取消
    if (launchCancelFlag) {
      writeLog('[启动] 用户已取消启动');
      return { success: false, error: '启动已取消', cancelled: true };
    }
    
    // 检查Java是否已安装
    let java = await ensureJavaRuntime(javaVersion);
    
    // 检查是否已取消（在Java检查后）
    if (launchCancelFlag) {
      writeLog('[启动] 用户已取消启动');
      return { success: false, error: '启动已取消', cancelled: true };
    }
    
    // 如果Java未安装，自动下载
    if (!java) {
      writeLog(`[Java] Java ${javaVersion} 未安装，自动开始下载`);
      
      // 发送通知给渲染进程
      if (mainWindow) {
        mainWindow.webContents.send('java-auto-download-start', {
          javaVersion: javaVersion,
          mcVersion: versionId
        });
      }
      
      // 自动下载并安装Java（期间检查取消标志）
      const installResult = await downloadAndInstallJava(javaVersion);
      
      // 检查是否已取消（在Java下载后）
      if (launchCancelFlag) {
        writeLog('[启动] 用户已取消启动（Java下载完成后）');
        return { success: false, error: '启动已取消', cancelled: true };
      }
      
      if (installResult.success) {
        java = installResult.javaPath;
        writeLog(`[Java] Java ${javaVersion} 安装成功: ${java}`);
        
        // 发送安装完成通知
        if (mainWindow) {
          mainWindow.webContents.send('java-auto-download-complete', {
            javaVersion: javaVersion,
            javaPath: java
          });
        }
      } else {
        writeLog(`[Java] Java ${javaVersion} 安装失败: ${installResult.error}`);
        return {
          success: false,
          error: `Java ${javaVersion} 安装失败: ${installResult.error}`
        };
      }
    }

    // 最终检查是否已取消（在启动游戏前）
    if (launchCancelFlag) {
      writeLog('[启动] 用户已取消启动（即将启动游戏前）');
      return { success: false, error: '启动已取消', cancelled: true };
    }

    const { jvmArgs, gameArgs, mainClass } = buildLaunchArgs(vd, gameDir, versionId, username, actualWindowMode, memoryMB, serverIp);
    const args = [...jvmArgs, mainClass, ...gameArgs];

    writeLog(`[启动] Java: ${java}`);
    writeLog(`[启动] 主类: ${mainClass}`);
    writeLog(`[启动] 窗口模式: ${actualWindowMode}`);
    writeLog(`[启动] 参数数: ${args.length}`);
    writeLog(`[启动] JVM参数: ${JSON.stringify(jvmArgs)}`);
    writeLog(`[启动] 游戏参数: ${JSON.stringify(gameArgs.slice(0, 10))}...`);
    writeLog(`[启动] Classpath条目数: ${jvmArgs[2].split(';').length}`);
    writeLog(`[启动] Classpath总长度: ${jvmArgs[2].length} 字符`);

    let proc;
    for (let i = 0; i < 3; i++) {
      try {
        proc = spawn(java, args, { cwd: gameDir, detached: false, windowsHide: false });
        writeLog(`启动游戏成功：PID ${proc.pid}`);
        break;
      } catch (e) {
        if (e.code === 'EBUSY' && i < 2) {
          await new Promise(r => setTimeout(r, 1500));
          continue;
        }
        writeLog(`启动游戏失败：${e.message}`);
        return { success: false, error: e.message };
      }
    }

    currentGameProcess = proc;
    currentGamePid = proc.pid;

    // 如果已经被取消，立即杀死
    if (launchCancelFlag) {
      writeLog('[启动] 进程已启动但取消标志已设置，立即终止');
      killGameProcessTree(proc.pid);
      try { proc.kill(); } catch {}
      currentGameProcess = null;
      currentGamePid = null;
      return { success: false, error: '启动已取消', cancelled: true };
    }

    // 检测游戏窗口创建成功
    await detectGameWindow(proc.pid);

    // 检测结束后再次检查取消标志（可能在窗口检测期间被取消）
    if (launchCancelFlag) {
      writeLog('[启动] 窗口检测结束后检测到取消标志');
      return { success: false, error: '启动已取消', cancelled: true };
    }

    // 捕获输出用于调试
    let stdoutData = '';
    let stderrData = '';
    proc.stdout?.on('data', d => {
      const text = d.toString();
      stdoutData += text;
      if (mainWindow) {
        mainWindow.webContents.send('game-log', text);
      }

      if (text.includes('LWJGL Version') || text.includes('OpenGL version') || text.includes('Window')) {
        writeLog(`[启动] 检测到窗口初始化日志`);
        if (mainWindow) {
          mainWindow.webContents.send('game-window-created', { pid: proc.pid });
        }
      }
    });
    proc.stderr?.on('data', d => {
      const text = d.toString();
      stderrData += text;
      if (mainWindow) {
        mainWindow.webContents.send('game-log', text);
      }

      if (text.includes('LWJGL Version') || text.includes('OpenGL version') || text.includes('Window')) {
        writeLog(`[启动] 检测到窗口初始化日志`);
        if (mainWindow) {
          mainWindow.webContents.send('game-window-created', { pid: proc.pid });
        }
      }
    });
    proc.on('error', (err) => {
      writeLog(`[启动] 进程错误: ${err.message}`);
    });
    proc.on('exit', (code) => {
      writeLog(`[启动] 进程退出，代码: ${code}`);
      if (code !== 0 && stderrData) {
        writeLog(`[启动] 错误输出: ${stderrData.slice(0, 1000)}`);
      }
      if (currentGamePid === proc.pid) {
        currentGameProcess = null;
        currentGamePid = null;
      }
      if (mainWindow) {
        mainWindow.webContents.send('game-closed', code);
      }
    });

    return { success: true, pid: proc.pid };
  } catch (e) {
    writeLog(`启动游戏异常：${e.message}`);
    return { success: false, error: e.message };
  }
});

// 检测游戏窗口创建成功
async function detectGameWindow(pid) {
  writeLog(`[启动] 开始检测游戏窗口，PID: ${pid}`);

  return new Promise((resolve) => {
    let resolved = false;
    const done = () => {
      if (resolved) return;
      resolved = true;
      resolve();
    };

    const cancelCheck = setInterval(() => {
      if (launchCancelFlag) {
        writeLog(`[启动] 窗口检测期间检测到取消标志，立即终止游戏进程并退出`);
        clearInterval(cancelCheck);
        try { detector.kill(); } catch {}
        killGameProcessTree(pid);
        try {
          if (currentGameProcess) { currentGameProcess.kill(); }
        } catch {}
        currentGameProcess = null;
        currentGamePid = null;
        done();
      }
    }, 100);

    const timeout = setTimeout(() => {
      writeLog(`[启动] 游戏窗口检测超时（8秒），继续启动流程`);
      clearInterval(cancelCheck);
      try { detector.kill(); } catch {}
      if (mainWindow && !launchCancelFlag) {
        mainWindow.webContents.send('game-window-created', { pid, timeout: true });
      }
      done();
    }, 8000);

    const script = `
      $deadline = (Get-Date).AddSeconds(7)
      while ((Get-Date) -lt $deadline) {
        try {
          $p = Get-Process -Id ${pid} -ErrorAction Stop
          if ($p.MainWindowHandle -ne 0) { Write-Output "FOUND"; exit 0 }
        } catch { Write-Output "GONE"; exit 1 }
        Start-Sleep -Milliseconds 150
      }
      Write-Output "TIMEOUT"; exit 2
    `;
    const detector = spawn('powershell', ['-NoProfile', '-Command', script], { windowsHide: true });
    let output = '';

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

    detector.on('close', (code) => {
      clearInterval(cancelCheck);
      clearTimeout(timeout);

      if (launchCancelFlag) { done(); return; }

      if (output.includes('FOUND')) {
        writeLog(`[启动] 检测到游戏窗口（MainWindowHandle != 0）`);
      } else if (output.includes('GONE')) {
        writeLog(`[启动] 进程已退出`);
      } else {
        writeLog(`[启动] 窗口检测结束，code=${code}，output=${output.trim()}`);
      }

      if (mainWindow) {
        mainWindow.webContents.send('game-window-created', { pid, windowDetected: output.includes('FOUND') });
      }
      done();
    });

    detector.on('error', (err) => {
      clearInterval(cancelCheck);
      clearTimeout(timeout);
      writeLog(`[启动] 窗口检测器启动失败: ${err.message}`);
      if (mainWindow && !launchCancelFlag) {
        mainWindow.webContents.send('game-window-created', { pid, error: true });
      }
      done();
    });
  });
}

// IPC: 下载并安装Java运行时
ipcMain.handle('install-java', async (_, javaVersion) => {
  try {
    writeLog(`[Java] 开始安装 Java ${javaVersion}`);
    
    // 发送下载开始消息
    if (mainWindow) {
      mainWindow.webContents.send('java-download-started', { javaVersion });
    }
    
    const result = await downloadAndInstallJava(javaVersion);
    
    if (result.success) {
      writeLog(`[Java] Java ${javaVersion} 安装成功: ${result.javaPath}`);
      if (mainWindow) {
        mainWindow.webContents.send('java-download-completed', {
          javaVersion,
          javaPath: result.javaPath
        });
      }
      return result;
    } else {
      writeLog(`[Java] Java ${javaVersion} 安装失败: ${result.error}`);
      if (mainWindow) {
        mainWindow.webContents.send('java-download-failed', {
          javaVersion,
          error: result.error
        });
      }
      return result;
    }
  } catch (e) {
    writeLog(`[Java] 安装Java异常: ${e.message}`);
    if (mainWindow) {
      mainWindow.webContents.send('java-download-failed', {
        javaVersion,
        error: e.message
      });
    }
    return { success: false, error: e.message };
  }
});

let currentSettings = null;

ipcMain.handle('get-settings', () => {
  if (!currentSettings) {
    currentSettings = loadSettings();
  }
  return currentSettings;
});

ipcMain.handle('save-settings', (_, settings) => {
  currentSettings = mergeWithDefaults(settings);
  const success = saveSettings(currentSettings);
  return { success, settings: currentSettings };
});

ipcMain.handle('reset-settings', () => {
  currentSettings = JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
  const success = saveSettings(currentSettings);
  return { success, settings: currentSettings };
});

ipcMain.handle('restart-app', () => {
  writeLog('[重启] 正在重启应用...');
  app.relaunch();
  app.exit();
});

ipcMain.handle('set-developer-mode', (_, enabled) => {
  isDeveloperMode = !!enabled;
  writeLog('[开发者模式] ' + (isDeveloperMode ? '已启用' : '已禁用'));
  return { success: true };
});

let activeAnimWindow = null;

function cleanupAnimTempDir(dir) {
  try {
    if (fs.existsSync(dir)) {
      fs.rmSync(dir, { recursive: true, force: true });
    }
  } catch (e) {}
}

ipcMain.handle('play-startup-animation', async () => {
  if (activeAnimWindow && !activeAnimWindow.isDestroyed()) {
    try { activeAnimWindow.close(); } catch (e) {}
    activeAnimWindow = null;
  }

  writeLog('[启动动画] 开始播放启动动画');

  const iconDir = path.join(__dirname, 'static', 'icon');
  const tempAnimDir = path.join(app.getPath('temp'), 'gpcl-anim-' + Date.now());
  try { fs.mkdirSync(tempAnimDir, { recursive: true }); } catch (e) {}

  var imageNames = ['caellab.png', 'gamets.png', 'gamets.ico', 'GPCL.png'];
  for (var _i = 0; _i < imageNames.length; _i++) {
    var src = path.join(iconDir, imageNames[_i]);
    if (fs.existsSync(src)) {
      try { fs.copyFileSync(src, path.join(tempAnimDir, imageNames[_i])); } catch (e) {}
    }
  }

  var hasCaelab = fs.existsSync(path.join(tempAnimDir, 'caellab.png'));
  var hasGamets = fs.existsSync(path.join(tempAnimDir, 'gamets.png')) || fs.existsSync(path.join(tempAnimDir, 'gamets.ico'));
  var hasGpcl = fs.existsSync(path.join(tempAnimDir, 'GPCL.png'));
  var gametsFile = fs.existsSync(path.join(tempAnimDir, 'gamets.png')) ? 'gamets.png' : 'gamets.ico';

  writeLog('[启动动画] 资源: caellab=' + hasCaelab + ' gamets=' + hasGamets + ' gpcl=' + hasGpcl);

  var ANIM_DURATION = 30;

  var htmlContent = '<!DOCTYPE html>\n<html><head><meta charset="utf-8"><style>\n' +
'*{margin:0;padding:0;box-sizing:border-box}\n' +
'html,body{width:100%;height:100%;overflow:hidden;background:#0a0a0a}\n' +
'canvas{position:fixed;top:0;left:0;width:100%;height:100%;z-index:1}\n' +
'.scene{position:fixed;top:0;left:0;width:100%;height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;pointer-events:none;z-index:10;opacity:0}\n' +
'#welcome-txt{text-align:center;font-family:"Microsoft YaHei","Segoe UI",sans-serif}\n' +
'#welcome-txt h1{font-size:56px;font-weight:700;color:#fff;letter-spacing:3px;text-shadow:0 0 25px rgba(91,135,49,0.6),0 0 50px rgba(91,135,49,0.2);margin-bottom:16px}\n' +
'#welcome-txt p{font-size:20px;color:rgba(180,180,180,0.7);letter-spacing:5px}\n' +
'.logo-row{display:flex;flex-direction:row;align-items:center;justify-content:center}\n' +
'#logo-caellab img{max-height:130px;max-width:300px;object-fit:contain;filter:drop-shadow(0 0 18px rgba(91,135,49,0.35))}\n' +
'#logo-both .logo-row{gap:50px}\n' +
'#logo-both img{max-height:110px;max-width:240px;object-fit:contain}\n' +
'#logo-both .caellab-img{filter:drop-shadow(0 0 18px rgba(91,135,49,0.35))}\n' +
'#logo-both .gamets-img{filter:drop-shadow(0 0 14px rgba(255,255,255,0.25))}\n' +
'#logo-gpcl img{max-height:170px;max-width:340px;object-fit:contain;filter:drop-shadow(0 0 25px rgba(91,135,49,0.4))}\n' +
'.logo-text{text-align:center;font-family:"Microsoft YaHei","Segoe UI",sans-serif;margin-top:18px}\n' +
'.logo-text-bottom{position:absolute;bottom:40px;left:0;width:100%;margin-top:0}\n' +
'.logo-title{font-size:20px;color:rgba(200,200,200,0.85);letter-spacing:4px;margin-bottom:6px}\n' +
'.footer-link{font-size:14px;color:rgba(91,135,49,0.7);text-decoration:underline;pointer-events:auto;cursor:pointer}\n' +
'.copyright{font-size:13px;color:rgba(160,160,160,0.6);letter-spacing:1px;margin-bottom:6px}\n' +
'.license-text{font-size:12px;color:rgba(140,140,140,0.5);margin:0}\n' +
'.license-text .footer-link{font-size:12px}\n' +
'.disclaimer{font-size:12px;color:rgba(120,120,120,0.45);max-width:600px;line-height:1.6;margin:40px auto 0;text-align:center}\n' +
'#sweep-line{position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:25;opacity:0}\n' +
'#sweep-line .band{position:absolute;top:0;height:100%;width:100px;background:linear-gradient(90deg,transparent,rgba(91,135,49,0.1),rgba(127,255,0,0.12),rgba(91,135,49,0.1),transparent)}\n' +
'#fade{position:fixed;top:0;left:0;width:100%;height:100%;background:#0a0a0a;opacity:0;pointer-events:none;z-index:30;transition:opacity 1.5s ease-in}\n' +
'#fade.show{opacity:1}\n' +
'#flash{position:fixed;top:0;left:0;width:100%;height:100%;background:#fff;opacity:0;pointer-events:none;z-index:28}\n' +
'</style></head><body>\n' +
'<canvas id="c"></canvas>\n' +
'<div class="scene" id="welcome"><div id="welcome-txt"><h1>Minecraft\u6B22\u8FCE\u4F60\uFF01</h1><p>By GPCL And AllMinecraftPlayer</p></div></div>\n' +
'<div class="scene" id="logo-caellab"><div class="logo-row"><img src="caellab.png" alt="CaelLab"></div><div class="logo-text"><div class="logo-title">\u865A\u821F\u5B9E\u9A8C\u5BA4</div><a href="https://www.caellab.com" target="_blank" class="footer-link">caellab.com</a></div></div>\n' +
'<div class="scene" id="logo-both"><div class="logo-row"><img class="caellab-img" src="caellab.png" alt="CaelLab"><img class="gamets-img" src="' + gametsFile + '" alt="GameTS"></div><div class="logo-text logo-text-bottom"><div class="copyright">Copyright \u00A9 2026 Yunyun(\u4E91\u4E91) By \u865A\u821F\u5B9E\u9A8C\u5BA4(CaelLab) / CaelLabGameTS</div><p class="license-text">Licensed under <a href="https://www.caellab.com/license/bysa-code" target="_blank" class="footer-link">CaelLab BY-SA Code License</a>. Open Source on <a href="https://github.com/yunyun-3782/GoodPlanCraftLaunCher" target="_blank" class="footer-link">GitHub</a>.</p></div></div>\n' +
'<div class="scene" id="logo-gpcl"><img src="GPCL.png" alt="GPCL"><div class="logo-text logo-text-bottom"><div class="disclaimer">GoodPlanCraftLauncher \u4E0E Mojang Studios \u53CA Microsoft\u3001Xbox \u65E0\u5B98\u65B9\u5173\u8054\u3002Minecraft \u4E3A Mojang Studios \u5546\u6807\u3002</div></div></div>\n' +
'<div id="sweep-line"><div class="band" id="sweep-band"></div></div>\n' +
'<div id="flash"></div><div id="fade"></div>\n' +
'<script>\n' +
'(function(){\n' +
'var canvas=document.getElementById("c"),ctx=canvas.getContext("2d");\n' +
'var W,H,dpr=window.devicePixelRatio||1;\n' +
'function resize(){W=window.innerWidth;H=window.innerHeight;canvas.width=W*dpr;canvas.height=H*dpr;ctx.setTransform(dpr,0,0,dpr,0,0)}\n' +
'resize();window.addEventListener("resize",resize);\n' +
'var startTime=performance.now();\n' +
'var DUR=' + ANIM_DURATION + ';\n' +
'function rand(a,b){return a+Math.random()*(b-a)}\n' +
'function easeOut(t){return 1-Math.pow(1-t,3)}\n' +
'function easeInOut(t){return t<.5?4*t*t*t:1-Math.pow(-2*t+2,3)/2}\n' +
'function clamp(v,a,b){return v<a?a:v>b?b:v}\n' +
'function lerp(a,b,t){return a+(b-a)*t}\n' +
'var BS=24;\n' +
'var MC_COLORS=["#8B6B3D","#6B6B6B","#5B8731","#3E6B1F","#6B4226","#5A5A5A","#7B5B2D","#4A4A4A"];\n' +
'var terrCols=Math.ceil(W/BS)+1;\n' +
'var terrH=[];\n' +
'for(var i=0;i<terrCols;i++){terrH.push(2+~~rand(0,4))}\n' +
'var parts=[];\n' +
'for(var i=0;i<160;i++){\n' +
'  var a=rand(0,6.283),sp=rand(0.12,0.6);\n' +
'  parts.push({x:rand(0,W),y:rand(0,H),vx:Math.cos(a)*sp,vy:Math.sin(a)*sp,\n' +
'    sz:rand(8,18),c:MC_COLORS[~~rand(0,MC_COLORS.length)],a:0,ta:rand(.08,.25),\n' +
'    rot:rand(0,6.28),rs:rand(-.012,.012)});\n' +
'}\n' +
'var star={active:false,x:0,y:0,sx:0,sy:0,tx:0,ty:0,t:0,dur:1.6,trail:[]};\n' +
'var sparkles=[];\n' +
'function addSparkle(x,y){for(var i=0;i<6;i++){var a=rand(0,6.28),sp=rand(0.5,2);\n' +
'  sparkles.push({x:x,y:y,vx:Math.cos(a)*sp,vy:Math.sin(a)*sp,a:1,sz:rand(3,6)})}}\n' +
'var shockwaves=[];\n' +
'function addShock(x,y,c,mr,d){shockwaves.push({x:x,y:y,r:0,mr:mr,c:c,a:.35,d:d,t:0})}\n' +
'var phaseShown={};\n' +
'function showScene(id,o,d){document.title="show:"+id+":"+o+":"+d}\n' +
'function hideScene(id,d){document.title="hide:"+id+":"+d}\n' +
'var waitingForDismiss=false;\n' +
'window.dismissAnimation=function(){\n' +
'  var f=document.getElementById("fade");f.style.transition="opacity 1.2s ease-in";f.classList.add("show");\n' +
'  setTimeout(function(){document.title="ended"},1300);\n' +
'};\n' +
'function drawBlock(x,y,sz,color,alpha){\n' +
'  ctx.save();ctx.globalAlpha=alpha;\n' +
'  ctx.fillStyle=color;ctx.fillRect(x,y,sz,sz);\n' +
'  ctx.fillStyle="rgba(255,255,255,0.09)";ctx.fillRect(x,y,sz,1);ctx.fillRect(x,y,1,sz);\n' +
'  ctx.fillStyle="rgba(0,0,0,0.18)";ctx.fillRect(x,y+sz-1,sz,1);ctx.fillRect(x+sz-1,y,1,sz);\n' +
'  ctx.restore();\n' +
'}\n' +
'function drawTerrain(t){\n' +
'  var a=clamp(t*.3,0,.2);\n' +
'  for(var c=0;c<terrCols;c++){\n' +
'    for(var r=0;r<terrH[c];r++){\n' +
'      var y=H-(r+1)*BS;var x=c*BS;\n' +
'      var col=r===0?"#3E6B1F":r===1?"#5B4B2D":"#3D3D3D";\n' +
'      drawBlock(x,y,BS,col,a);\n' +
'    }\n' +
'  }\n' +
'}\n' +
'function drawGrid(t){\n' +
'  var a=clamp(t*.3,0,.018);\n' +
'  ctx.save();ctx.strokeStyle="rgba(255,255,255,"+a+")";ctx.lineWidth=0.5;\n' +
'  for(var x=0;x<W;x+=BS){ctx.beginPath();ctx.moveTo(x,0);ctx.lineTo(x,H);ctx.stroke()}\n' +
'  for(var y=0;y<H;y+=BS){ctx.beginPath();ctx.moveTo(0,y);ctx.lineTo(W,y);ctx.stroke()}\n' +
'  ctx.restore();\n' +
'}\n' +
'function frame(now){\n' +
'  var t=(now-startTime)/1000;\n' +
'  ctx.clearRect(0,0,W,H);\n' +
'  ctx.fillStyle="rgba(10,10,10,"+clamp(t*.5,0,1)+")";ctx.fillRect(0,0,W,H);\n' +
'  drawGrid(t);\n' +
'  drawTerrain(t);\n' +
'  if(t>1&&t<8){\n' +
'    var gp=clamp((t-1)*.6,0,.3);var r=100+gp*120;\n' +
'    var g=ctx.createRadialGradient(W/2,H/2,0,W/2,H/2,r);\n' +
'    g.addColorStop(0,"rgba(91,135,49,"+(.06*gp)+")");g.addColorStop(1,"rgba(62,107,31,0)");\n' +
'    ctx.fillStyle=g;ctx.fillRect(0,0,W,H);\n' +
'  }\n' +
'  if(t>22&&t<28){\n' +
'    var gp2=clamp((t-22)*.5,0,.25);var r2=120+gp2*130;\n' +
'    var g2=ctx.createRadialGradient(W/2,H/2,0,W/2,H/2,r2);\n' +
'    g2.addColorStop(0,"rgba(91,135,49,"+(.06*gp2)+")");g2.addColorStop(1,"rgba(62,107,31,0)");\n' +
'    ctx.fillStyle=g2;ctx.fillRect(0,0,W,H);\n' +
'  }\n' +
'  for(var i=0;i<parts.length;i++){var p=parts[i];\n' +
'    p.a=clamp(p.a+.003,0,p.ta);p.x+=p.vx;p.y+=p.vy;p.rot+=p.rs;\n' +
'    p.vx*=.9995;p.vy*=.9995;\n' +
'    if(p.x<-30)p.x=W+30;if(p.x>W+30)p.x=-30;\n' +
'    if(p.y<-30)p.y=H+30;if(p.y>H+30)p.y=-30;\n' +
'    ctx.save();ctx.translate(p.x,p.y);ctx.rotate(p.rot);\n' +
'    drawBlock(-p.sz/2,-p.sz/2,p.sz,p.c,p.a);ctx.restore();\n' +
'  }\n' +
'  if(star.active){\n' +
'    var st=clamp((t-star.t)/star.dur,0,1);var e=easeInOut(st);\n' +
'    star.x=lerp(star.sx,star.tx,e);star.y=lerp(star.sy,star.ty,e);\n' +
'    star.trail.push({x:star.x,y:star.y,a:1});if(star.trail.length>35)star.trail.shift();\n' +
'    for(var j=0;j<star.trail.length;j++){var tr=star.trail[j];tr.a*=.93;\n' +
'      ctx.save();ctx.globalAlpha=tr.a*.5;ctx.fillStyle="#7FFF00";\n' +
'      ctx.fillRect(tr.x-2,tr.y-2,4,4);ctx.restore();}\n' +
'    ctx.save();ctx.fillStyle="#7FFF00";ctx.shadowColor="#7FFF00";ctx.shadowBlur=15;\n' +
'    ctx.fillRect(star.x-5,star.y-5,10,10);\n' +
'    ctx.shadowBlur=30;ctx.fillStyle="rgba(127,255,0,0.12)";\n' +
'    ctx.fillRect(star.x-14,star.y-14,28,28);ctx.restore();\n' +
'    if(Math.random()>.6)addSparkle(star.x+rand(-8,8),star.y+rand(-8,8));\n' +
'    if(st>=1)star.active=false;\n' +
'  }\n' +
'  for(var s=sparkles.length-1;s>=0;s--){var sp=sparkles[s];\n' +
'    sp.x+=sp.vx;sp.y+=sp.vy;sp.a*=.95;sp.vx*=.97;sp.vy*=.97;\n' +
'    if(sp.a<.01){sparkles.splice(s,1);continue}\n' +
'    ctx.save();ctx.globalAlpha=sp.a;ctx.fillStyle="#7FFF00";\n' +
'    ctx.fillRect(sp.x-sp.sz/2,sp.y-sp.sz/2,sp.sz,sp.sz);ctx.restore();\n' +
'  }\n' +
'  for(var s=shockwaves.length-1;s>=0;s--){var sw=shockwaves[s];\n' +
'    sw.t+=1/60;var pct=sw.t/sw.d;if(pct>=1){shockwaves.splice(s,1);continue}\n' +
'    sw.r=sw.mr*easeOut(pct);sw.a=.35*(1-pct);\n' +
'    ctx.save();ctx.strokeStyle=sw.c;ctx.globalAlpha=sw.a;ctx.lineWidth=2+2*(1-pct);\n' +
'    ctx.beginPath();ctx.arc(sw.x,sw.y,sw.r,0,6.28);ctx.stroke();ctx.restore();\n' +
'  }\n' +
'  if(t>1.5&&!phaseShown.w){phaseShown.w=true;showScene("welcome",1,1)}\n' +
'  if(t>7&&!phaseShown.hidew){phaseShown.hidew=true;hideScene("welcome",1)}\n' +
'  if(t>8.5&&!phaseShown.star){\n' +
'    phaseShown.star=true;\n' +
'    star.active=true;star.sx=-50;star.sy=H*.55;star.tx=W/2;star.ty=H/2;star.t=t;star.trail=[];\n' +
'  }\n' +
'  if(t>10.5&&!phaseShown.ca){phaseShown.ca=true;addShock(W/2,H/2,"rgba(91,135,49,0.3)",400,1.2);showScene("logo-caellab",1,1.2)}\n' +
'  if(t>14.5&&!phaseShown.hideca){phaseShown.hideca=true;hideScene("logo-caellab",.8)}\n' +
'  if(t>15.5&&!phaseShown.both){phaseShown.both=true;showScene("logo-both",1,1.2)}\n' +
'  if(t>20.5&&!phaseShown.hideboth){phaseShown.hideboth=true;hideScene("logo-both",1)}\n' +
'  if(t>22&&!phaseShown.gpcl){phaseShown.gpcl=true;addShock(W/2,H/2,"rgba(127,255,0,0.12)",350,1);showScene("logo-gpcl",1,1.5)}\n' +
'  if(t>26&&!phaseShown.sweep){\n' +
'    phaseShown.sweep=true;\n' +
'    var sl=document.getElementById("sweep-line");sl.style.opacity="1";\n' +
'    var band=document.getElementById("sweep-band");var swStart=performance.now();\n' +
'    function sweepFrame(swNow){var swT=(swNow-swStart)/1500;\n' +
'      if(swT>1){sl.style.opacity="0";return}\n' +
'      band.style.left=(-200+(W+400)*easeInOut(swT))+"px";\n' +
'      requestAnimationFrame(sweepFrame)}\n' +
'    requestAnimationFrame(sweepFrame);\n' +
'  }\n' +
'  if(t>27.5&&!phaseShown.launch){phaseShown.launch=true;document.title="launch"}\n' +
'  if(t>28&&!phaseShown.hgpcl){phaseShown.hgpcl=true;hideScene("logo-gpcl",1)}\n' +
'  if(t>29.5&&!phaseShown.fadeblk){phaseShown.fadeblk=true;document.getElementById("fade").classList.add("show")}\n' +
'  if(t>DUR&&!waitingForDismiss){waitingForDismiss=true;document.title="waiting"}\n' +
'  requestAnimationFrame(frame);\n' +
'}\n' +
'document.title="meta:"+DUR;\n' +
'requestAnimationFrame(frame);\n' +
'})();\n' +
'<\/script></body></html>';

  var tempHtmlPath = path.join(tempAnimDir, 'index.html');
  try { fs.writeFileSync(tempHtmlPath, htmlContent, 'utf8'); } catch (e) {
    writeLog('[启动动画] 写入临时文件失败: ' + e.message);
    cleanupAnimTempDir(tempAnimDir);
    return { success: false, error: '写入临时文件失败', duration: 0 };
  }

  return new Promise(function(resolve) {
    var animWindow = new BrowserWindow({
      fullscreen: true,
      frame: false,
      skipTaskbar: true,
      backgroundColor: '#000000',
      webPreferences: {
        nodeIntegration: false,
        contextIsolation: true
      }
    });

    activeAnimWindow = animWindow;

    animWindow.setAlwaysOnTop(true, 'screen-saver');
    animWindow.webContents.setWindowOpenHandler(function(details) {
      shell.openExternal(details.url);
      return { action: 'deny' };
    });
    animWindow.loadFile(tempHtmlPath);

    var resolved = false;

    animWindow.on('page-title-updated', function(e, title) {
      e.preventDefault();

      if (title.startsWith('show:')) {
        var parts = title.split(':');
        var sceneId = parts[1];
        var opacity = parts[2];
        var dur = parts[3];
        animWindow.webContents.executeJavaScript(
          '(function(){var el=document.getElementById("' + sceneId + '");' +
          'if(el){el.style.transition="opacity ' + dur + 's ease-out";' +
          'el.style.opacity="' + opacity + '"}})()'
        );
        return;
      }

      if (title.startsWith('hide:')) {
        var parts = title.split(':');
        var sceneId = parts[1];
        var dur = parts[2];
        animWindow.webContents.executeJavaScript(
          '(function(){var el=document.getElementById("' + sceneId + '");' +
          'if(el){el.style.transition="opacity ' + dur + 's ease-in";' +
          'el.style.opacity="0"}})()'
        );
        return;
      }

      if (title === 'launch' && !resolved) {
        resolved = true;
        writeLog('[启动动画] 动画即将结束，提前启动MC');
        resolve({ success: true, duration: ANIM_DURATION });
        return;
      }

      if (title === 'waiting') {
        writeLog('[启动动画] 进入黑屏等待阶段');
        return;
      }

      if (title === 'ended') {
        writeLog('[启动动画] 动画退场完毕');
        try { animWindow.close(); } catch (e) {}
        return;
      }
    });

    animWindow.on('closed', function() {
      if (activeAnimWindow === animWindow) activeAnimWindow = null;
      cleanupAnimTempDir(tempAnimDir);
      if (!resolved) {
        resolved = true;
        resolve({ success: false, error: '动画窗口已关闭', duration: 0 });
      }
    });

    setTimeout(function() {
      if (!resolved) {
        resolved = true;
        writeLog('[启动动画] 动画加载超时');
        resolve({ success: false, error: '动画加载超时', duration: 0 });
        try { if (!animWindow.isDestroyed()) animWindow.close(); } catch (e) {}
      }
    }, 35000);
  });
});

ipcMain.handle('dismiss-startup-animation', function() {
  if (activeAnimWindow && !activeAnimWindow.isDestroyed()) {
    writeLog('[启动动画] MC窗口就绪，执行退场');
    try {
      activeAnimWindow.webContents.executeJavaScript(
        'if(typeof dismissAnimation==="function")dismissAnimation()'
      );
    } catch (e) {}
  }
});

ipcMain.handle('read-json-file', async (_, subPath, fileName) => {
  try {
    const dir = path.join(BASE_DIR, 'gpcl', subPath);
    const filePath = path.join(dir, fileName);
    if (!fs.existsSync(filePath)) {
      return null;
    }
    const content = fs.readFileSync(filePath, 'utf8');
    return JSON.parse(content);
  } catch (e) {
    writeLog(`读取文件失败: ${e.message}`);
    return null;
  }
});

ipcMain.handle('write-json-file', async (_, subPath, fileName, data) => {
  try {
    const dir = path.join(BASE_DIR, 'gpcl', subPath);
    const filePath = path.join(dir, fileName);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
    return true;
  } catch (e) {
    writeLog(`写入文件失败: ${e.message}`);
    return false;
  }
});

// 获取 Forge 版本列表
ipcMain.handle('get-forge-versions', async (_, mcVersion) => {
  try {
    writeLog(`[Forge] 获取版本列表: ${mcVersion}`);
    const versions = await fetchForgeVersions(mcVersion);
    return { success: true, versions };
  } catch (e) {
    writeLog(`[Forge] 获取版本列表失败: ${e.message}`);
    return { success: false, error: e.message, versions: [] };
  }
});

// 从 Forge Maven 获取版本列表
async function fetchForgeVersions(mcVersion) {
  return new Promise((resolve, reject) => {
    const https = require('https');
    const url = `https://files.minecraftforge.net/net/minecraftforge/forge/maven-metadata.json`;
    
    https.get(url, { timeout: 10000 }, (res) => {
      let data = '';
      
      res.on('data', (chunk) => {
        data += chunk;
      });
      
      res.on('end', () => {
        try {
          const metadata = JSON.parse(data);
          const versions = [];
          
          // 查找对应 MC 版本的 Forge 版本
          const versionArray = metadata[mcVersion];
          if (versionArray && Array.isArray(versionArray)) {
            versionArray.forEach((fullVersion) => {
              const parts = fullVersion.split('-');
              const forgeVersion = parts.slice(1).join('-');
              versions.push({
                id: fullVersion,
                name: `Forge ${forgeVersion}`,
                version: forgeVersion,
                mcVersion: mcVersion
              });
            });
          }
          
          // 按版本号排序（最新的在前）
          versions.sort((a, b) => compareVersions(b.version, a.version));
          
          // 只返回前 10 个版本
          const topVersions = versions.slice(0, 10);
          
          // 标记推荐版本（第一个）
          if (topVersions.length > 0) {
            topVersions[0].name += ' (推荐)';
          }
          
          writeLog(`[Forge] 找到 ${topVersions.length} 个版本`);
          resolve(topVersions);
        } catch (e) {
          writeLog(`[Forge] 解析错误: ${e.message}`);
          reject(new Error('解析 Forge 元数据失败'));
        }
      });
    }).on('error', (e) => {
      reject(new Error(`请求 Forge 元数据失败: ${e.message}`));
    }).on('timeout', () => {
      reject(new Error('请求 Forge 元数据超时'));
    });
  });
}

// 版本号比较函数
function compareVersions(v1, v2) {
  const parts1 = v1.split(/[.-]/).map(p => parseInt(p, 10) || 0);
  const parts2 = v2.split(/[.-]/).map(p => parseInt(p, 10) || 0);
  
  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
    const a = parts1[i] || 0;
    const b = parts2[i] || 0;
    if (a > b) return 1;
    if (a < b) return -1;
  }
  return 0;
}

async function installVersionWithModLoader(versionId, loaderType, loaderVersion, maxConcurrent) {
  try {
    writeLog(`[模组加载器] 开始下载: ${loaderType} ${loaderVersion} for MC ${versionId}`);
    
    // 1. 先下载原版游戏
    writeLog(`[模组加载器] 下载原版 MC ${versionId}`);
    await installVersion(versionId, maxConcurrent);
    
    if (shouldCancelDownload) {
      return { success: false, error: '下载已取消' };
    }
    
    // 2. 根据模组加载器类型进行安装
    let finalVersionId;
    if (loaderType === 'forge') {
      finalVersionId = await installForge(versionId, loaderVersion);
    } else {
      return { success: false, error: `不支持的模组加载器: ${loaderType}` };
    }
    
    writeLog(`[模组加载器] 安装完成: ${finalVersionId}`);
    
    // 更新版本最后启动时间
    updateVersionLastPlayed(finalVersionId);
    
    return { success: true, finalVersionId };
    
  } catch (e) {
    writeLog(`[模组加载器] 安装失败: ${e.message}`);
    return { success: false, error: e.message };
  }
}

// 安装 Forge：直接从 Forge Maven 下载完整的版本 JSON
async function installForge(mcVersion, forgeVersion) {
  writeLog(`[Forge] 安装: MC ${mcVersion}, Forge ${forgeVersion}`);
  
  const versionDir = path.join(GAME_DIR, 'versions', mcVersion);
  if (!fs.existsSync(versionDir)) {
    throw new Error(`原版版本 ${mcVersion} 不存在`);
  }
  
  // 构造完整的 Forge 版本 ID（如 1.20.1-47.2.0）
  const fullForgeVersionId = `${mcVersion}-${forgeVersion}`;
  
  // Forge 在 Maven 上提供了完整的版本 JSON（含 mainClass、libraries、inheritsFrom 等）
  const forgeJsonUrl = `https://maven.minecraftforge.net/net/minecraftforge/forge/${fullForgeVersionId}/forge-${fullForgeVersionId}.json`;
  
  writeLog(`[Forge] 下载版本 JSON: ${forgeJsonUrl}`);
  let forgeJsonData;
  try {
    forgeJsonData = await fetchText(forgeJsonUrl);
  } catch (e) {
    throw new Error(`无法下载 Forge 版本 JSON: ${e.message}`);
  }
  
  let forgeVersionData;
  try {
    forgeVersionData = JSON.parse(forgeJsonData);
  } catch (e) {
    const snippet = forgeJsonData.substring(0, 100);
    writeLog(`[Forge] JSON 解析失败，响应内容: ${snippet}`);
    throw new Error(`Forge 版本 JSON 解析失败，服务器可能返回了错误页面`);
  }
  
  const forgeJsonId = `${mcVersion}-forge`;
  forgeVersionData.id = forgeJsonId;
  
  const forgeJsonPath = path.join(versionDir, `${forgeJsonId}.json`);
  fs.writeFileSync(forgeJsonPath, JSON.stringify(forgeVersionData, null, 2));
  
  const gpclDir = path.join(versionDir, 'gpcl');
  if (!fs.existsSync(gpclDir)) fs.mkdirSync(gpclDir, { recursive: true });
  
  const configPath = path.join(gpclDir, 'config.ini');
  const configContent = `[Version]
Minecraft=${mcVersion}
Forge=${forgeVersion}
`;
  fs.writeFileSync(configPath, configContent, 'utf8');
  
  writeLog(`[Forge] 安装完成: ${forgeJsonId}`);
  return forgeJsonId;
}

// 读取 config.ini 配置文件
function readVersionConfig(versionId) {
  const versionDir = path.join(GAME_DIR, 'versions', versionId);
  const configPath = path.join(versionDir, 'gpcl', 'config.ini');
  
  if (!fs.existsSync(configPath)) {
    return null;
  }
  
  try {
    const content = fs.readFileSync(configPath, 'utf8');
    const config = {
      Minecraft: '',
      Forge: ''
    };
    
    const lines = content.split('\n');
    let inVersionSection = false;
    
    for (const line of lines) {
      const trimmed = line.trim();
      
      if (trimmed === '[Version]') {
        inVersionSection = true;
        continue;
      }
      
      if (!inVersionSection) continue;
      
      const parts = trimmed.split('=');
      if (parts.length === 2) {
        const key = parts[0].trim();
        const value = parts[1].trim();
        if (config.hasOwnProperty(key)) {
          config[key] = value;
        }
      }
    }
    
    return config;
  } catch (e) {
    writeLog(`[Config] 读取配置失败: ${e.message}`);
    return null;
  }
}

// 生成版本显示名称
function generateVersionDisplayName(versionId) {
  const config = readVersionConfig(versionId);
  
  if (!config) {
    return versionId;
  }
  
  const parts = [];
  parts.push(config.Minecraft || versionId);
  
  if (config.Forge) {
    parts.push(`Forge${config.Forge}`);
  }
  
  return parts.join(' ');
}

// 生成启动页显示名称
function generateLaunchDisplayName(versionId) {
  const config = readVersionConfig(versionId);
  
  if (!config) {
    return versionId;
  }
  
  const parts = [];
  parts.push(config.Minecraft || versionId);
  
  if (config.Forge) {
    parts.push(`Forge${config.Forge}`);
  }
  
  return parts.join(' ');
}