import path from 'path';
import { app, ipcMain } from 'electron';
import fs from 'fs';
import https from 'https';
import extract from 'extract-zip';
import { launch, Version, diagnose } from '@xmcl/core';
import { execSync } from 'child_process';
import {
  installDependencies,
  installFabric,
  getFabricLoaders,
  getVersionList,
  install,
  installTask,
  installDependenciesTask,
} from '@xmcl/installer';
import { spawn } from 'child_process';
import { AuthService } from './auth-service';

// Константы
const AUTHLIB_INJECTOR_FILENAME = 'authlib-injector-1.2.5.jar';
const MCSTATUS_API_URL = 'https://api.mcstatus.io/v2/status/java/';

// Создаем экземпляр сервиса аутентификации
const authService = new AuthService();

// Модифицированная функция для получения последней версии релиза с произвольного URL
export async function getLatestReleaseVersion(apiUrl: string): Promise<string> {
  try {
    const response = await fetch(apiUrl);
    const data = await response.json();
    return data.tag_name || '0.0.0';
  } catch (error) {
    console.error('Failed to fetch latest version:', error);
    return '0.0.0';
  }
}

// Функция для загрузки файла
export async function downloadFile(
  url: string,
  dest: string,
  progressCallback: (progress: number) => void,
): Promise<void> {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(dest);
    let downloadedSize = 0;
    let totalSize = 0;
    let redirectCount = 0;

    const makeRequest = (requestUrl: string) => {
      https
        .get(requestUrl, (response) => {
          // Обрабатываем редиректы
          if (response.statusCode === 301 || response.statusCode === 302) {
            if (redirectCount++ > 5) {
              reject(new Error('Too many redirects'));
              return;
            }
            makeRequest(response.headers.location!);
            return;
          }

          if (response.statusCode !== 200) {
            reject(new Error(`Server returned ${response.statusCode}`));
            return;
          }

          totalSize = parseInt(response.headers['content-length'] || '0', 10);

          response.on('data', (chunk) => {
            downloadedSize += chunk.length;
            const progress = Math.round((downloadedSize / totalSize) * 100);
            progressCallback(progress);
          });

          response.pipe(file);

          file.on('finish', () => {
            file.close();
            // Проверяем, что файл скачан полностью
            if (downloadedSize !== totalSize && totalSize > 0) {
              fs.unlink(dest, () => {
                reject(new Error('File download incomplete'));
              });
              return;
            }
            resolve();
          });
        })
        .on('error', (err) => {
          fs.unlink(dest, () => reject(err));
        });
    };

    makeRequest(url);
  });
}

// Добавим функцию для определения версии Java
export async function getJavaVersion(
  javaPath: string,
): Promise<{ version: string; majorVersion: number }> {
  return new Promise((resolve, reject) => {
    const process = spawn(javaPath, ['-version']);
    let output = '';

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

    process.on('close', (code) => {
      if (code === 0) {
        // Извлекаем версию из вывода (например, "java version "1.8.0_291"")
        const versionMatch = output.match(/version "([^"]+)"/);
        if (versionMatch) {
          const version = versionMatch[1];
          // Определяем major версию
          let majorVersion = 8; // По умолчанию предполагаем Java 8

          if (version.startsWith('1.8')) {
            majorVersion = 8;
          } else if (version.match(/^(9|10|11|12|13|14|15|16)/)) {
            majorVersion = parseInt(version.split('.')[0], 10);
          } else if (version.match(/^1\.(9|10|11|12|13|14|15|16)/)) {
            majorVersion = parseInt(version.split('.')[1], 10);
          } else if (version.match(/^([0-9]+)/)) {
            majorVersion = parseInt(version.match(/^([0-9]+)/)?.[1] || '0', 10);
          }

          resolve({ version, majorVersion });
        } else {
          reject(new Error('Unable to parse Java version'));
        }
      } else {
        reject(new Error(`Java process exited with code ${code}`));
      }
    });
  });
}

// Модифицируем функцию findJava, чтобы она находила все версии Java и определяла их версии
export async function findJavaVersions(): Promise<
  Array<{ path: string; version: string; majorVersion: number }>
> {
  const javaPaths: string[] = [];
  const results: Array<{
    path: string;
    version: string;
    majorVersion: number;
  }> = [];

  try {
    // 1. Сначала проверяем переменную JAVA_HOME
    if (process.env.JAVA_HOME) {
      const javaPath = path.join(
        process.env.JAVA_HOME,
        'bin',
        'java' + (process.platform === 'win32' ? '.exe' : ''),
      );
      if (fs.existsSync(javaPath)) {
        javaPaths.push(javaPath);
      }
    }

    // 2. Проверяем стандартные пути установки в зависимости от платформы
    const checkPaths: string[] = [];

    if (process.platform === 'win32') {
      // Windows
      const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';
      const programFilesX86 =
        process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';

      // JDK пути
      [
        'Java',
        'AdoptOpenJDK',
        'Eclipse Adoptium',
        'BellSoft',
        'Zulu',
        'Amazon Corretto',
        'Microsoft',
      ].forEach((vendor) => {
        checkPaths.push(path.join(programFiles, vendor));
        checkPaths.push(path.join(programFilesX86, vendor));
      });
    } else if (process.platform === 'darwin') {
      // macOS
      checkPaths.push('/Library/Java/JavaVirtualMachines');
      checkPaths.push('/System/Library/Java/JavaVirtualMachines');
      checkPaths.push('/usr/libexec/java_home');
    } else {
      // Linux
      checkPaths.push('/usr/lib/jvm');
      checkPaths.push('/usr/java');
      checkPaths.push('/opt/java');
    }

    // Проверяем каждый путь
    for (const basePath of checkPaths) {
      if (fs.existsSync(basePath)) {
        try {
          // Находим подпапки с JDK/JRE
          const entries = fs.readdirSync(basePath, { withFileTypes: true });
          for (const entry of entries) {
            if (entry.isDirectory()) {
              // Проверяем наличие исполняемого файла java в bin
              const javaPath = path.join(
                basePath,
                entry.name,
                'bin',
                'java' + (process.platform === 'win32' ? '.exe' : ''),
              );

              if (fs.existsSync(javaPath)) {
                javaPaths.push(javaPath);
              }
            }
          }
        } catch (err) {
          console.error(`Ошибка при сканировании ${basePath}:`, err);
        }
      }
    }

    // 3. Пробуем найти java в PATH через команду which/where
    try {
      const command =
        process.platform === 'win32' ? 'where java' : 'which java';
      const javaPathFromCmd = execSync(command).toString().trim().split('\n');

      javaPathFromCmd.forEach((path) => {
        if (path && fs.existsSync(path) && !javaPaths.includes(path)) {
          javaPaths.push(path);
        }
      });
    } catch (err) {
      console.error('Ошибка при поиске java через PATH:', err);
    }

    // Получаем информацию о версиях найденных Java
    for (const javaPath of javaPaths) {
      try {
        const versionInfo = await getJavaVersion(javaPath);
        results.push({
          path: javaPath,
          version: versionInfo.version,
          majorVersion: versionInfo.majorVersion,
        });
      } catch (err) {
        console.error(`Ошибка при определении версии для ${javaPath}:`, err);
      }
    }

    // Сортируем результаты по majorVersion (от меньшей к большей)
    return results.sort((a, b) => a.majorVersion - b.majorVersion);
  } catch (error) {
    console.error('Ошибка при поиске версий Java:', error);
    return results;
  }
}

// Обновим функцию findJava для использования Java 8
export async function findJava(): Promise<string> {
  try {
    console.log('Поиск доступных версий Java...');

    const javaVersions = await findJavaVersions();

    if (javaVersions.length === 0) {
      throw new Error('Java не найдена. Установите Java и повторите попытку.');
    }

    console.log('Найденные версии Java:');
    javaVersions.forEach((java) => {
      console.log(
        `- Java ${java.majorVersion} (${java.version}) по пути: ${java.path}`,
      );
    });

    // Предпочитаем Java 21 или 17 для совместимости с authlib-injector
    const preferredVersions = [21, 17, 11];

    for (const preferredVersion of preferredVersions) {
      const preferred = javaVersions.find(
        (java) => java.majorVersion === preferredVersion,
      );
      if (preferred) {
        console.log(
          `Выбрана предпочтительная версия Java ${preferredVersion}: ${preferred.path}`,
        );
        return preferred.path;
      }
    }

    // Если не нашли предпочтительные версии, берем самую старую версию
    console.log(`Выбрана доступная версия Java: ${javaVersions[0].path}`);
    return javaVersions[0].path;
  } catch (error) {
    console.error('Ошибка при поиске Java:', error);
    throw error;
  }
}

// Добавим функцию для проверки/копирования authlib-injector (как в C#)
async function ensureAuthlibInjectorExists(appPath: string): Promise<string> {
  const authlibPath = path.join(appPath, AUTHLIB_INJECTOR_FILENAME);

  // Проверяем, существует ли файл
  if (fs.existsSync(authlibPath)) {
    console.log(
      `Файл ${AUTHLIB_INJECTOR_FILENAME} уже существует: ${authlibPath}`,
    );
    return authlibPath;
  }

  // Ищем authlib в ресурсах приложения
  const resourcePath = path.join(app.getAppPath(), AUTHLIB_INJECTOR_FILENAME);

  if (fs.existsSync(resourcePath)) {
    console.log(`Копирование ${AUTHLIB_INJECTOR_FILENAME} из ресурсов...`);
    fs.copyFileSync(resourcePath, authlibPath);
    console.log(`Файл успешно скопирован: ${authlibPath}`);
    return authlibPath;
  }

  // Если не нашли локальный файл - скачиваем его
  console.log(`Скачивание ${AUTHLIB_INJECTOR_FILENAME}...`);
  await downloadFile(
    `https://github.com/yushijinhun/authlib-injector/releases/download/v1.2.5/${AUTHLIB_INJECTOR_FILENAME}`,
    authlibPath,
    (progress) => {
      console.log(`Прогресс скачивания: ${progress}%`);
    },
  );

  return authlibPath;
}

// Инициализация IPC обработчиков
export function initMinecraftHandlers() {
  // Обработчик для скачивания и распаковки
  ipcMain.handle('download-and-extract', async (event, options) => {
    try {
      const {
        downloadUrl = 'https://github.com/DIKER0K/Comfort/releases/latest/download/Comfort.zip',
        apiReleaseUrl = 'https://api.github.com/repos/DIKER0K/Comfort/releases/latest',
        versionFileName = 'comfort_version.txt',
        packName = 'Comfort',
        preserveFiles = [], // Новый параметр: список файлов/папок для сохранения
      } = options || {};

      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const versionsDir = path.join(minecraftDir, 'versions');
      const versionFilePath = path.join(minecraftDir, versionFileName);

      // Получаем текущую и последнюю версии
      const latestVersion = await getLatestReleaseVersion(apiReleaseUrl);
      let currentVersion = '';

      // Проверяем текущую версию, если файл существует
      if (fs.existsSync(versionFilePath)) {
        currentVersion = fs.readFileSync(versionFilePath, 'utf-8').trim();
      }

      // Проверяем, нужно ли обновление
      if (currentVersion === latestVersion) {
        return {
          success: true,
          updated: false,
          version: currentVersion,
          packName,
        };
      }

      const tempDir = path.join(appPath, 'temp');
      const packDir = path.join(versionsDir, packName); // Директория пакета

      // Создаем/очищаем временную директорию
      if (fs.existsSync(tempDir)) {
        fs.rmSync(tempDir, { recursive: true });
      }
      fs.mkdirSync(tempDir, { recursive: true });

      const zipPath = path.join(tempDir, `${packName}.zip`);

      // Скачиваем файл
      await downloadFile(downloadUrl, zipPath, (progress) => {
        event.sender.send('download-progress', progress);
      });

      // Проверяем архив
      const fileStats = fs.statSync(zipPath);
      if (fileStats.size < 1024) {
        throw new Error('Downloaded file is too small, likely corrupted');
      }

      // Создаем папку versions если её нет
      if (!fs.existsSync(versionsDir)) {
        fs.mkdirSync(versionsDir, { recursive: true });
      }

      // Сохраняем файлы/папки, которые нужно оставить
      const backupDir = path.join(tempDir, 'backup');
      fs.mkdirSync(backupDir, { recursive: true });

      // Проверка и бэкап указанных файлов/папок
      for (const filePath of preserveFiles) {
        const fullPath = path.join(packDir, filePath);

        if (fs.existsSync(fullPath)) {
          const backupPath = path.join(backupDir, filePath);

          // Создаем необходимые директории для бэкапа
          const backupDirPath = path.dirname(backupPath);
          if (!fs.existsSync(backupDirPath)) {
            fs.mkdirSync(backupDirPath, { recursive: true });
          }

          // Копируем файл или директорию
          if (fs.lstatSync(fullPath).isDirectory()) {
            fs.cpSync(fullPath, backupPath, { recursive: true });
            console.log(`Директория ${filePath} сохранена во временный бэкап`);
          } else {
            fs.copyFileSync(fullPath, backupPath);
            console.log(`Файл ${filePath} сохранен во временный бэкап`);
          }
        }
      }

      // Распаковываем архив напрямую в папку versions
      await extract(zipPath, { dir: versionsDir });
      fs.unlinkSync(zipPath);

      // Восстанавливаем файлы/папки из бэкапа
      for (const filePath of preserveFiles) {
        const backupPath = path.join(backupDir, filePath);
        if (fs.existsSync(backupPath)) {
          const targetPath = path.join(packDir, filePath);

          // Создаем необходимые директории для восстановления
          const targetDirPath = path.dirname(targetPath);
          if (!fs.existsSync(targetDirPath)) {
            fs.mkdirSync(targetDirPath, { recursive: true });
          }

          // Копируем обратно файл или директорию
          if (fs.lstatSync(backupPath).isDirectory()) {
            fs.cpSync(backupPath, targetPath, { recursive: true });
            console.log(`Директория ${filePath} восстановлена из бэкапа`);
          } else {
            fs.copyFileSync(backupPath, targetPath);
            console.log(`Файл ${filePath} восстановлен из бэкапа`);
          }
        }
      }

      // Сохраняем новую версию
      fs.writeFileSync(versionFilePath, latestVersion);

      // Удаляем временную директорию
      fs.rmSync(tempDir, { recursive: true });

      return { success: true, updated: true, version: latestVersion, packName };
    } catch (error) {
      console.error('Error in download-and-extract:', error);
      throw error;
    }
  });

  // Обработчик для запуска Minecraft
  ipcMain.handle('launch-minecraft', async (event, gameConfig) => {
    try {
      const {
        accessToken,
        uuid,
        username,
        memory = 4096,
        baseVersion = '1.21.4',
        fabricVersion = 'fabric0.16.14',
        packName = 'Comfort', // Название основной сборки
        versionToLaunchOverride = '', // Возможность переопределить версию для запуска
        serverIp = 'popa-popa.ru',
        serverPort, // Добавляем опциональный порт без значения по умолчанию
      } = gameConfig || {};

      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const versionsDir = path.join(minecraftDir, 'versions');

      // Определяем версию для запуска
      const versionsContents = fs.existsSync(versionsDir)
        ? fs.readdirSync(versionsDir)
        : [];
      console.log('Доступные версии:', versionsContents);

      // Найти версию пакета, Fabric или базовую версию
      let versionToLaunch = versionToLaunchOverride;

      if (!versionToLaunch) {
        if (
          versionsContents.includes(`${baseVersion}-fabric${fabricVersion}`)
        ) {
          versionToLaunch = `${baseVersion}-fabric${fabricVersion}`;
        } else if (versionsContents.includes(packName)) {
          versionToLaunch = packName;
        } else {
          versionToLaunch = baseVersion;
        }
      }

      console.log('Запускаем версию:', versionToLaunch);

      // Находим путь к Java
      event.sender.send('installation-status', {
        step: 'java',
        message: 'Поиск Java...',
      });

      let javaPath;
      try {
        javaPath = await findJava();
      } catch (error) {
        console.warn('Ошибка при поиске Java:', error);
        event.sender.send('installation-status', {
          step: 'java-error',
          message: 'Не удалось найти Java. Используем системную Java.',
        });
        javaPath = 'java';
      }

      // Далее пробуем установить Minecraft, но продолжаем даже при ошибках
      let resolvedVersion;
      try {
        // 1. Получаем список версий и устанавливаем ванильный Minecraft
        event.sender.send('installation-status', {
          step: 'minecraft-list',
          message: 'Получение списка версий Minecraft...',
        });

        const versionList = await getVersionList();
        const minecraftVersion = versionList.versions.find(
          (v) => v.id === baseVersion,
        );

        if (minecraftVersion) {
          // Устанавливаем базовую версию Minecraft
          event.sender.send('installation-status', {
            step: 'minecraft-install',
            message: `Установка Minecraft ${baseVersion}...`,
          });

          try {
            const installMcTask = installTask(minecraftVersion, minecraftDir, {
              skipRevalidate: true,
            });

            await installMcTask.startAndWait({
              onStart(task) {
                event.sender.send('installation-status', {
                  step: `minecraft-install.${task.path}`,
                  message: `Начало: ${task.name || task.path}`,
                });
              },
              onUpdate(task) {
                const percentage =
                  Math.round(
                    (installMcTask.progress / installMcTask.total) * 100,
                  ) || 0;

                event.sender.send('download-progress', percentage);
                event.sender.send('installation-status', {
                  step: `minecraft-install.${task.path}`,
                  message: `Прогресс ${task.name || task.path}: ${percentage}% (${installMcTask.progress}/${installMcTask.total})`,
                });
              },
              onFailed(task, error) {
                console.warn(
                  `Ошибка при установке ${task.path}, продолжаем:`,
                  error,
                );
                event.sender.send('installation-status', {
                  step: `minecraft-install.${task.path}`,
                  message: `Ошибка: ${error.message}`,
                });
              },
              onSucceed(task) {
                event.sender.send('installation-status', {
                  step: `minecraft-install.${task.path}`,
                  message: `Завершено: ${task.name || task.path}`,
                });
              },
            });
          } catch (error) {
            console.warn('Ошибка при установке Minecraft, продолжаем:', error);
          }

          // 2. Устанавливаем Fabric
          try {
            event.sender.send('installation-status', {
              step: 'fabric-list',
              message: 'Получение списка версий Fabric...',
            });

            if (fabricVersion) {
              event.sender.send('installation-status', {
                step: 'fabric-install',
                message: `Установка Fabric ${fabricVersion}...`,
              });

              await installFabric({
                minecraftVersion: baseVersion,
                version: fabricVersion, // Используйте напрямую, без .version
                minecraft: minecraftDir,
              });
            }
          } catch (error) {
            console.warn('Ошибка при установке Fabric, продолжаем:', error);
          }

          // 3. Подготовка версии и установка зависимостей
          try {
            // Используем идентификатор Fabric-версии
            const fabricVersionId = `${baseVersion}-fabric${fabricVersion}`;

            event.sender.send('installation-status', {
              step: 'version-parse',
              message: 'Подготовка версии...',
            });

            resolvedVersion = await Version.parse(
              minecraftDir,
              fabricVersionId,
            );

            event.sender.send('installation-status', {
              step: 'dependencies',
              message: 'Установка библиотек и ресурсов...',
            });

            const depsTask = installDependenciesTask(resolvedVersion, {
              assetsDownloadConcurrency: 4,
              skipRevalidate: true,
              prevalidSizeOnly: true,
              checksumValidatorResolver: (checksum) => ({
                validate: async () => {
                  /* void */
                },
              }),
            });

            try {
              await depsTask.startAndWait({
                onStart(task) {
                  event.sender.send('installation-status', {
                    step: `dependencies.${task.path}`,
                    message: `Начало: ${task.name || task.path}`,
                  });
                },
                onUpdate(task) {
                  const percentage =
                    Math.round((depsTask.progress / depsTask.total) * 100) || 0;

                  event.sender.send('download-progress', percentage);
                  event.sender.send('installation-status', {
                    step: `dependencies.${task.path}`,
                    message: `Установка ${task.name || task.path}: ${percentage}%`,
                  });
                },
                onFailed(task, error) {
                  console.warn(
                    `Ошибка при установке ${task.path}, продолжаем:`,
                    error,
                  );
                  event.sender.send('installation-status', {
                    step: `dependencies.${task.path}`,
                    message: `Ошибка: ${error.message}`,
                  });
                },
                onSucceed(task) {
                  event.sender.send('installation-status', {
                    step: `dependencies.${task.path}`,
                    message: `Завершено: ${task.name || task.path}`,
                  });
                },
              });
            } catch (error) {
              console.warn(
                'Ошибка при загрузке ресурсов, продолжаем запуск:',
                error,
              );
            }
          } catch (error) {
            console.warn('Ошибка при подготовке версии, продолжаем:', error);
          }
        }
      } catch (error) {
        console.warn('Произошла ошибка при подготовке Minecraft:', error);
      }

      // Загрузка и проверка authlib-injector
      const authlibPath = await ensureAuthlibInjectorExists(appPath);
      event.sender.send('installation-status', {
        step: 'authlib-injector',
        message: 'authlib-injector готов',
      });

      // Запускаем Minecraft с authlib-injector для Ely.by
      event.sender.send('installation-status', {
        step: 'launch',
        message: 'Запуск игры...',
      });

      // При запуске используем переданные параметры
      const packDir = path.join(versionsDir, packName);

      // При формировании конфигурации запуска создаем объект server только с нужными параметрами
      const serverConfig: any = { ip: serverIp };

      // Добавляем порт только если он был передан
      if (serverPort) {
        serverConfig.port = serverPort;
      }

      const proc = await launch({
        gamePath: packDir,
        resourcePath: minecraftDir,
        javaPath,
        version: versionToLaunch,
        launcherName: 'popa-popa',
        server: serverConfig, // Используем созданный объект конфигурации
        extraJVMArgs: [
          '-Dlog4j2.formatMsgNoLookups=true',
          `-javaagent:${authlibPath}=ely.by`,
          `-Xmx${memory}M`,
        ],
        // Используем данные аутентификации Yggdrasil
        accessToken,
        gameProfile: {
          id: uuid,
          name: username,
        },
      });

      // Логирование
      proc.stdout?.on('data', (data) => {
        console.log(`Minecraft stdout: ${data}`);
      });
      proc.stderr?.on('data', (data) => {
        console.error(`Minecraft stderr: ${data}`);
      });

      return { success: true, pid: proc.pid };
    } catch (error) {
      console.error('Ошибка при запуске Minecraft:', error);
      event.sender.send('installation-status', {
        step: 'error',
        message: `Ошибка запуска: ${error.message}`,
      });

      return { success: false, error: error.message };
    }
  });

  // Добавьте в функцию initMinecraftHandlers или создайте новую
  ipcMain.handle('get-pack-files', async (event, packName) => {
    try {
      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const packDir = path.join(minecraftDir, 'versions', packName);

      if (!fs.existsSync(packDir)) {
        return { success: false, error: 'Директория сборки не найдена' };
      }

      // Функция для рекурсивного обхода директории
      const scanDir: any = (dir: any, basePath: any = '') => {
        const result = [];
        const items = fs.readdirSync(dir);

        for (const item of items) {
          const itemPath = path.join(dir, item);
          const relativePath = basePath ? path.join(basePath, item) : item;
          const isDirectory = fs.statSync(itemPath).isDirectory();

          result.push({
            name: item,
            path: relativePath,
            isDirectory,
            // Если это директория, рекурсивно сканируем ее
            children: isDirectory ? scanDir(itemPath, relativePath) : [],
          });
        }

        return result;
      };

      const files = scanDir(packDir);
      return { success: true, files };
    } catch (error) {
      console.error('Ошибка при получении файлов сборки:', error);
      return { success: false, error: error.message };
    }
  });

  // Добавьте в функцию initMinecraftHandlers новый обработчик
  ipcMain.handle('get-available-versions', async (event) => {
    try {
      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const versionsDir = path.join(minecraftDir, 'versions');

      if (!fs.existsSync(versionsDir)) {
        return { success: true, versions: [] };
      }

      const items = fs.readdirSync(versionsDir);
      const versions = [];

      for (const item of items) {
        const versionPath = path.join(versionsDir, item);
        if (fs.statSync(versionPath).isDirectory()) {
          // Проверяем, есть ли конфигурация для пакета
          const versionJsonPath = path.join(versionPath, `${item}.json`);
          let versionInfo = {
            id: item,
            name: item,
            version: item,
          };

          if (fs.existsSync(versionJsonPath)) {
            try {
              const versionData = JSON.parse(
                fs.readFileSync(versionJsonPath, 'utf8'),
              );
              versionInfo.version = versionData.id || item;
            } catch (error) {
              console.warn(`Ошибка при чтении файла версии ${item}:`, error);
            }
          }

          versions.push(versionInfo);
        }
      }

      return { success: true, versions };
    } catch (error) {
      console.error('Ошибка при получении доступных версий:', error);
      return { success: false, error: error.message };
    }
  });
}

// Добавляем обработчики IPC для аутентификации
export function initAuthHandlers() {
  // Аутентификация
  ipcMain.handle('authenticate', async (event, { username, password }) => {
    try {
      const auth = await authService.login(username, password);
      return {
        accessToken: auth.accessToken,
        clientToken: auth.clientToken,
        selectedProfile: auth.selectedProfile,
      };
    } catch (error) {
      console.error('Ошибка аутентификации:', error);
      throw error;
    }
  });

  // Валидация токена
  ipcMain.handle('validate-token', async (event, accessToken) => {
    try {
      const clientToken = JSON.parse(
        fs.readFileSync(
          path.join(app.getPath('userData'), 'config.json'),
          'utf8',
        ),
      ).clientToken;

      const valid = await authService.validate(accessToken, clientToken);
      return { valid };
    } catch (error) {
      console.error('Ошибка валидации токена:', error);
      return { valid: false };
    }
  });

  // Обновление токена
  ipcMain.handle(
    'refresh-token',
    async (event, { accessToken, clientToken }) => {
      try {
        const auth = await authService.refresh(accessToken, clientToken);
        if (!auth) return null;

        return {
          accessToken: auth.accessToken,
          clientToken: auth.clientToken,
          selectedProfile: auth.selectedProfile,
        };
      } catch (error) {
        console.error('Ошибка обновления токена:', error);
        return null;
      }
    },
  );
}

// Функция для получения статуса сервера
export function initServerStatusHandler() {
  ipcMain.handle('get-server-status', async (event, { host, port }) => {
    try {
      // Формируем адрес с портом, если указан
      const serverAddress = port ? `${host}:${port}` : host;

      // Делаем запрос к API mcstatus.io
      const response = await fetch(`${MCSTATUS_API_URL}${serverAddress}`);

      // Проверяем статус ответа
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`API вернул ошибку ${response.status}: ${errorText}`);
      }

      const data = await response.json();

      if (data.online) {
        return {
          success: true,
          online: data.players?.online || 0,
          max: data.players?.max || 0,
          version: data.version?.name_clean || 'Unknown',
          icon: data.icon || null, // Возвращаем иконку
          motd: data.motd?.clean || '', // Название сервера
        };
      } else {
        return { success: false, error: 'Сервер не доступен' };
      }
    } catch (error) {
      console.error('Ошибка при получении статуса сервера:', error);
      return { success: false, error: error.message };
    }
  });
}

// Функция для работы с конфигурацией сборки
export function initPackConfigHandlers() {
  // Файл конфигурации
  const CONFIG_FILENAME = 'popa-launcher-config.json';

  // Обработчик для сохранения настроек сборки
  ipcMain.handle('save-pack-config', async (event, { packName, config }) => {
    try {
      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const packDir = path.join(minecraftDir, 'versions', packName);

      // Создаем папку для сборки, если она не существует
      if (!fs.existsSync(packDir)) {
        fs.mkdirSync(packDir, { recursive: true });
      }

      const configPath = path.join(packDir, CONFIG_FILENAME);

      // Сохраняем конфигурацию в файл
      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));

      // Добавляем файл конфигурации в список файлов, которые не удаляются
      if (!config.preserveFiles.includes(CONFIG_FILENAME)) {
        config.preserveFiles.push(CONFIG_FILENAME);
        // Перезаписываем файл с обновленным списком
        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
      }

      return { success: true };
    } catch (error) {
      console.error('Ошибка при сохранении настроек сборки:', error);
      return { success: false, error: error.message };
    }
  });

  // Обработчик для загрузки настроек сборки
  ipcMain.handle('load-pack-config', async (event, { packName }) => {
    try {
      const appPath = path.dirname(app.getPath('exe'));
      const minecraftDir = path.join(appPath, '.minecraft');
      const packDir = path.join(minecraftDir, 'versions', packName);
      const configPath = path.join(packDir, CONFIG_FILENAME);

      // Проверяем существование файла конфигурации
      if (!fs.existsSync(configPath)) {
        // Если файла нет, возвращаем дефолтную конфигурацию
        return {
          success: true,
          config: {
            memory: 4096,
            preserveFiles: [CONFIG_FILENAME], // По умолчанию сохраняем файл конфигурации
          },
        };
      }

      // Читаем и парсим конфигурацию
      const configData = fs.readFileSync(configPath, 'utf8');
      const config = JSON.parse(configData);

      // Добавляем файл конфигурации в список сохраняемых файлов, если его там нет
      if (!config.preserveFiles.includes(CONFIG_FILENAME)) {
        config.preserveFiles.push(CONFIG_FILENAME);
      }

      return { success: true, config };
    } catch (error) {
      console.error('Ошибка при загрузке настроек сборки:', error);
      return {
        success: false,
        error: error.message,
        // Возвращаем дефолтную конфигурацию при ошибке
        config: {
          memory: 4096,
          preserveFiles: [CONFIG_FILENAME],
        },
      };
    }
  });
}

// Добавляем после обработчика get-available-versions
ipcMain.handle('get-version-config', async (event, { versionId }) => {
  try {
    const appPath = path.dirname(app.getPath('exe'));
    const minecraftDir = path.join(appPath, '.minecraft');
    const versionsDir = path.join(minecraftDir, 'versions');
    const versionPath = path.join(versionsDir, versionId);

    // Проверяем существование директории версии
    if (!fs.existsSync(versionPath)) {
      return { success: false, error: `Версия ${versionId} не найдена` };
    }

    // Проверяем конфигурационный файл версии
    const configPath = path.join(versionPath, 'popa-launcher-config.json');

    // Определяем базовые настройки по умолчанию
    let config = {
      downloadUrl: '',
      apiReleaseUrl: '',
      versionFileName: `${versionId}_version.txt`,
      packName: versionId,
      memory: 4096,
      baseVersion: '1.21.4',
      serverIp: 'popa-popa.ru',
      fabricVersion: '0.16.14',
      preserveFiles: ['popa-launcher-config.json'],
    };

    // Если это Comfort, используем настройки по умолчанию
    if (versionId === 'Comfort') {
      config.downloadUrl =
        'https://github.com/DIKER0K/Comfort/releases/latest/download/Comfort.zip';
      config.apiReleaseUrl =
        'https://api.github.com/repos/DIKER0K/Comfort/releases/latest';
    }

    // Если есть конфигурационный файл, загружаем из него
    if (fs.existsSync(configPath)) {
      try {
        const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
        config = { ...config, ...savedConfig };
      } catch (error) {
        console.warn(`Ошибка чтения конфигурации ${versionId}:`, error);
      }
    }

    return { success: true, config };
  } catch (error) {
    console.error('Ошибка получения настроек версии:', error);
    return { success: false, error: error.message };
  }
});