'use strict';

/*
 * main.js – Electron Hauptprozess für ViperCraft
 * Phase 1: Fenster, Instanz-Verwaltung, Einstellungen.
 * (Vanilla-Start, Microsoft-Login und Mod-Loader folgen in späteren Phasen.)
 */

const { app, BrowserWindow, ipcMain, dialog, shell, safeStorage, Notification, Tray, Menu, nativeImage } = require('electron');
const path = require('path');
const fs = require('fs');
const os = require('os');
const { execFile } = require('child_process');
const pkg = require('../package.json');
const store = require('./store');
const services = require('./services');
const launcher = require('./launcher');
const loaders = require('./loaders');
const forge = require('./forge');
const auth = require('./auth');
const updater = require('./updater');
const icons = require('./icons');
const bedrock = require('./bedrock');
const backup = require('./backup');
const mmcimport = require('./mmcimport');
const cfimport = require('./cfimport');
const mcimport = require('./mcimport');
const technicimport = require('./technicimport');
const technicdiscover = require('./technicdiscover');
const javadl = require('./javadl');
const crashreports = require('./crashreports');
const skins = require('./skins');
const servers = require('./servers');
const mcping = require('./mcping');

// undici als globales fetch verwenden -> ermöglicht Proxy via setGlobalDispatcher
const undici = require('undici');
globalThis.fetch = undici.fetch;
globalThis.Headers = undici.Headers;
globalThis.Request = undici.Request;
globalThis.Response = undici.Response;

// ---------------------------------------------------------------------------
// Automatische Überwachung der Anmelde-Dienste
// ---------------------------------------------------------------------------

const AUTH_ENDPOINTS = [
  { name: 'Microsoft-Login', url: 'https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode' },
  { name: 'Xbox Live', url: 'https://user.auth.xboxlive.com/user/authenticate' },
  { name: 'Minecraft-Dienste', url: 'https://api.minecraftservices.com/minecraft/profile' },
];

let authHealth = { ok: true, checked: null, down: [] };

async function checkAuthServices() {
  const down = [];
  for (const ep of AUTH_ENDPOINTS) {
    try {
      const ctrl = new AbortController();
      const t = setTimeout(() => ctrl.abort(), 8000);
      // Antwort-Status ist egal (401/404 = Dienst lebt); nur Ausfall/5xx zählt als "down"
      const res = await fetch(ep.url, { method: 'GET', signal: ctrl.signal, headers: { 'User-Agent': 'AeroMC-Launcher/0.28' } });
      clearTimeout(t);
      if (res.status >= 500) down.push(ep.name);
    } catch {
      down.push(ep.name);
    }
  }
  authHealth = { ok: down.length === 0, checked: new Date().toISOString(), down };
  if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('auth:health', authHealth);
  return authHealth;
}

function applyProxy(s) {
  try {
    if (s.proxyEnabled && s.proxyHost && String(s.proxyPort).trim()) {
      const cred = s.proxyUser ? `${encodeURIComponent(s.proxyUser)}:${encodeURIComponent(s.proxyPass || '')}@` : '';
      undici.setGlobalDispatcher(new undici.ProxyAgent(`http://${cred}${s.proxyHost}:${s.proxyPort}`));
    } else {
      undici.setGlobalDispatcher(new undici.Agent());
    }
  } catch { /* ungültige Proxy-Konfig ignorieren */ }
}

let mainWindow = null;

// ---------------------------------------------------------------------------
// Verknüpfungen: "AeroMC.exe --launch <id>" startet eine Instanz direkt
// ---------------------------------------------------------------------------

// Nur eine Instanz des Launchers. Ein zweiter Aufruf (Doppelklick auf eine
// Verknüpfung) reicht seine Argumente an das laufende Fenster weiter.
const hatEinzelSperre = app.requestSingleInstanceLock();
if (!hatEinzelSperre) app.quit();

/*
 * Instanz-Kennung aus den Startargumenten lesen.
 *
 * Wichtig: Bei einem zweiten Start sortiert Chromium die Argumente um –
 * alle Schalter wandern nach vorn, alles andere ans Ende. Aus
 *   --launch  1.21.11
 * wird dabei
 *   --launch  --allow-file-access-from-files  <pfad>  1.21.11
 * und die Kennung steht nicht mehr hinter ihrem Schalter. Deshalb wird die
 * Form "--launch=<kennung>" verwendet: die bleibt ein einziges Argument.
 */
function instanzAusArgumenten(argv) {
  const args = (argv || []).map(String);

  for (const a of args) {
    if (a.startsWith('--launch=')) return a.slice('--launch='.length);
  }

  // Notnagel für Verknüpfungen aus früheren Fassungen (und den Aufruf von
  // Hand): Steht "--launch" allein da, ist die Kennung durch das Umsortieren
  // ans Ende gerutscht – das letzte Argument, das kein Schalter ist.
  if (args.includes('--launch')) {
    const i = args.indexOf('--launch');
    if (args[i + 1] && !args[i + 1].startsWith('-')) return args[i + 1];
    for (let j = args.length - 1; j > 0; j--) {
      if (!args[j].startsWith('-')) return args[j];
    }
  }
  return null;
}

// wie instanzAusArgumenten, nur für die optionale Server-Adresse einer
// Server-Verknüpfung ("--server=<ip>") – bleibt aus demselben Grund als ein
// einziges "--server=..."-Argument zusammen
function serverAusArgumenten(argv) {
  const args = (argv || []).map(String);
  for (const a of args) {
    if (a.startsWith('--server=')) return a.slice('--server='.length);
  }
  return null;
}

// Startwunsch an die Oberfläche geben – dort hängt die gesamte Rückmeldung dran
function starteInstanzImFenster(id, serverIp) {
  if (!id || !mainWindow || mainWindow.isDestroyed()) return;
  mainWindow.webContents.send('instance:launch-request', { id, serverIp: serverIp || null });
}

app.on('second-instance', (_e, argv) => {
  // showMainWindow() statt nur restore()+focus(): bei aktivem Autostart kann
  // das Fenster echt versteckt sein (hide(), nicht nur minimiert) – das
  // braucht ein show(), sonst bleibt es beim zweiten Start unsichtbar
  showMainWindow();
  starteInstanzImFenster(instanzAusArgumenten(argv), serverAusArgumenten(argv));
});

// Ziel für Verknüpfungen: bei der Portable-Fassung zeigt process.execPath auf
// den entpackten Temp-Ordner – eine Verknüpfung dorthin wäre morgen tot.
function verknuepfungsZiel() {
  if (updater.detectInstallKind() === 'portable') {
    return updater.portableTarget() || process.execPath;
  }
  return process.execPath;
}

/*
 * Baut die Argumente für eine Verknüpfung zusammen.
 * Im Entwicklungsmodus (npm start) zeigt process.execPath nur auf die nackte
 * electron.exe – die weiß ohne Pfadangabe nicht, welche App sie laden soll,
 * und zeigt stattdessen ihren eigenen Startbildschirm statt AeroMC. Im
 * gepackten Build (Setup/Portable) ist die App fest eingebaut, daher dort
 * kein Zusatz nötig.
 */
function verknuepfungsArgs(teile) {
  const praefix = app.isPackaged ? '' : `"${path.join(__dirname, '..')}" `;
  return praefix + teile.join(' ');
}

/*
 * Icon für eine Verknüpfung. Im gepackten Build trägt die EXE selbst schon
 * das richtige Icon als Ressource (funktioniert auch aus dem asar heraus).
 * Im Entwicklungsmodus zeigt "ziel" auf die nackte electron.exe (Atom-Logo) –
 * dort stattdessen direkt die eigene .ico-Datei verwenden, die im
 * Entwicklungsordner als normale Datei vorliegt.
 */
function verknuepfungsIcon(ziel) {
  if (app.isPackaged) return ziel;
  return windowIcon() || ziel;
}

function windowIcon() {
  const png = path.join(__dirname, 'assets', 'logo.png');
  const ico = path.join(__dirname, 'assets', 'icon.ico');
  if (fs.existsSync(ico)) return ico;
  if (fs.existsSync(png)) return png;
  return undefined; // Electron-Standard, solange kein Logo hinterlegt ist
}

function createWindow(startHidden) {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 820,
    minWidth: 940,
    minHeight: 640,
    backgroundColor: '#1b1e24',
    title: 'AeroMC',
    icon: windowIcon(),
    autoHideMenuBar: true,
    show: !startHidden,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: false,
    },
  });

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

  // Bei aktivem Autostart landet das Fenster beim Schließen (X) nur im
  // Infobereich, statt AeroMC wirklich zu beenden – sonst wäre der
  // Autostart witzlos, weil man ihn beim ersten Wegklicken gleich wieder los ist.
  mainWindow.on('close', (e) => {
    if (appIsQuitting || !store.getSettings().autostart) return;
    e.preventDefault();
    mainWindow.hide();
  });

  // mit "--launch <id>" gestartet -> Instanz anwerfen, sobald die Oberfläche
  // ihren Empfänger dafür registriert hat. WICHTIG: nicht auf "did-finish-load"
  // verlassen – das feuert, sobald die Seite geladen ist, aber die Oberfläche
  // registriert ihren IPC-Listener erst nach eigenem asynchronem Vorlauf
  // (u. a. Skin-Hintergrund laden). Kommt der Startwunsch früher an als diese
  // Registrierung, geht er kommentarlos verloren – ein Wettlauf, der je nach
  // Netzwerk-/Ladegeschwindigkeit mal gewinnt, mal nicht. Deshalb wartet der
  // Hauptprozess hier auf ein explizites Bereit-Signal der Oberfläche.
  const startId = instanzAusArgumenten(process.argv);
  const startServer = serverAusArgumenten(process.argv);
  if (startId) {
    ipcMain.once('renderer:ready', () => starteInstanzImFenster(startId, startServer));
  }
}

let tray = null;
let appIsQuitting = false;

function showMainWindow() {
  if (!mainWindow || mainWindow.isDestroyed()) { createWindow(false); return; }
  if (mainWindow.isMinimized()) mainWindow.restore();
  mainWindow.show();
  mainWindow.focus();
}

function createTray() {
  if (tray) return;
  try {
    const iconPfad = windowIcon();
    const bild = iconPfad ? nativeImage.createFromPath(iconPfad) : nativeImage.createEmpty();
    tray = new Tray(bild.isEmpty() ? nativeImage.createEmpty() : bild.resize({ width: 16, height: 16 }));
    tray.setToolTip('AeroMC');
    tray.setContextMenu(Menu.buildFromTemplate([
      { label: 'Öffnen', click: () => showMainWindow() },
      { type: 'separator' },
      { label: 'Beenden', click: () => { appIsQuitting = true; app.quit(); } },
    ]));
    tray.on('click', () => showMainWindow());
  } catch { /* z. B. wenn kein Icon vorhanden ist – Autostart läuft dann ohne Tray-Symbol weiter */ }
}

function destroyTray() {
  if (tray) { tray.destroy(); tray = null; }
}

// Windows-Autostart-Eintrag setzen/entfernen + Tray-Symbol passend ein-/ausblenden
function applyAutostart(enabled) {
  try {
    app.setLoginItemSettings({ openAtLogin: !!enabled, args: enabled ? ['--hidden'] : [] });
  } catch { /* z. B. in portabler Umgebung ohne Schreibrechte auf die Registry */ }
  if (enabled) createTray();
  else destroyTray();
}

app.whenReady().then(() => {
  if (!hatEinzelSperre) return;   // zweite Instanz beendet sich selbst
  store.init(app.getPath('userData'));
  services.setCacheDir(app.getPath('userData'));   // Java-Suche zwischenspeichern
  // selbst geholte Laufzeiten: ablegen und bei der Java-Suche mitberücksichtigen
  services.setManagedJavaDir(javadl.setJavaDir(path.join(app.getPath('userData'), 'java')));
  // Konten verschlüsselt speichern (Windows-DPAPI, an das Benutzerkonto gebunden)
  auth.init(app.getPath('userData'), {
    available: () => { try { return safeStorage.isEncryptionAvailable(); } catch { return false; } },
    encrypt: (s) => safeStorage.encryptString(s).toString('base64'),
    decrypt: (b) => safeStorage.decryptString(Buffer.from(b, 'base64')),
  });
  applyProxy(store.getSettings());
  const autostartAn = !!store.getSettings().autostart;
  // Autostart-Eintrag/Tray mit der Einstellung synchron halten (falls z. B.
  // von Hand an der Registry gedreht wurde oder nach einem Update)
  applyAutostart(autostartAn);
  const startHidden = autostartAn && process.argv.includes('--hidden');
  createWindow(startHidden);

  // Java-Suche im Hintergrund vorbereiten -> erster Spielstart ohne Verzögerung
  setTimeout(() => { try { services.scanJava(); } catch { /* egal */ } }, 800);

  // echte Minecraft-Icons einmalig aus den eigenen Spieldateien holen
  setTimeout(() => {
    try {
      const { shared, out } = iconDirs();
      if (!fs.existsSync(out) || fs.readdirSync(out).length === 0) icons.extractIcons(shared, out);
    } catch { /* noch keine Version heruntergeladen */ }
  }, 1500);

  // Reste früherer Update-Downloads aufräumen (mehrere hundert MB im Temp)
  setTimeout(() => { try { updater.cleanupUpdateCache(); } catch { /* egal */ } }, 6000);

  // Sicherung nach Zeitplan: kurz nach dem Start prüfen, danach stündlich.
  // Die Prüfung ist billig – gesichert wird nur, wenn wirklich fällig.
  setTimeout(() => { backupNachZeitplan('zeitplan').catch(() => {}); }, 60000);
  setInterval(() => { backupNachZeitplan('zeitplan').catch(() => {}); }, 3600000);

  // automatisch auf Updates prüfen (kurz nach dem Start)
  setTimeout(async () => {
    try {
      const info = await updater.checkForUpdate(app.getVersion());
      if (mainWindow && !mainWindow.isDestroyed()) {
        // Ergebnis immer melden, damit die Info-Seite auch "aktuell" anzeigen
        // kann – nicht erst wenn der Nutzer manuell auf "Suchen" klickt
        mainWindow.webContents.send('update:checked', info);
        if (info.available) mainWindow.webContents.send('update:available', info);
      }
    } catch (err) {
      // offline o. Ä. – kein Absturz, aber die Info-Seite darf den Fehler zeigen
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('update:checked', { error: (err && err.message) || String(err) });
      }
    }
  }, 4000);

  // Anmelde-Dienste automatisch überwachen (sofort + alle 2 Minuten)
  setTimeout(() => checkAuthServices(), 2500);
  setInterval(() => checkAuthServices(), 120000);

  // Anmeldung im Hintergrund auffrischen -> kein erneuter Login beim Start nötig
  const cid = store.getSettings().azureClientId || auth.DEFAULT_CLIENT_ID;
  auth.getValidAccount(cid)
    .then((acc) => {
      if (acc && mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('auth:refreshed');
    })
    .catch(() => { /* offline o. Ä. – Konto bleibt gespeichert */ });

  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

app.on('before-quit', () => { appIsQuitting = true; });

// ---------------------------------------------------------------------------
// Java-Erkennung (für Anzeige in den Einstellungen)
// ---------------------------------------------------------------------------

function detectJava(javaPath) {
  return new Promise((resolve) => {
    const cmd = javaPath && javaPath.trim() ? javaPath : 'java';
    execFile(cmd, ['-version'], (err, stdout, stderr) => {
      if (err) return resolve({ ok: false, path: cmd, version: null, error: err.message });
      // "java -version" schreibt nach stderr
      const out = (stderr || stdout || '').split('\n')[0].trim();
      resolve({ ok: true, path: cmd, version: out });
    });
  });
}

// ---------------------------------------------------------------------------
// IPC – Einstellungen
// ---------------------------------------------------------------------------

ipcMain.handle('settings:get', () => store.getSettings());

ipcMain.handle('settings:save', (_e, patch) => {
  const s = store.saveSettings(patch);
  applyProxy(s);
  if (patch && Object.prototype.hasOwnProperty.call(patch, 'autostart')) applyAutostart(s.autostart);
  return s;
});

ipcMain.handle('settings:instancesDir', () => store.getInstancesDir());

ipcMain.handle('java:detect', (_e, javaPath) => detectJava(javaPath));

// automatische Java-Suche über das System
ipcMain.handle('java:scan', () => services.scanJava(false));   // Knopf sucht immer frisch
// aus dem Zwischenspeicher – für Dialoge, die nur die Liste anzeigen wollen
ipcMain.handle('java:list', () => services.scanJava(true));

// ---------------------------------------------------------------------------
// IPC – Minecraft-Versionen (Mojang)
// ---------------------------------------------------------------------------

ipcMain.handle('mc:versions', () => services.getMcVersions(app.getPath('userData')));

// ---------------------------------------------------------------------------
// IPC – Mods (Modrinth)
// ---------------------------------------------------------------------------

ipcMain.handle('curseforge:testKey', async (_e, apiKey) => {
  try { return await services.curseforgeTestKey(apiKey); }
  catch (err) { return { ok: false, message: err.message || String(err) }; }
});

ipcMain.handle('mods:search', async (_e, opts) => {
  const o = opts || {};
  const source = o.source || 'modrinth';
  try {
    if (source === 'curseforge') {
      const zugang = services.curseforgeZugang(store.getSettings());
      return await services.curseforgeSearch(zugang, o);
    }
    return await services.modrinthSearch(o);
  } catch (err) {
    return {
      total: 0,
      hits: [],
      error: (err && err.message) ? err.message : String(err),
      needKey: !!(err && err.code === 'need-key'),
    };
  }
});

ipcMain.handle('mods:list', (_e, id, art) => store.listMods(id, art || 'mod'));

ipcMain.handle('mods:install', async (_e, id, project, art) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const typ = services.inhaltsArt(art || 'mod');
  const gameVersion = inst.minecraft.version;
  const loader = inst.minecraft.loader;
  if (!gameVersion) return { ok: false, message: 'Instanz hat keine Minecraft-Version gesetzt.' };
  // Nur Mods brauchen einen Loader – Ressourcenpakete und Shader laufen auch
  // in einer Vanilla-Instanz.
  if (typ.loaderNoetig && (!loader || loader === 'vanilla')) {
    return { ok: false, message: 'Mods brauchen einen Mod-Loader (Fabric/Forge/NeoForge/Quilt).' };
  }

  const modsDir = store.inhaltsDir(id, art || 'mod');
  const done = new Set(store.listMods(id, art || 'mod').map((m) => m.projectId));
  const added = [];
  let firstError = null;
  const istCf = !!(project && (project.source === 'curseforge' || String(project.projectId || '').startsWith('cf-')));
  const zugang = istCf ? services.curseforgeZugang(store.getSettings()) : null;

  // installiert ein Projekt und rekursiv seine PFLICHT-Abhängigkeiten
  async function installOne(proj, isDep) {
    if (done.has(proj.projectId)) return;
    done.add(proj.projectId);
    try {
      let res;
      if (String(proj.projectId || '').startsWith('cf-') || proj.source === 'curseforge') {
        res = await services.curseforgeInstall({
          zugang, projectId: proj.projectId, title: proj.title,
          gameVersion, loader, modsDir, art: art || 'mod',
        });
        if (!res.ok) {
          if (!isDep && !firstError) firstError = res.message;
          return;
        }
        // merken, welche Pflicht-Abhängigkeiten dieser Mod mitbringt – damit
        // wir beim Entfernen warnen können, wenn ein anderer Mod ihn braucht
        res.entry.requiredDeps = (res.dependencies || [])
          .filter((d) => d.required && d.projectId).map((d) => d.projectId);
        store.addMod(id, res.entry, art || 'mod');
        added.push(res.entry);
        for (const dep of res.dependencies || []) {
          if (dep.required && dep.projectId && !done.has(dep.projectId)) {
            await installOne({ projectId: dep.projectId, title: dep.projectId, source: 'curseforge' }, true);
          }
        }
      } else {
        res = await services.modrinthInstall({
          projectId: proj.projectId, title: proj.title, gameVersion, loader, modsDir, art: art || 'mod',
        });
        if (!res.ok) {
          if (!isDep && !firstError) firstError = res.message;
          return;
        }
        res.entry.requiredDeps = (res.dependencies || [])
          .filter((d) => d.dependency_type === 'required' && d.project_id).map((d) => d.project_id);
        store.addMod(id, res.entry, art || 'mod');
        added.push(res.entry);
        for (const dep of res.dependencies || []) {
          if (dep.dependency_type === 'required' && dep.project_id && !done.has(dep.project_id)) {
            const title = await services.modrinthProjectTitle(dep.project_id);
            await installOne({ projectId: dep.project_id, title }, true);
          }
        }
      }
    } catch (err) {
      if (!isDep && !firstError) firstError = err.message;
    }
  }

  await installOne(project, false);
  if (!added.length) return { ok: false, message: firstError || 'Installation fehlgeschlagen.' };
  return { ok: true, entry: added[0], added, depCount: added.length - 1 };
});

/*
 * Lokale Datei(en) direkt in den Inhaltsordner kopieren – für Mods, die
 * nicht über Modrinth/CurseForge zu finden sind (Dev-Build, privater Mod,
 * per Hand zugeschickt). Die Datei taucht danach ganz normal in der
 * "Installiert"-Liste auf, weil listMods() den Ordner ohnehin mitscannt.
 */
ipcMain.handle('mods:addFile', async (_e, id, art) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const typ = services.inhaltsArt(art || 'mod');
  const filters = (art || 'mod') === 'mod'
    ? [{ name: 'Mod-Datei', extensions: ['jar', 'zip'] }]
    : [{ name: typ.label || 'Datei', extensions: ['zip'] }];
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Datei hinzufügen',
    properties: ['openFile', 'multiSelections'],
    filters: filters.concat([{ name: 'Alle Dateien', extensions: ['*'] }]),
  });
  if (res.canceled || !res.filePaths.length) return { ok: false, canceled: true };

  const dir = store.inhaltsDir(id, art || 'mod');
  fs.mkdirSync(dir, { recursive: true });
  const added = [];
  const failed = [];
  for (const src of res.filePaths) {
    try {
      if (!/\.(jar|zip)$/i.test(src)) {
        failed.push({ name: path.basename(src), message: 'Nur .jar/.zip-Dateien werden unterstützt.' });
        continue;
      }
      const name = path.basename(src);
      const ext = path.extname(name);
      const base = name.slice(0, -ext.length);
      let dest = path.join(dir, name);
      // Namenskollision -> durchnummerieren statt eine vorhandene Datei zu überschreiben
      let n = 2;
      while (fs.existsSync(dest)) { dest = path.join(dir, `${base} (${n})${ext}`); n++; }
      fs.copyFileSync(src, dest);
      added.push(path.basename(dest));
    } catch (err) {
      failed.push({ name: path.basename(src), message: err.message });
    }
  }
  return { ok: true, added, failed };
});

// verfügbare Loader-Versionen (Fabric/Quilt) für eine MC-Version
ipcMain.handle('loaders:versions', async (_e, loader, mcVersion) => {
  try { return await loaders.listLoaderVersions(loader, mcVersion); }
  catch { return []; }
});

ipcMain.handle('mods:remove', (_e, id, filename, art) => store.removeMod(id, filename, art || 'mod'));
// prüft, ob andere installierte Mods diesen hier als Pflicht-Abhängigkeit brauchen
ipcMain.handle('mods:dependents', (_e, id, filename, art) => store.findDependents(id, filename, art || 'mod'));

// Vorhandener Arbeitsspeicher – Grundlage für die Prüfung der RAM-Angaben
function gesamtSpeicherMb() {
  return Math.round(os.totalmem() / 1048576);
}

ipcMain.handle('system:memory', () => ({
  totalMb: gesamtSpeicherMb(),
  freeMb: Math.round(os.freemem() / 1048576),
}));

ipcMain.handle('system:checkMemory', (_e, minMb, maxMb) =>
  services.pruefeSpeicher(minMb, maxMb, gesamtSpeicherMb()));

// Neuester Absturzbericht einer Instanz; seit = Startzeitpunkt in Millisekunden
ipcMain.handle('crash:latest', (_e, id, seit) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, grund: 'keine-instanz' };
  return crashreports.lies(store.gameDir(id), Number(seit) || 0);
});

// ---- Serverliste (servers.dat) ----

ipcMain.handle('servers:list', (_e, id) => {
  if (!store.getInstance(id)) return { ok: false, message: 'Instanz nicht gefunden.' };
  return servers.lies(store.gameDir(id));
});

ipcMain.handle('servers:add', (_e, id, eintrag) => {
  if (!store.getInstance(id)) return { ok: false, message: 'Instanz nicht gefunden.' };
  return servers.fuegeHinzu(store.gameDir(id), eintrag || {});
});

ipcMain.handle('servers:remove', (_e, id, ip) => {
  if (!store.getInstance(id)) return { ok: false, message: 'Instanz nicht gefunden.' };
  return servers.entferne(store.gameDir(id), ip);
});

ipcMain.handle('servers:rename', (_e, id, ip, neuerName) => {
  if (!store.getInstance(id)) return { ok: false, message: 'Instanz nicht gefunden.' };
  return servers.benenneUm(store.gameDir(id), ip, neuerName);
});

// Live-Status eines Servers abfragen (MOTD/Spielerzahl/Version) – wie der
// Vanilla-Mehrspieler-Bildschirm, ohne sich wirklich zu verbinden
ipcMain.handle('servers:ping', async (_e, ip) => {
  const s = String(ip || '').trim();
  const m = s.match(/^([^:]+)(?::(\d+))?$/);
  if (!m) return { ok: false, message: 'Ungültige Adresse.' };
  const host = m[1];
  const port = m[2] ? Number(m[2]) : 25565;
  try { return await mcping.pingServer(host, port); }
  catch (err) { return { ok: false, message: err.message }; }
});

// denselben Server in weitere Instanzen übertragen
ipcMain.handle('servers:copyTo', (_e, zielIds, eintrag) => {
  const erledigt = [];
  const fehler = [];
  for (const zielId of zielIds || []) {
    const inst = store.getInstance(zielId);
    if (!inst) { fehler.push({ id: zielId, message: 'Instanz nicht gefunden.' }); continue; }
    const res = servers.uebertrage(store.gameDir(zielId), eintrag || {});
    if (res.ok) erledigt.push(inst.name);
    else fehler.push({ name: inst.name, message: res.message });
  }
  return { ok: true, erledigt, fehler };
});

// Logdateien der Instanz – auch nach einem Neustart des Launchers
ipcMain.handle('logs:list', (_e, id) => {
  if (!store.getInstance(id)) return [];
  return crashreports.listeLogs(store.gameDir(id));
});

ipcMain.handle('logs:read', (_e, id, name) => {
  if (!store.getInstance(id)) return { ok: false, grund: 'keine-instanz' };
  return crashreports.liesLog(store.gameDir(id), name);
});

ipcMain.handle('logs:openFolder', (_e, id) => {
  if (!store.getInstance(id)) return false;
  const dir = crashreports.logOrdner(store.gameDir(id));
  if (!fs.existsSync(dir)) return false;
  shell.openPath(dir);
  return true;
});

// Ordner mit den Absturzberichten öffnen
ipcMain.handle('crash:openFolder', (_e, id) => {
  const inst = store.getInstance(id);
  if (!inst) return false;
  const dir = crashreports.berichtsOrdner(store.gameDir(id));
  if (!fs.existsSync(dir)) return false;
  shell.openPath(dir);
  return true;
});

// Mod ab-/anschalten statt löschen (Datei wird nur umbenannt)
ipcMain.handle('mods:setEnabled', (_e, id, filename, enabled, art) => {
  const res = store.setModEnabled(id, filename, !!enabled, art || 'mod');
  if (res.ok) return res;
  const ordner = services.inhaltsArt(art || 'mod').ordner;
  const gruende = {
    'not-found': `Die Datei liegt nicht mehr im ${ordner}-Ordner.`,
    'both-exist': `Es liegen beide Fassungen im ${ordner}-Ordner (an und abgeschaltet). Bitte eine davon von Hand entfernen.`,
    'bad-name': 'Ungültiger Dateiname.',
  };
  return { ok: false, message: gruende[res.reason] || res.reason };
});

// sucht für die installierten Mods nach neueren Dateien (lädt noch nichts)
ipcMain.handle('mods:checkUpdates', async (_e, id, art) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const gameVersion = inst.minecraft.version;
  const loader = inst.minecraft.loader;
  if (!gameVersion) return { ok: false, message: 'Instanz hat keine Minecraft-Version gesetzt.' };
  try {
    const res = await services.modrinthFindUpdates(store.listMods(id, art || 'mod'), gameVersion, loader, (p) => {
      if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('mods:updateProgress', p);
    }, art || 'mod');
    return { ok: true, ...res };
  } catch (err) {
    return { ok: false, message: 'Update-Suche fehlgeschlagen: ' + err.message };
  }
});

// lädt die gewählten Aktualisierungen und ersetzt die alten Dateien
ipcMain.handle('mods:applyUpdates', async (_e, id, projectIds, art) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const gameVersion = inst.minecraft.version;
  const loader = inst.minecraft.loader;
  const sorte = art || 'mod';
  const modsDir = store.inhaltsDir(id, sorte);
  const gewuenscht = new Set(projectIds || []);
  const erneuert = [];
  const fehler = [];

  for (const mod of store.listMods(id, sorte)) {
    if (!mod.projectId || !gewuenscht.has(mod.projectId)) continue;
    try {
      const res = await services.modrinthInstall({
        projectId: mod.projectId, title: mod.title, gameVersion, loader, modsDir, art: sorte,
      });
      if (!res.ok) { fehler.push({ title: mod.title, message: res.message }); continue; }
      store.addMod(id, res.entry, sorte);
      // alte Datei erst weg, wenn die neue liegt – und nie, wenn sie gleich heißt
      if (mod.filename && mod.filename !== res.entry.filename) store.removeMod(id, mod.filename, sorte);
      // war der Eintrag abgeschaltet, bleibt er es auch nach dem Update
      if (mod.enabled === false) store.setModEnabled(id, res.entry.filename, false, sorte);
      erneuert.push({ title: mod.title, von: mod.versionNumber || '?', auf: res.entry.versionNumber });
    } catch (err) {
      fehler.push({ title: mod.title, message: err.message });
    }
  }
  return { ok: true, erneuert, fehler };
});

// ---------------------------------------------------------------------------
// IPC – Microsoft-Login (Phase 3)
// ---------------------------------------------------------------------------

ipcMain.handle('auth:status', () => auth.currentAccount());
ipcMain.handle('auth:health', () => authHealth);
ipcMain.handle('auth:recheck', () => checkAuthServices());
// "playing" kommt aus den tatsächlich laufenden Spielen, nicht aus dem Aktiv-Merkmal
ipcMain.handle('auth:accounts', () => auth.listAccounts()
  .map((a) => Object.assign({}, a, { playing: spielendeKonten.has(a.id) })));
ipcMain.handle('auth:setActive', (_e, id) => auth.setActive(id));

// ---- Skin des aktiven Kontos ----

// gültiges Zugangstoken des aktiven Kontos holen
async function aktivesToken() {
  const clientId = store.getSettings().azureClientId || auth.DEFAULT_CLIENT_ID;
  const acc = await auth.getValidAccount(clientId);
  return acc && acc.mcAccessToken ? acc.mcAccessToken : null;
}

ipcMain.handle('skin:profile', async () => {
  const token = await aktivesToken();
  if (!token) return { ok: false, message: 'Kein angemeldetes Konto.' };
  try { return await skins.holeProfil(token); }
  catch (err) { return { ok: false, message: 'Profil konnte nicht geladen werden: ' + err.message }; }
});

ipcMain.handle('skin:choose', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Skin auswählen',
    properties: ['openFile'],
    filters: [{ name: 'PNG-Bild', extensions: ['png'] }],
  });
  if (res.canceled || !res.filePaths.length) return { ok: false, canceled: true };
  const pfad = res.filePaths[0];
  // sofort prüfen, damit der Nutzer nicht erst nach dem Hochladen erfährt,
  // dass die Datei nicht passt
  const geprueft = skins.pruefeDatei(pfad);
  if (!geprueft.ok) return geprueft;
  // gleich als Bilddaten mitgeben, damit die Vorschau ohne Dateizugriff
  // im Renderer auskommt
  let dataUri = '';
  try { dataUri = 'data:image/png;base64,' + fs.readFileSync(pfad).toString('base64'); } catch { /* egal */ }
  return { ok: true, pfad, breite: geprueft.breite, hoehe: geprueft.hoehe, dataUri };
});

ipcMain.handle('skin:apply', async (_e, dateiPfad, variante) => {
  const token = await aktivesToken();
  if (!token) return { ok: false, message: 'Kein angemeldetes Konto.' };
  try { return await skins.setzeSkin(token, dateiPfad, variante); }
  catch (err) { return { ok: false, message: 'Skin konnte nicht gesetzt werden: ' + err.message }; }
});

ipcMain.handle('skin:reset', async () => {
  const token = await aktivesToken();
  if (!token) return { ok: false, message: 'Kein angemeldetes Konto.' };
  try { return await skins.setzeSkinZurueck(token); }
  catch (err) { return { ok: false, message: 'Zurücksetzen fehlgeschlagen: ' + err.message }; }
});
ipcMain.handle('auth:remove', (_e, id) => auth.removeAccount(id));
ipcMain.handle('auth:logout', () => { auth.clearAccount(); return true; });

ipcMain.handle('auth:login', async () => {
  const clientId = store.getSettings().azureClientId || auth.DEFAULT_CLIENT_ID;
  try {
    const account = await auth.login(
      clientId,
      (code) => {
        if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('auth:code', code);
      },
      () => {},
    );
    return { ok: true, account };
  } catch (err) {
    return { ok: false, message: err.message };
  }
});

// ---------------------------------------------------------------------------
// IPC – Instanzen
// ---------------------------------------------------------------------------

ipcMain.handle('instances:list', () => store.listInstances());

ipcMain.handle('instances:get', (_e, id) => store.getInstance(id));

ipcMain.handle('instances:create', (_e, data) => store.createInstance(data));

ipcMain.handle('instances:update', (_e, id, patch) => store.updateInstance(id, patch));

ipcMain.handle('instances:delete', (_e, id) => store.deleteInstance(id));

ipcMain.handle('instances:duplicate', (_e, id) => store.duplicateInstance(id));

ipcMain.handle('instances:openFolder', (_e, id) => {
  const p = store.instancePath(id);
  if (fs.existsSync(p)) shell.openPath(p);
  return true;
});

ipcMain.handle('instances:openGameDir', (_e, id) => {
  const p = store.gameDir(id);
  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
  shell.openPath(p);
  return true;
});

// ---- Welten & Ressourcenpakete ----

function listDir(dir, dirsOnly) {
  if (!fs.existsSync(dir)) return [];
  return fs.readdirSync(dir, { withFileTypes: true })
    .filter((e) => (dirsOnly ? e.isDirectory() : true) && !e.name.startsWith('.'))
    .map((e) => {
      let size = 0;
      try { size = fs.statSync(path.join(dir, e.name)).size; } catch { /* egal */ }
      return { name: e.name, isDir: e.isDirectory(), size };
    });
}

ipcMain.handle('instance:worlds', (_e, id) => listDir(path.join(store.gameDir(id), 'saves'), true));
ipcMain.handle('instance:resourcepacks', (_e, id) => listDir(path.join(store.gameDir(id), 'resourcepacks'), false));
ipcMain.handle('instance:datapacks', (_e, id) => listDir(path.join(store.gameDir(id), 'datapacks'), false));

function safeSub(id, sub, name) {
  const base = path.join(store.gameDir(id), sub);
  const target = path.join(base, name);
  // Pfad-Ausbruch verhindern
  if (!target.startsWith(base + path.sep)) return null;
  return target;
}

ipcMain.handle('instance:deleteContent', (_e, id, sub, name) => {
  const target = safeSub(id, sub, name);
  if (target && fs.existsSync(target)) fs.rmSync(target, { recursive: true, force: true });
  return true;
});

ipcMain.handle('instance:openSubdir', (_e, id, sub) => {
  const p = path.join(store.gameDir(id), sub);
  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
  shell.openPath(p);
  return true;
});

// ---- Screenshots ----

ipcMain.handle('instance:screenshots', (_e, id) =>
  listDir(path.join(store.gameDir(id), 'screenshots'), false)
    .filter((f) => /\.(png|jpe?g|gif|webp)$/i.test(f.name))
    .sort((a, b) => b.name.localeCompare(a.name)));

ipcMain.handle('instance:screenshotData', (_e, id, name) => {
  const target = safeSub(id, 'screenshots', name);
  try {
    if (!target || !fs.existsSync(target)) return null;
    if (fs.statSync(target).size > 12 * 1024 * 1024) return null;
    let ext = path.extname(target).slice(1).toLowerCase();
    if (ext === 'jpg') ext = 'jpeg';
    return `data:image/${ext};base64,` + fs.readFileSync(target).toString('base64');
  } catch { return null; }
});

ipcMain.handle('instance:openScreenshot', (_e, id, name) => {
  const target = safeSub(id, 'screenshots', name);
  if (target && fs.existsSync(target)) shell.openPath(target);
  return true;
});

// ---- Instanz Import/Export (ZIP über Windows-Bordmittel) ----

function runPwsh(command, env) {
  return new Promise((resolve, reject) => {
    execFile('powershell', ['-NoProfile', '-NonInteractive', '-Command', command],
      { env: Object.assign({}, process.env, env), windowsHide: true, maxBuffer: 64 * 1024 * 1024 },
      (err, stdout, stderr) => (err ? reject(new Error(stderr || err.message)) : resolve(stdout)));
  });
}

ipcMain.handle('instances:export', async (_e, id) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const safe = (inst.name || 'instanz').replace(/[^\w.-]+/g, '_');
  const res = await dialog.showSaveDialog(mainWindow, {
    title: 'Instanz exportieren',
    defaultPath: safe + '.zip',
    filters: [{ name: 'ZIP-Archiv', extensions: ['zip'] }],
  });
  if (res.canceled) return { ok: false, canceled: true };
  try {
    if (fs.existsSync(res.filePath)) fs.unlinkSync(res.filePath);
    await runPwsh("Compress-Archive -Path (Join-Path $env:VN_SRC '*') -DestinationPath $env:VN_DST -Force",
      { VN_SRC: store.instancePath(id), VN_DST: res.filePath });
    return { ok: true, path: res.filePath };
  } catch (err) {
    return { ok: false, message: 'Export fehlgeschlagen: ' + err.message };
  }
});

/*
 * Schnellsicherung EINER Welt als ZIP – unabhängig vom globalen
 * Backup-System, landet in einem eigenen Unterordner der Dokumente.
 */
ipcMain.handle('world:backup', async (_e, id, worldName) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const worldDir = path.join(store.gameDir(id), 'saves', String(worldName || ''));
  if (path.dirname(worldDir) !== path.join(store.gameDir(id), 'saves') || !fs.existsSync(worldDir)) {
    return { ok: false, message: 'Welt nicht gefunden.' };
  }

  try {
    const zielOrdner = path.join(app.getPath('documents'), 'AeroMC Launcher', 'Welten-Sicherungen',
      (inst.name || 'Instanz').replace(/[^\w.-]+/g, '_'));
    fs.mkdirSync(zielOrdner, { recursive: true });
    const zeitstempel = new Date().toISOString().replace(/[:T]/g, '-').slice(0, 16);
    const safeWorld = String(worldName).replace(/[^\w.-]+/g, '_');
    const zielDatei = path.join(zielOrdner, `${safeWorld}_${zeitstempel}.zip`);
    if (fs.existsSync(zielDatei)) fs.unlinkSync(zielDatei);

    await runPwsh("Compress-Archive -Path (Join-Path $env:VN_SRC '*') -DestinationPath $env:VN_DST -Force",
      { VN_SRC: worldDir, VN_DST: zielDatei });
    notify('Welt gesichert', `${worldName} (${inst.name}) wurde gesichert.`);
    return { ok: true, path: zielDatei };
  } catch (err) {
    return { ok: false, message: 'Sicherung fehlgeschlagen: ' + err.message };
  }
});

// ---- Modpack-Import (Modrinth .mrpack) ----

async function importMrpack(buf, zip) {
  const raw = forge.readZipEntry(buf, zip['modrinth.index.json']).toString('utf8').replace(/^/, '');
  const index = JSON.parse(raw);
  const deps = index.dependencies || {};
  let loader = 'vanilla', loaderVersion = '';
  if (deps['fabric-loader']) { loader = 'fabric'; loaderVersion = deps['fabric-loader']; }
  else if (deps['quilt-loader']) { loader = 'quilt'; loaderVersion = deps['quilt-loader']; }
  else if (deps.forge) { loader = 'forge'; loaderVersion = deps.forge; }
  else if (deps.neoforge) { loader = 'neoforge'; loaderVersion = deps.neoforge; }

  const created = store.createOrReplaceImportedInstance({
    name: index.name || 'Modpack',
    minecraft: { version: deps.minecraft || '', loader, loaderVersion },
  });
  const gameDir = store.gameDir(created.id);
  const inside = (dest) => dest.startsWith(gameDir + path.sep);

  const eingespielt = await spieleMrpackEin(buf, zip, index, gameDir, { schonePlayerDaten: false });

  // Herkunft merken, damit sich das Paket später aktualisieren lässt
  const herkunft = await modpackHerkunft(buf, index);
  store.updateInstance(created.id, { modpack: Object.assign(herkunft, { dateien: eingespielt.dateien }) });

  return {
    ok: true,
    instance: store.getInstance(created.id),
    fileCount: eingespielt.dateien.length,
  };
}

/*
 * Spielt ein .mrpack in ein Spielverzeichnis ein.
 * schonePlayerDaten: bei einer Aktualisierung bleiben Welten, Bildschirmfotos
 * und die Optionen unangetastet – sonst wären die Einstellungen des Spielers weg.
 * -> { dateien: [relative Pfade] }
 */
const SPIELERDATEN = [/^saves\//i, /^screenshots\//i, /^logs\//i, /^options\.txt$/i, /^servers\.dat$/i];

async function spieleMrpackEin(buf, zip, index, gameDir, { schonePlayerDaten }) {
  const inside = (dest) => dest.startsWith(gameDir + path.sep);
  const geschuetzt = (rel) => schonePlayerDaten && SPIELERDATEN.some((r) => r.test(rel));
  const dateien = [];

  const files = (index.files || []).filter((f) => !(f.env && f.env.client === 'unsupported'));
  let i = 0;
  for (const f of files) {
    i++;
    const url = f.downloads && f.downloads[0];
    if (!url || !f.path) continue;
    const rel = String(f.path).replace(/\\/g, '/');
    if (geschuetzt(rel)) continue;
    const dest = path.join(gameDir, rel.replace(/\//g, path.sep));
    if (!inside(dest)) continue;
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', { phase: 'modpack', current: i, total: files.length, detail: 'Modpack-Dateien' });
    }
    try {
      const res = await fetch(url, { headers: { 'User-Agent': 'AeroMC-Launcher' } });
      if (!res.ok) continue;
      fs.mkdirSync(path.dirname(dest), { recursive: true });
      fs.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
      dateien.push(rel);
    } catch { /* einzelne Datei überspringen */ }
  }

  // overrides einspielen
  for (const prefix of ['overrides/', 'client-overrides/']) {
    for (const name of Object.keys(zip)) {
      if (!name.startsWith(prefix) || name.endsWith('/')) continue;
      const rel = name.slice(prefix.length);
      if (geschuetzt(rel)) continue;
      const dest = path.join(gameDir, rel.replace(/\//g, path.sep));
      if (!inside(dest)) continue;
      fs.mkdirSync(path.dirname(dest), { recursive: true });
      fs.writeFileSync(dest, forge.readZipEntry(buf, zip[name]));
      dateien.push(rel);
    }
  }
  return { dateien };
}

/*
 * Woher stammt das Paket? Modrinth kennt jede veröffentlichte Datei an ihrer
 * Prüfsumme – darüber finden wir Projekt und Fassung, ohne den Nutzer zu fragen.
 */
async function modpackHerkunft(buf, index) {
  const basis = {
    quelle: 'modrinth',
    name: index.name || '',
    versionNummer: index.versionId || '',
    projectId: '',
    versionId: '',
  };
  try {
    const sha1 = require('crypto').createHash('sha1').update(buf).digest('hex');
    const res = await fetch(`https://api.modrinth.com/v2/version_file/${sha1}?algorithm=sha1`,
      { headers: { 'User-Agent': 'AeroMC-Launcher', Accept: 'application/json' } });
    if (res.ok) {
      const v = await res.json();
      basis.projectId = v.project_id || '';
      basis.versionId = v.id || '';
      basis.versionNummer = v.version_number || basis.versionNummer;
    }
  } catch { /* offline oder unbekanntes Paket – dann eben ohne Herkunft */ }
  return basis;
}

// ---- Modpack aktualisieren (Modrinth) ----

/*
 * Sucht eine neuere Fassung des installierten Modpacks.
 * -> { ok, verfuegbar, aktuelleNummer, neueNummer, ... }
 */
ipcMain.handle('modpack:check', async (_e, id) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const mp = inst.modpack;
  if (!mp || !mp.projectId) {
    return { ok: false, message: 'Für diese Instanz ist kein Modrinth-Modpack hinterlegt. '
      + 'Aktualisieren geht nur bei Instanzen, die aus einem .mrpack entstanden sind.' };
  }
  try {
    const res = await fetch(`https://api.modrinth.com/v2/project/${mp.projectId}/version`,
      { headers: { 'User-Agent': 'AeroMC-Launcher', Accept: 'application/json' } });
    if (!res.ok) return { ok: false, message: 'Modrinth antwortet mit HTTP ' + res.status };
    const versionen = await res.json();
    if (!Array.isArray(versionen) || !versionen.length) return { ok: true, verfuegbar: false };

    const neueste = versionen[0];
    const verfuegbar = neueste.id !== mp.versionId;
    return {
      ok: true,
      verfuegbar,
      name: mp.name,
      aktuelleNummer: mp.versionNummer || '?',
      neueNummer: neueste.version_number,
      neueVersionId: neueste.id,
      hinweise: neueste.changelog || '',
      spielVersion: (neueste.game_versions || [])[0] || '',
    };
  } catch (err) {
    return { ok: false, message: 'Suche fehlgeschlagen: ' + err.message };
  }
});

/*
 * Spielt eine neuere Fassung ein. Dateien der alten Fassung, die es nicht mehr
 * gibt, werden entfernt; Welten, Bildschirmfotos und Optionen bleiben.
 */
ipcMain.handle('modpack:update', async (_e, id, versionId) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  const mp = inst.modpack;
  if (!mp || !mp.projectId) return { ok: false, message: 'Kein Modpack hinterlegt.' };

  try {
    const vres = await fetch(`https://api.modrinth.com/v2/version/${versionId}`,
      { headers: { 'User-Agent': 'AeroMC-Launcher', Accept: 'application/json' } });
    if (!vres.ok) return { ok: false, message: 'Fassung nicht abrufbar (HTTP ' + vres.status + ').' };
    const version = await vres.json();
    const datei = (version.files || []).find((f) => f.primary) || (version.files || [])[0];
    if (!datei || !datei.url) return { ok: false, message: 'Diese Fassung enthält keine Paketdatei.' };

    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', { id, phase: 'modpack', detail: 'Neue Fassung wird geladen …' });
    }
    const dl = await fetch(datei.url, { headers: { 'User-Agent': 'AeroMC-Launcher' } });
    if (!dl.ok) return { ok: false, message: 'Download fehlgeschlagen (HTTP ' + dl.status + ').' };
    const buf = Buffer.from(await dl.arrayBuffer());

    const zip = forge.readZipIndex(buf);
    if (!zip['modrinth.index.json']) return { ok: false, message: 'Die geladene Datei ist kein .mrpack.' };
    const index = JSON.parse(forge.readZipEntry(buf, zip['modrinth.index.json']).toString('utf8').replace(/^/, ''));

    const gameDir = store.gameDir(id);
    const neu = await spieleMrpackEin(buf, zip, index, gameDir, { schonePlayerDaten: true });

    // Was die alte Fassung mitbrachte und die neue nicht mehr kennt, muss weg –
    // sonst bleiben alte Mods liegen und der Loader stolpert darüber.
    const behalten = new Set(neu.dateien.map((d) => d.toLowerCase()));
    const entfernt = [];
    for (const alt of mp.dateien || []) {
      if (behalten.has(String(alt).toLowerCase())) continue;
      if (SPIELERDATEN.some((r) => r.test(alt))) continue;
      const p = path.join(gameDir, String(alt).replace(/\//g, path.sep));
      if (!p.startsWith(gameDir + path.sep)) continue;
      try {
        if (fs.existsSync(p)) { fs.rmSync(p, { force: true }); entfernt.push(alt); }
      } catch { /* egal */ }
    }

    // Minecraft-Version und Loader können sich mit der neuen Fassung ändern
    const deps = index.dependencies || {};
    let loader = 'vanilla'; let loaderVersion = '';
    if (deps['fabric-loader']) { loader = 'fabric'; loaderVersion = deps['fabric-loader']; }
    else if (deps['quilt-loader']) { loader = 'quilt'; loaderVersion = deps['quilt-loader']; }
    else if (deps.forge) { loader = 'forge'; loaderVersion = deps.forge; }
    else if (deps.neoforge) { loader = 'neoforge'; loaderVersion = deps.neoforge; }

    store.updateInstance(id, {
      minecraft: { version: deps.minecraft || inst.minecraft.version, loader, loaderVersion },
      modpack: Object.assign({}, mp, {
        versionId: version.id,
        versionNummer: version.version_number,
        dateien: neu.dateien,
      }),
    });

    notify('Modpack aktualisiert', `${inst.name} ist auf Version ${version.version_number} aktualisiert.`);
    return {
      ok: true,
      neueNummer: version.version_number,
      eingespielt: neu.dateien.length,
      entfernt: entfernt.length,
      spielVersion: deps.minecraft || '',
    };
  } catch (err) {
    return { ok: false, message: 'Aktualisierung fehlgeschlagen: ' + err.message };
  }
});

// ---- Modpack-Import (CurseForge .zip mit manifest.json) ----

// "forge-47.2.0" / "fabric-0.15.7" -> { loader, loaderVersion }
function loaderAusManifest(manifest) {
  const eintraege = (manifest.minecraft && manifest.minecraft.modLoaders) || [];
  const primaer = eintraege.find((l) => l && l.primary) || eintraege[0];
  const id = String((primaer && primaer.id) || '');
  const m = id.match(/^(forge|neoforge|fabric|quilt)-(.+)$/i);
  if (!m) return { loader: 'vanilla', loaderVersion: '' };
  return { loader: m[1].toLowerCase(), loaderVersion: m[2] };
}

async function importCurseForge(buf, zip, zugang) {
  const raw = forge.readZipEntry(buf, zip['manifest.json']).toString('utf8').replace(/^/, '');
  const manifest = JSON.parse(raw);
  const { loader, loaderVersion } = loaderAusManifest(manifest);

  const created = store.createOrReplaceImportedInstance({
    name: manifest.name || 'CurseForge-Modpack',
    minecraft: {
      version: (manifest.minecraft && manifest.minecraft.version) || '',
      loader,
      loaderVersion,
    },
  });
  const gameDir = store.gameDir(created.id);
  const inside = (dest) => dest.startsWith(gameDir + path.sep);
  const melde = (detail, current, total) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', { phase: 'modpack', current, total, detail });
    }
  };

  // 1) Dateiliste über die CurseForge-API auflösen
  const dateien = (manifest.files || []).filter((f) => f && f.fileID);
  melde('Dateiliste abrufen', 0, dateien.length);
  const aufgeloest = await services.curseforgeResolveFiles(zugang, dateien,
    (p) => melde('Dateiliste abrufen', p.aufgeloest, p.gesamt));

  // 2) Mods herunterladen
  const modsDir = path.join(gameDir, 'mods');
  let geladen = 0;
  const fehlend = [];
  let i = 0;
  for (const f of dateien) {
    i++;
    const info = aufgeloest.get(Number(f.fileID));
    if (!info) { fehlend.push(f.fileID); continue; }
    const dest = path.join(modsDir, path.basename(info.fileName));
    if (!inside(dest)) continue;
    melde('Mods laden', i, dateien.length);
    try {
      // Das CurseForge-CDN verlangt seit Juli 2026 auch beim reinen Dateiabruf
      // einen gültigen Schlüssel. Bei der Weiterleitung setzt ihn der Server.
      await services.downloadFile(info.url, dest, info.kopfzeilen);
      geladen++;
    } catch {
      fehlend.push(f.fileID);
    }
  }

  // 3) overrides einspielen
  const prefix = (manifest.overrides || 'overrides').replace(/\/*$/, '') + '/';
  for (const name of Object.keys(zip)) {
    if (!name.startsWith(prefix) || name.endsWith('/')) continue;
    const dest = path.join(gameDir, name.slice(prefix.length).replace(/\//g, path.sep));
    if (!inside(dest)) continue;
    fs.mkdirSync(path.dirname(dest), { recursive: true });
    fs.writeFileSync(dest, forge.readZipEntry(buf, zip[name]));
  }

  return {
    ok: true,
    instance: store.getInstance(created.id),
    fileCount: dateien.length,
    geladen,
    fehlend: fehlend.length,
  };
}

ipcMain.handle('modpack:search', async (_e, opts) => {
  try {
    const q = Object.assign({}, opts || {}, { art: 'modpack' });
    return await services.modrinthSearch(q);
  } catch (err) {
    return { total: 0, hits: [], error: err.message };
  }
});

ipcMain.handle('modpack:installFromModrinth', async (_e, project) => {
  try {
    const projectId = project && (project.projectId || project.id);
    if (!projectId) return { ok: false, message: 'Kein Modpack gewählt.' };
    const gameVersion = (project && project.gameVersion) || '';
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', {
        phase: 'modpack', detail: 'Modpack-Version wird ermittelt …',
      });
    }
    const file = await services.modrinthResolveModpack({ projectId, gameVersion });
    if (!file) {
      return {
        ok: false,
        message: gameVersion
          ? ('Keine Modpack-Version für Minecraft ' + gameVersion + ' gefunden.')
          : 'Keine Modpack-Version gefunden.',
      };
    }
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', {
        phase: 'modpack',
        detail: 'Lade ' + (file.filename || file.name || 'Modpack') + ' …',
      });
    }
    const buf = await services.downloadBuffer(file.url);
    const zip = forge.readZipIndex(buf);
    if (!zip['modrinth.index.json']) {
      return { ok: false, message: 'Die geladene Datei ist kein gültiges Modrinth-Modpack (.mrpack).' };
    }
    const result = await importMrpack(buf, zip);
    if (result && result.ok && result.instance) {
      // Herkunft mit aktueller Version-ID ergänzen, falls der Index sie nicht trägt
      const inst = result.instance;
      const mp = Object.assign({}, inst.modpack || {}, {
        projectId: projectId,
        versionId: file.versionId,
        versionNumber: file.versionNumber,
        title: (project && project.title) || (inst.modpack && inst.modpack.title) || inst.name,
      });
      store.updateInstance(inst.id, { modpack: mp });
      result.instance = store.getInstance(inst.id);
    }
    if (result && result.ok && result.instance) {
      notify('Modpack installiert', `${result.instance.name} ist einsatzbereit.`);
    }
    return result;
  } catch (err) {
    return { ok: false, message: 'Modpack-Installation fehlgeschlagen: ' + err.message };
  }
});

/*
 * Kern des Modpack-Datei-Imports, unabhängig davon ob der Pfad aus einem
 * Dateidialog oder per Drag&Drop aufs Fenster kommt.
 * notModpack: true heißt "kein Modpack-Format erkannt" – der Aufrufer kann
 * dann noch andere ZIP-Interpretationen probieren (z. B. Instanz-Export).
 */
async function importModpackFromPath(filePath) {
  try {
    const buf = fs.readFileSync(filePath);
    const zip = forge.readZipIndex(buf);
    let result = null;
    if (zip['modrinth.index.json']) {
      result = await importMrpack(buf, zip);
    } else if (zip['manifest.json']) {
      const zugang = services.curseforgeZugang(store.getSettings());
      if (!zugang) {
        return { ok: false, needsKey: true,
          message: 'CurseForge-Modpacks brauchen einen Zugang. Trage in den Netzwerk-Einstellungen entweder deinen eigenen API-Key ein (kostenlos über console.curseforge.com) oder die Adresse einer CurseForge-Weiterleitung.' };
      }
      result = await importCurseForge(buf, zip, zugang);
    } else {
      return { ok: false, notModpack: true, message: 'Unbekanntes Modpack-Format (keine modrinth.index.json gefunden).' };
    }
    if (result && result.ok && result.instance) {
      notify('Modpack installiert', `${result.instance.name} ist einsatzbereit.`);
    }
    return result;
  } catch (err) {
    return { ok: false, notModpack: true, message: 'Modpack-Import fehlgeschlagen: ' + err.message };
  }
}

ipcMain.handle('modpack:import', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Modpack importieren',
    properties: ['openFile'],
    filters: [{ name: 'Modpacks', extensions: ['mrpack', 'zip'] }],
  });
  if (res.canceled) return { ok: false, canceled: true };
  return importModpackFromPath(res.filePaths[0]);
});

// Verknüpfung auf dem Desktop, die genau diese Instanz startet
// wunschName: optionaler, vom Nutzer selbst vergebener Dateiname (ohne .lnk)
ipcMain.handle('instances:shortcut', (_e, id, wunschName) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  if (process.platform !== 'win32') {
    return { ok: false, message: 'Verknüpfungen werden nur unter Windows unterstützt.' };
  }
  try {
    const roh = (wunschName && wunschName.trim()) || inst.name || 'Instanz';
    const name = String(roh).replace(/[\\/:*?"<>|]/g, '_').trim() || 'Instanz';
    const datei = path.join(app.getPath('desktop'), name + '.lnk');
    const ziel = verknuepfungsZiel();
    const ok = shell.writeShortcutLink(datei, fs.existsSync(datei) ? 'replace' : 'create', {
      target: ziel,
      // Gleichheitsform, damit die Kennung beim Umsortieren durch Chromium
      // an ihrem Schalter bleibt (siehe instanzAusArgumenten)
      args: verknuepfungsArgs([`--launch="${id}"`]),
      cwd: path.dirname(ziel),
      description: 'AeroMC – ' + inst.name,
      icon: verknuepfungsIcon(ziel),
      iconIndex: 0,
    });
    if (!ok) return { ok: false, message: 'Verknüpfung konnte nicht geschrieben werden.' };
    return { ok: true, path: datei };
  } catch (err) {
    return { ok: false, message: 'Verknüpfung fehlgeschlagen: ' + err.message };
  }
});

/*
 * Desktop-Verknüpfung, die eine Instanz startet UND direkt mit einem
 * bestimmten Server verbindet (Quick Play, ab Minecraft 1.20). Technisch
 * dasselbe wie instances:shortcut, nur mit zusätzlichem "--server="-Argument.
 * wunschName: optionaler, vom Nutzer selbst vergebener Dateiname (ohne .lnk)
 */
ipcMain.handle('servers:shortcut', (_e, id, ip, name, wunschName) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  if (!ip) return { ok: false, message: 'Keine Serveradresse angegeben.' };
  if (process.platform !== 'win32') {
    return { ok: false, message: 'Verknüpfungen werden nur unter Windows unterstützt.' };
  }
  try {
    const rohName = (wunschName && wunschName.trim())
      || `${inst.name || 'Instanz'} - ${name || ip}`;
    const dateiName = String(rohName).replace(/[\\/:*?"<>|]/g, '_').trim() || 'Server';
    const datei = path.join(app.getPath('desktop'), `${dateiName}.lnk`);
    const ziel = verknuepfungsZiel();
    const ok = shell.writeShortcutLink(datei, fs.existsSync(datei) ? 'replace' : 'create', {
      target: ziel,
      // Gleichheitsform für beide Kennungen, damit sie beim Umsortieren durch
      // Chromium zusammenbleiben (siehe instanzAusArgumenten)
      args: verknuepfungsArgs([`--launch="${id}"`, `--server="${ip}"`]),
      cwd: path.dirname(ziel),
      description: `AeroMC – ${inst.name} → ${name || ip}`,
      icon: verknuepfungsIcon(ziel),
      iconIndex: 0,
    });
    if (!ok) return { ok: false, message: 'Verknüpfung konnte nicht geschrieben werden.' };
    return { ok: true, path: datei };
  } catch (err) {
    return { ok: false, message: 'Verknüpfung fehlgeschlagen: ' + err.message };
  }
});

/*
 * Kern des ZIP-Instanz-Imports (AeroMC-Export oder einzelne MultiMC/Prism-
 * Instanz), unabhängig davon ob der Pfad aus einem Dateidialog oder per
 * Drag&Drop aufs Fenster kommt.
 */
async function importInstanceZipFromPath(filePath) {
  const tmp = path.join(app.getPath('temp'), 'vn-import-' + Date.now());
  try {
    fs.mkdirSync(tmp, { recursive: true });
    await runPwsh('Expand-Archive -Path $env:VN_SRC -DestinationPath $env:VN_DST -Force',
      { VN_SRC: filePath, VN_DST: tmp });

    // instance.json finden (auch in Unterordner)
    let base = tmp;
    if (!fs.existsSync(path.join(base, 'instance.json'))) {
      const sub = fs.readdirSync(tmp).map((n) => path.join(tmp, n))
        .find((p) => { try { return fs.statSync(p).isDirectory() && fs.existsSync(path.join(p, 'instance.json')); } catch { return false; } });
      if (sub) base = sub;
    }
    // Kein eigener Export? Dann auf eine MultiMC/Prism-Instanz prüfen –
    // die bringt statt instance.json eine instance.cfg mit.
    if (!fs.existsSync(path.join(base, 'instance.json'))) {
      const mmc = mmcimport.scanSingle(tmp);
      if (mmc.ok) {
        const done = mmcimport.importOne(store, mmc.instance, true);
        return { ok: true, instance: store.getInstance(done.id), quelle: 'multimc', copied: done.copied };
      }
      throw new Error('Keine gültige Instanz im Archiv (weder instance.json noch instance.cfg).');
    }
    const imported = JSON.parse(fs.readFileSync(path.join(base, 'instance.json'), 'utf8'));
    const created = store.createOrReplaceImportedInstance({
      name: imported.name || 'Import',
      icon: imported.icon || 'grass',
      notes: imported.notes || '',
      minecraft: imported.minecraft || {},
    });
    if (imported.java) store.updateInstance(created.id, { java: imported.java });

    const mcSrc = path.join(base, 'minecraft');
    if (fs.existsSync(mcSrc)) fs.cpSync(mcSrc, store.gameDir(created.id), { recursive: true });
    const modsSrc = path.join(base, 'mods.json');
    if (fs.existsSync(modsSrc)) fs.copyFileSync(modsSrc, path.join(store.instancePath(created.id), 'mods.json'));
    if (imported.customImage && fs.existsSync(path.join(base, imported.customImage))) {
      fs.copyFileSync(path.join(base, imported.customImage), path.join(store.instancePath(created.id), imported.customImage));
      store.updateInstance(created.id, { customImage: imported.customImage });
    }
    return { ok: true, instance: store.getInstance(created.id) };
  } catch (err) {
    return { ok: false, message: 'Import fehlgeschlagen: ' + err.message };
  } finally {
    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* egal */ }
  }
}

ipcMain.handle('instances:import', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Instanz importieren',
    properties: ['openFile'],
    filters: [{ name: 'ZIP-Archiv', extensions: ['zip'] }],
  });
  if (res.canceled) return { ok: false, canceled: true };
  return importInstanceZipFromPath(res.filePaths[0]);
});

/*
 * Datei per Drag&Drop aufs Fenster gezogen. Anhand der Endung/des Inhalts
 * wird entschieden, was damit passieren soll:
 *   .jar             -> als Mod/Ressourcenpaket/Shader in die übergebene
 *                        Instanz kopieren (targetId/targetArt vom Renderer,
 *                        je nachdem was gerade offen bzw. ausgewählt ist)
 *   .mrpack / .zip    -> zuerst als Modpack versuchen (Modrinth/CurseForge),
 *                        sonst als AeroMC-/MultiMC-Instanz-Export
 */
ipcMain.handle('files:drop', async (_e, filePath, targetId, targetArt) => {
  if (!filePath || !fs.existsSync(filePath)) return { ok: false, message: 'Datei nicht gefunden.' };
  const ext = path.extname(filePath).toLowerCase();

  if (ext === '.jar') {
    if (!targetId) {
      return { ok: false, message: 'Bitte zuerst eine Instanz öffnen (Mods-Dialog), dann die Datei dort hineinziehen.' };
    }
    const inst = store.getInstance(targetId);
    if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
    const art = targetArt || 'mod';
    const dir = store.inhaltsDir(targetId, art);
    fs.mkdirSync(dir, { recursive: true });
    try {
      const name = path.basename(filePath);
      const ext2 = path.extname(name);
      const base = name.slice(0, -ext2.length);
      let dest = path.join(dir, name);
      let n = 2;
      while (fs.existsSync(dest)) { dest = path.join(dir, `${base} (${n})${ext2}`); n++; }
      fs.copyFileSync(filePath, dest);
      return { ok: true, kind: 'mod', added: [path.basename(dest)] };
    } catch (err) {
      return { ok: false, message: err.message };
    }
  }

  if (ext === '.mrpack' || ext === '.zip') {
    const modpack = await importModpackFromPath(filePath);
    // .mrpack ist immer ein Modpack – bei Fehlschlag direkt die Meldung
    // zeigen, statt es zusätzlich noch als Instanz-Export zu probieren
    if (!modpack.notModpack || ext === '.mrpack') return Object.assign({ kind: 'modpack' }, modpack);
    // .zip ohne erkanntes Modpack-Format -> als Instanz-Export/-Import versuchen
    const instanceRes = await importInstanceZipFromPath(filePath);
    return Object.assign({ kind: 'instance' }, instanceRes);
  }

  return { ok: false, message: 'Nicht unterstützter Dateityp: ' + (ext || '(ohne Endung)') };
});

/*
 * Windows-Benachrichtigung für abgeschlossene Hintergrund-Aktionen (Backup,
 * größere Downloads) – nur wenn die Einstellung an ist UND das Fenster
 * gerade nicht im Vordergrund ist (sonst sieht man's eh schon live).
 */
function notify(title, body) {
  try {
    if (store.getSettings().desktopNotifications === false) return;
    if (mainWindow && !mainWindow.isDestroyed() && mainWindow.isFocused()) return;
    if (!Notification.isSupported()) return;
    const n = new Notification({ title, body, silent: false });
    n.on('click', () => {
      if (mainWindow && !mainWindow.isDestroyed()) {
        if (mainWindow.isMinimized()) mainWindow.restore();
        mainWindow.focus();
      }
    });
    n.show();
  } catch { /* rein informativ – darf nie einen Ablauf stören */ }
}

// ---------------------------------------------------------------------------
// Sicherungen: von Hand und nach Zeitplan
// ---------------------------------------------------------------------------

let backupLaeuft = false;

/*
 * Erstellt eine Sicherung aller Instanzen.
 * still = kein Fortschritt an die Oberfläche (für den Zeitplan im Hintergrund)
 */
async function erstelleBackup({ still } = {}) {
  if (backupLaeuft) return { ok: false, message: 'Es läuft bereits eine Sicherung.' };
  backupLaeuft = true;
  const destinationPath = backup.resolveAutoBackupPath(app.getPath('documents'));
  try {
    const result = await backup.createGlobalBackup({
      instancesDir: store.getInstancesDir(),
      userDataDir: app.getPath('userData'),
      includeSettings: true,
      destinationPath,
      onProgress: (progress) => {
        if (!still && mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('backup:progress', progress);
      },
    });
    if (!still && mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('backup:progress', { mode: 'create', percent: 100, detail: 'Backup abgeschlossen' });
    }
    if (result && result.ok) notify('Backup abgeschlossen', 'Die Sicherung aller Instanzen ist fertig.');
    return result;
  } catch (err) {
    return { ok: false, message: 'Backup fehlgeschlagen: ' + err.message };
  } finally {
    backupLaeuft = false;
  }
}

/*
 * Alte automatische Sicherungen wegräumen. Ohne das läuft die Platte voll –
 * jede Sicherung enthält sämtliche Instanzen.
 */
function raeumeAlteBackups(behalten) {
  const anzahl = Math.max(1, Number(behalten) || 5);
  try {
    const alle = backup.listGlobalBackups(app.getPath('documents'));   // neueste zuerst
    for (const b of alle.slice(anzahl)) {
      try { fs.rmSync(b.path, { force: true }); } catch { /* egal */ }
    }
    return Math.max(0, alle.length - anzahl);
  } catch { return 0; }
}

const BACKUP_ABSTAND = { daily: 24 * 3600 * 1000, weekly: 7 * 24 * 3600 * 1000 };

// Ist laut Einstellungen eine Sicherung fällig?
function backupFaellig(settings, jetzt = Date.now()) {
  if (!settings.autoBackupEnabled) return false;
  const abstand = BACKUP_ABSTAND[settings.autoBackupEvery] || BACKUP_ABSTAND.daily;
  const zuletzt = Date.parse(settings.autoBackupLast || '') || 0;
  return jetzt - zuletzt >= abstand;
}

async function backupNachZeitplan(anlass) {
  const settings = store.getSettings();
  if (!settings.autoBackupEnabled) return null;
  if (anlass === 'zeitplan' && !backupFaellig(settings)) return null;
  if (backupLaeuft) return null;

  const res = await erstelleBackup({ still: true });
  if (res && res.ok) {
    store.saveSettings({ autoBackupLast: new Date().toISOString() });
    const geloescht = raeumeAlteBackups(settings.autoBackupKeep);
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('backup:auto', {
        ok: true, anlass, datei: res.path || res.destinationPath || '', aufgeraeumt: geloescht,
      });
    }
  } else if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('backup:auto', { ok: false, anlass, message: res && res.message });
  }
  return res;
}

ipcMain.handle('backup:global', () => erstelleBackup({ still: false }));

ipcMain.handle('backup:list', async () => backup.listGlobalBackups(app.getPath('documents')));

ipcMain.handle('backup:restore', async (_e, sourcePath) => {
  if (!sourcePath || !String(sourcePath).trim()) {
    return { ok: false, message: 'Kein Backup ausgewählt.' };
  }
  try {
    const currentSettings = store.getSettings();
    const result = await backup.restoreGlobalBackup({
      sourcePath,
      instancesDir: store.getInstancesDir(),
      userDataDir: app.getPath('userData'),
      includeSettings: true,
      instancesDirSetting: currentSettings.instancesDir || null,
      onProgress: (progress) => {
        if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('backup:progress', progress);
      },
    });
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('backup:progress', { mode: 'restore', percent: 100, detail: 'Wiederherstellen abgeschlossen' });
    }
    return result;
  } catch (err) {
    return { ok: false, message: 'Wiederherstellen fehlgeschlagen: ' + err.message };
  }
});

// Phase 2: echter Vanilla-Download & -Start (Start selbst ist an Login gebunden).
/*
 * Welche Konten spielen gerade? Konto-ID -> Anzahl laufender Spiele.
 * Wie bei MultiMC wird das Konto erst beim Start gelesen; ein laufendes Spiel
 * behält seines. So kann man das aktive Konto wechseln und mit einem zweiten
 * Konto parallel starten.
 */
const spielendeKonten = new Map();

function meldeKontenAenderung() {
  if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('accounts:changed');
}

function kontoSpieltJetzt(kontoId) {
  if (!kontoId) return;
  spielendeKonten.set(kontoId, (spielendeKonten.get(kontoId) || 0) + 1);
  meldeKontenAenderung();
}

function kontoSpieltNichtMehr(kontoId) {
  if (!kontoId) return;
  const rest = (spielendeKonten.get(kontoId) || 1) - 1;
  if (rest > 0) spielendeKonten.set(kontoId, rest);
  else spielendeKonten.delete(kontoId);
  meldeKontenAenderung();
}

ipcMain.handle('instances:launch', async (_e, id, accountId, launchOpts) => {
  const inst = store.getInstance(id);
  if (!inst) return { ok: false, message: 'Instanz nicht gefunden.' };
  if (!inst.minecraft.version) {
    return { ok: false, message: 'Bitte zuerst eine Minecraft-Version wählen (Bearbeiten).' };
  }
  const settings = store.getSettings();

  // Speicherangaben prüfen, bevor Java mit einer unverständlichen Meldung
  // aussteigt. Greift auch bei von Hand bearbeiteten Instanzdateien.
  const speicher = services.pruefeSpeicher(
    inst.java.minMemMb || settings.defaultMinMemMb,
    inst.java.maxMemMb || settings.defaultMaxMemMb,
    gesamtSpeicherMb(),
  );
  if (!speicher.ok) {
    return { ok: false, message: speicher.message + ' Bitte im Bearbeiten-Dialog oder in den Einstellungen anpassen.' };
  }

  // Auf Wunsch vor dem Start sichern. Bewusst abgewartet – eine Sicherung,
  // die nebenher läuft, während Minecraft dieselben Dateien anfasst, wäre
  // nicht verlässlich.
  if (settings.autoBackupEnabled && settings.autoBackupBeforeLaunch) {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('launch:progress', { id, phase: 'backup', detail: 'Sicherung vor dem Start …' });
    }
    await backupNachZeitplan('vor-dem-start').catch(() => {});
  }

  const opts = {
    versionId: inst.minecraft.version,
    loader: inst.minecraft.loader || 'vanilla',
    loaderVersion: inst.minecraft.loaderVersion || '',
    gameDir: store.gameDir(id),
    sharedDir: path.join(app.getPath('userData'), 'shared'),
    userDataDir: app.getPath('userData'),
    javaPath: inst.java.path || settings.javaPath || '',
    minMemMb: inst.java.minMemMb || settings.defaultMinMemMb,
    maxMemMb: inst.java.maxMemMb || settings.defaultMaxMemMb,
    extraArgs: inst.java.extraArgs || '',
    preLaunchCommand: inst.preLaunchCommand || settings.globalPreLaunch || '',
    postExitCommand: inst.postExitCommand || settings.globalPostExit || '',
    wrapperCommand: settings.wrapperCommand || '',
    mcMaximized: !!settings.mcMaximized,
    mcWidth: settings.mcWidth || 854,
    mcHeight: settings.mcHeight || 480,
    auth: null,
    // fehlende Java-Fassung bei Bedarf selbst beschaffen (abschaltbar)
    ensureJava: settings.autoJava === false ? null : (major, onProgress) => javadl.ensureJava(major, onProgress),
    quickPlayServer: (launchOpts && launchOpts.quickPlayServer) ? String(launchOpts.quickPlayServer).trim() : '',
  };

  // eingeloggtes Microsoft-Konto verwenden (gewähltes oder aktives) -> echter Start
  const clientId = settings.azureClientId || auth.DEFAULT_CLIENT_ID;
  const account = accountId
    ? await auth.getValidAccountById(clientId, accountId)
    : await auth.getValidAccount(clientId);
  if (account && account.profile) {
    opts.auth = {
      name: account.profile.name,
      uuid: account.profile.id,
      accessToken: account.mcAccessToken,
      userType: 'msa',
    };
  }

  // Konto dieses Starts merken – nicht das aktive, denn das kann inzwischen
  // gewechselt worden sein, während dieses Spiel noch läuft.
  const kontoId = account && account.profile ? account.profile.id : null;
  let gezaehlt = false;

  try {
    let launchStart = 0;
    const res = await launcher.prepareAndLaunch(opts, (evt) => {
      if (evt.phase === 'launch') {
        launchStart = Date.now();
        if (!gezaehlt) { gezaehlt = true; kontoSpieltJetzt(kontoId); }
      }
      if (evt.phase === 'exit') {
        if (gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); }
        if (launchStart) {
          const secs = Math.max(0, Math.round((Date.now() - launchStart) / 1000));
          launchStart = 0;   // Spielzeit nur einmal gutschreiben
          const cur = store.getInstance(id);
          if (cur) store.updateInstance(id, { totalPlaySeconds: (cur.totalPlaySeconds || 0) + secs });
        }
      }
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('launch:progress', Object.assign({ id }, evt));
      }
    });
    // Start fehlgeschlagen, obwohl schon gezählt -> Zählung zurücknehmen,
    // sonst bliebe das Konto für immer als "spielt" stehen
    if (!res.ok && gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); }
    if (res.ok) store.updateInstance(id, { lastPlayed: new Date().toISOString() });
    return res;
  } catch (err) {
    if (gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); }
    return { ok: false, message: 'Start fehlgeschlagen: ' + err.message };
  }
});

// ---------------------------------------------------------------------------
// IPC – Dialoge
// ---------------------------------------------------------------------------

ipcMain.handle('dialog:pickFolder', async (_e, title) => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: title || 'Ordner wählen',
    properties: ['openDirectory', 'createDirectory'],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('dialog:pickImage', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Instanz-Bild wählen',
    properties: ['openFile'],
    filters: [{ name: 'Bilder', extensions: ['png', 'jpg', 'jpeg', 'gif', 'webp'] }],
  });
  return res.canceled ? null : res.filePaths[0];
});

// eigenes Bild einer Instanz zuweisen / entfernen
ipcMain.handle('instances:setImage', (_e, id, sourcePath) => {
  store.setCustomImage(id, sourcePath);
  return { meta: store.getInstance(id), iconData: store.iconDataUri(id) };
});
ipcMain.handle('instances:clearImage', (_e, id) => store.clearCustomImage(id));
ipcMain.handle('instances:icon', (_e, id) => store.iconDataUri(id));

// beliebige Bilddatei als data:-URI (für Vorschau vor dem Speichern)
ipcMain.handle('file:dataUri', (_e, filePath) => {
  try {
    const stat = fs.statSync(filePath);
    if (stat.size > 8 * 1024 * 1024) return null; // >8 MB nicht als Vorschau
    let ext = path.extname(filePath).slice(1).toLowerCase();
    if (ext === 'jpg') ext = 'jpeg';
    const buf = fs.readFileSync(filePath);
    return `data:image/${ext};base64,` + buf.toString('base64');
  } catch { return null; }
});

ipcMain.handle('dialog:pickJava', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'java.exe wählen',
    properties: ['openFile'],
    filters: [{ name: 'Java', extensions: ['exe'] }],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('app:openExternal', (_e, url) => {
  if (typeof url === 'string' && /^https?:\/\//.test(url)) shell.openExternal(url);
  return true;
});

// ---------------------------------------------------------------------------
// IPC – Instanzen aus MultiMC/Prism übernehmen
// ---------------------------------------------------------------------------

ipcMain.handle('mmc:pickFolder', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'MultiMC-Ordner wählen (der Ordner mit MultiMC.exe)',
    properties: ['openDirectory'],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('mmc:scan', (_e, folder) => {
  try { return mmcimport.scan(folder); }
  catch (err) { return { ok: false, reason: err.message }; }
});

ipcMain.handle('mmc:import', (_e, entries, copyData) => {
  const done = [];
  const failed = [];
  for (const entry of entries || []) {
    try {
      const imported = mmcimport.importOne(store, entry, copyData !== false);
      done.push(imported);
    }
    catch (err) { failed.push({ name: entry.name, message: err.message }); }
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mmc:progress', { current: done.length + failed.length, total: entries.length });
    }
  }
  return { ok: true, imported: done, failed };
});

ipcMain.handle('cf:pickFolder', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'CurseForge-Ordner wählen (oder direkt den Instances-Ordner)',
    properties: ['openDirectory'],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('cf:scan', (_e, folder) => {
  try { return cfimport.scan(folder); }
  catch (err) { return { ok: false, reason: err.message }; }
});

ipcMain.handle('cf:import', (_e, entries, copyData) => {
  const done = [];
  const failed = [];
  for (const entry of entries || []) {
    try {
      const imported = cfimport.importOne(store, entry, copyData !== false);
      done.push(imported);
    }
    catch (err) { failed.push({ name: entry.name, message: err.message }); }
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('cf:progress', { current: done.length + failed.length, total: entries.length });
    }
  }
  return { ok: true, imported: done, failed };
});

ipcMain.handle('mc:pickFolder', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Minecraft-Launcher-Ordner wählen (meist .minecraft)',
    properties: ['openDirectory'],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('mc:scan', (_e, folder) => {
  try { return mcimport.scan(folder); }
  catch (err) { return { ok: false, reason: err.message }; }
});

ipcMain.handle('mc:import', (_e, entries, copyData) => {
  const done = [];
  const failed = [];
  for (const entry of entries || []) {
    try {
      const imported = mcimport.importOne(store, entry, copyData !== false);
      done.push(imported);
    }
    catch (err) { failed.push({ name: entry.name, message: err.message }); }
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mc:progress', { current: done.length + failed.length, total: entries.length });
    }
  }
  return { ok: true, imported: done, failed };
});

ipcMain.handle('technic:pickFolder', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Technic-Ordner wählen (oder direkt den modpacks-Ordner)',
    properties: ['openDirectory'],
  });
  return res.canceled ? null : res.filePaths[0];
});

ipcMain.handle('technic:scan', (_e, folder) => {
  try { return technicimport.scan(folder); }
  catch (err) { return { ok: false, reason: err.message }; }
});

ipcMain.handle('technic:import', (_e, entries, copyData) => {
  const done = [];
  const failed = [];
  for (const entry of entries || []) {
    try {
      const imported = technicimport.importOne(store, entry, copyData !== false);
      done.push(imported);
    }
    catch (err) { failed.push({ name: entry.name, message: err.message }); }
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('technic:progress', { current: done.length + failed.length, total: entries.length });
    }
  }
  return { ok: true, imported: done, failed };
});

// ---- Technic-Plattform: Modpack-Katalog durchsuchen und direkt installieren ----

ipcMain.handle('technicPlatform:search', async (_e, query) => {
  try { return { ok: true, hits: await technicdiscover.search(query) }; }
  catch (err) { return { ok: false, message: err.message }; }
});

ipcMain.handle('technicPlatform:install', async (_e, slug) => {
  try {
    const res = await technicdiscover.installFromPlatform(store, slug, (p) => {
      if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('technicPlatform:progress', p);
    });
    if (res.ok && res.instance) notify('Modpack installiert', `${res.instance.name} ist einsatzbereit.`);
    return res;
  } catch (err) {
    return { ok: false, message: err.message };
  }
});

// ---------------------------------------------------------------------------
// IPC – Minecraft Bedrock (Windows-Store-App)
// ---------------------------------------------------------------------------

ipcMain.handle('bedrock:detect', () => bedrock.detect());
ipcMain.handle('bedrock:launch', () => bedrock.launch());
ipcMain.handle('bedrock:worlds', () => bedrock.listWorlds());
ipcMain.handle('bedrock:list', (_e, kind) => bedrock.listFolder(kind));
ipcMain.handle('bedrock:remove', (_e, kind, name) => bedrock.removeEntry(kind, name));

ipcMain.handle('bedrock:openFolder', (_e, kind) => {
  const p = bedrock.folderPath(kind);
  if (p) { fs.mkdirSync(p, { recursive: true }); shell.openPath(p); }
  return true;
});

ipcMain.handle('bedrock:installAddon', async () => {
  const res = await dialog.showOpenDialog(mainWindow, {
    title: 'Add-on oder Welt importieren',
    properties: ['openFile'],
    filters: [{ name: 'Bedrock-Pakete', extensions: ['mcpack', 'mcaddon', 'mcworld', 'mctemplate'] }],
  });
  if (res.canceled) return { ok: false, canceled: true };
  return bedrock.installAddon(res.filePaths[0]);
});

// Weltordner im Explorer zeigen
ipcMain.handle('bedrock:openWorld', (_e, dir) => {
  const base = bedrock.folderPath('worlds');
  if (base && dir && dir.startsWith(base) && fs.existsSync(dir)) shell.openPath(dir);
  return true;
});

// ---------------------------------------------------------------------------
// IPC – echte Minecraft-Icons (aus den eigenen Spieldateien)
// ---------------------------------------------------------------------------

function iconDirs() {
  const ud = app.getPath('userData');
  const parent = path.dirname(ud);
  // auch im Datenordner vor der Umbenennung suchen
  const candidates = [path.join(ud, 'shared')];
  for (const alt of ['viper-network', 'Viper-Network', 'aeromc', 'AeroMC']) {
    const p = path.join(parent, alt, 'shared');
    if (!candidates.includes(p)) candidates.push(p);
  }
  return { shared: candidates, out: path.join(ud, 'icons') };
}

ipcMain.handle('icons:list', () => {
  const { out } = iconDirs();
  return icons.listIcons(out);
});

ipcMain.handle('icons:extract', () => {
  const { shared, out } = iconDirs();
  const res = icons.extractIcons(shared, out);
  if (!res.ok) return { ok: false, reason: res.reason };
  return { ok: true, version: res.version, count: res.count, icons: icons.listIcons(out) };
});

// ---------------------------------------------------------------------------
// IPC – Automatische Updates
// ---------------------------------------------------------------------------

ipcMain.handle('update:check', async () => {
  try { return await updater.checkForUpdate(app.getVersion()); }
  catch (err) { return { available: false, error: err.message }; }
});

// Ein Klick: herunterladen, prüfen, Update anwenden und Launcher beenden
ipcMain.handle('update:install', async (_e, asset) => {
  try {
    const file = await updater.downloadAndInstall(asset, (p) => {
      if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('update:progress', p);
    });
    const res = updater.applyUpdate(file);
    // Portable: der Tausch klappt erst, wenn der Launcher die EXE freigibt
    setTimeout(() => app.quit(), 1200);
    return { ok: true, path: file.path, kind: file.kind, mode: res.started };
  } catch (err) {
    return { ok: false, message: err.message };
  }
});

ipcMain.handle('app:info', () => ({
  name: pkg.productName || pkg.build?.productName || pkg.name || 'AeroMC',
  version: app.getVersion(),
  author: pkg.author || '',
  homepage: pkg.homepage || '',
  launcherWebsite: pkg.launcherWebsite || '',
}));