// main.js — Main-Process with concurrent folder upload/download, progress events, and temp-dir cleanup
const { app, BrowserWindow, ipcMain, dialog, Menu, nativeImage, Tray, shell, clipboard } = require('electron');
const ppath = require('path');
const fs = require('fs');
const os = require('os');
const crypto = require('crypto');
const { execSync } = require('child_process');
const https = require('https');
const archiver = require('archiver');
const Updater = require('./updater.js'); // Auto-Updater
let updater = null;

const {
  createRepoGitHub,
  createRepoGitea,
  checkGiteaConnection,
  listGiteaRepos,
  getGiteaUserHeatmap,
  getGiteaRepoContents,
  getGiteaFileContent,
  uploadGiteaFile,
  getGiteaCommits,
  getGiteaCommit,
  getGiteaCommitDiff,
  getGiteaCommitFiles,
  searchGiteaCommits,
  getGiteaBranches,
  listGiteaReleases,
  getGiteaRelease,
  createGiteaRelease,
  editGiteaRelease,
  deleteGiteaRelease,
  uploadReleaseAsset,
  deleteReleaseAsset
} = require('./src/git/apiHandler.js');

const { initRepo, commitAndPush, getBranches, getCommitLogs } = require('./src/git/gitHandler.js');

// Backup system
const BackupManager = require('./src/backup/BackupManager.js');
const LocalProvider = require('./src/backup/LocalProvider.js');

// NOTE: credentials/data location is computed via getDataDir() to avoid calling app.getPath before ready
function getCredentialsFilePath() {
  return ppath.join(app.getPath('userData'), 'credentials.json');
}

const ALGORITHM = 'aes-256-cbc';
const SECRET_KEY = crypto.scryptSync('SuperSecretKey123!', 'salt', 32);
const IV = Buffer.alloc(16, 0);

// default concurrency for parallel uploads/downloads
const DEFAULT_CONCURRENCY = 4;
// temp drag cleanup delay (ms)
const TMP_CLEANUP_MS = 20_000;
const RETRY_QUEUE_INTERVAL_MS = 15_000;
const RETRY_MAX_ATTEMPTS = 8;

let retryQueue = [];
let retryQueueRunning = false;
let retryQueueTimer = null;

function getRetryQueueFilePath() {
  return ppath.join(app.getPath('userData'), 'retry-queue.json');
}

function readRetryQueueFromDisk() {
  try {
    const file = getRetryQueueFilePath();
    if (!fs.existsSync(file)) return [];
    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
    return Array.isArray(parsed) ? parsed : [];
  } catch (e) {
    console.error('readRetryQueueFromDisk error', e);
    return [];
  }
}

function saveRetryQueueToDisk() {
  try {
    const file = getRetryQueueFilePath();
    const dir = app.getPath('userData');
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(file, JSON.stringify(retryQueue, null, 2), 'utf8');
  } catch (e) {
    console.error('saveRetryQueueToDisk error', e);
  }
}

function broadcastRetryQueueUpdate(extra = {}) {
  const payload = {
    size: retryQueue.length,
    items: retryQueue.slice(0, 100),
    ...extra
  };
  for (const win of BrowserWindow.getAllWindows()) {
    try { win.webContents.send('retry-queue-updated', payload); } catch (_) {}
  }
}

function isRetryableNetworkError(errorLike) {
  const raw = String(errorLike && errorLike.message ? errorLike.message : errorLike || '').toLowerCase();
  if (!raw) return false;
  return (
    raw.includes('econnrefused') ||
    raw.includes('enotfound') ||
    raw.includes('eai_again') ||
    raw.includes('getaddrinfo') ||
    raw.includes('etimedout') ||
    raw.includes('timeout') ||
    raw.includes('econnaborted') ||
    raw.includes('socket hang up') ||
    raw.includes('503') ||
    raw.includes('502') ||
    raw.includes('504')
  );
}

function enqueueRetryWriteTask(data, reason) {
  const item = {
    id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
    type: 'write-gitea-file',
    payload: {
      owner: data.owner,
      repo: data.repo,
      path: data.path,
      content: data.content || '',
      ref: data.ref || 'HEAD'
    },
    attempts: 0,
    nextRetryAt: Date.now() + 5000,
    createdAt: new Date().toISOString(),
    lastError: String(reason || '')
  };
  retryQueue.push(item);
  saveRetryQueueToDisk();
  broadcastRetryQueueUpdate({ event: 'queued', item });
  return item;
}

async function processRetryQueueOnce() {
  if (retryQueueRunning) {
    return { ok: true, skipped: true, reason: 'already-running', size: retryQueue.length };
  }

  retryQueueRunning = true;
  const now = Date.now();
  let processed = 0;
  let succeeded = 0;
  let failed = 0;

  try {
    const credentials = readCredentials();
    const token = credentials && credentials.giteaToken;
    const url = credentials && credentials.giteaURL;

    if (!token || !url) {
      return { ok: false, error: 'missing-token-or-url', processed: 0, size: retryQueue.length };
    }

    const survivors = [];
    for (const item of retryQueue) {
      if ((item.nextRetryAt || 0) > now) {
        survivors.push(item);
        continue;
      }

      processed++;
      if (item.type !== 'write-gitea-file') {
        survivors.push(item);
        continue;
      }

      try {
        const payload = item.payload || {};
        const base64 = Buffer.from(payload.content || '', 'utf8').toString('base64');
        await uploadGiteaFile({
          token,
          url,
          owner: payload.owner,
          repo: payload.repo,
          path: payload.path,
          contentBase64: base64,
          message: `Retry edit ${payload.path} via Git Manager GUI`,
          branch: payload.ref || 'HEAD'
        });
        succeeded++;
      } catch (e) {
        const attempts = (item.attempts || 0) + 1;
        if (attempts >= RETRY_MAX_ATTEMPTS) {
          failed++;
        } else {
          const backoffMs = Math.min(300000, 5000 * Math.pow(2, attempts));
          survivors.push({
            ...item,
            attempts,
            nextRetryAt: Date.now() + backoffMs,
            lastError: String(e && e.message ? e.message : e)
          });
        }
      }
    }

    retryQueue = survivors;
    saveRetryQueueToDisk();
    broadcastRetryQueueUpdate({ event: 'processed', processed, succeeded, failed });
    return { ok: true, processed, succeeded, failed, size: retryQueue.length };
  } finally {
    retryQueueRunning = false;
  }
}

/* -----------------------------
   Utilities for safe filesystem ops
   ----------------------------- */
function ensureDir(dirPath) {
  try {
    if (fs.existsSync(dirPath)) {
      if (!fs.statSync(dirPath).isDirectory()) {
        // If a file exists where we expect a directory, remove it
        fs.unlinkSync(dirPath);
      }
    }
    fs.mkdirSync(dirPath, { recursive: true });
  } catch (e) {
    // Re-throw with clearer message
    throw new Error(`ensureDir failed for ${dirPath}: ${e && e.message ? e.message : e}`);
  }
}

/**
 * Create a safe, unique temporary directory under os.tmpdir().
 * If an entry exists at that path and it's a file, it will be removed.
 * If a directory exists it will be removed and recreated to ensure a clean state.
 * Returns the created directory path.
 *
 * baseName should be a short string (no path separators). We append a timestamp to reduce collisions.
 */
function getSafeTmpDir(baseName) {
  const safeBase = (baseName || 'tmp').replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').substring(0, 64);

  // Basis-Temp-Ordner für interne Verwaltung
  const internalBase = ppath.join(os.tmpdir(), 'gitea-drag');
  if (!fs.existsSync(internalBase)) fs.mkdirSync(internalBase, { recursive: true });

  // Eindeutiger Unterordner, um Kollisionen zu vermeiden
  const uniqueSub = crypto.randomBytes(8).toString('hex');
  const internalDir = ppath.join(internalBase, uniqueSub);
  fs.mkdirSync(internalDir, { recursive: true });

  // Sichtbarer Ordnername = safeBase
  const finalDir = ppath.join(internalDir, safeBase);
  fs.mkdirSync(finalDir, { recursive: true });

  return finalDir;
}


/* -----------------------------
   app / window
   ----------------------------- */
let tray = null;

function createTray(win) {
  const iconPath = ppath.join(__dirname, 'renderer', 'icon.png');
  tray = new Tray(nativeImage.createFromPath(iconPath).resize({ width: 16, height: 16 }));
  tray.setToolTip('Git Manager Explorer Pro');
  const menu = Menu.buildFromTemplate([
    { label: 'Öffnen', click: () => { win.show(); win.focus(); } },
    { type: 'separator' },
    { label: 'Beenden', click: () => { app.quit(); } }
  ]);
  tray.setContextMenu(menu);
  tray.on('double-click', () => { win.show(); win.focus(); });
}

function createWindow() {
  // Entfernt das Menü (File, Edit, View...) komplett
  Menu.setApplicationMenu(null);

  const startHidden = process.argv.includes('--hidden');

  const win = new BrowserWindow({
    width: 1200,
    height: 820,
    frame: false,
    show: !startHidden,
    webPreferences: {
      preload: ppath.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true
    }
  });
  win.loadFile(ppath.join(__dirname, 'renderer', 'index.html'));
  // win.webContents.openDevTools();

  createTray(win);

  // Schließen-Button -> Tray statt Beenden (nur wenn Autostart aktiv)
  win.on('close', (e) => {
    const { enabled } = app.getLoginItemSettings();
    if (enabled) {
      e.preventDefault();
      win.hide();
    }
  });
}

app.whenReady().then(() => {
  retryQueue = readRetryQueueFromDisk();
  createWindow();
  broadcastRetryQueueUpdate({ event: 'startup' });
  retryQueueTimer = setInterval(() => {
    processRetryQueueOnce().catch(e => console.error('processRetryQueueOnce timer error', e));
  }, RETRY_QUEUE_INTERVAL_MS);
  app.on('activate', () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); });
});
app.on('window-all-closed', () => { if (process.platform !== 'darwin') app.quit(); });
app.on('before-quit', () => {
  if (retryQueueTimer) {
    clearInterval(retryQueueTimer);
    retryQueueTimer = null;
  }
});

/* -----------------------------
   Helper: read credentials
   ----------------------------- */
function readCredentials() {
  try {
    const CREDENTIALS_FILE = getCredentialsFilePath();
    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
    const encrypted = fs.readFileSync(CREDENTIALS_FILE);
    const decipher = crypto.createDecipheriv(ALGORITHM, SECRET_KEY, IV);
    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
    return JSON.parse(decrypted.toString('utf8'));
  } catch (e) {
    console.error('readCredentials error', e);
    return null;
  }
}

/* ==================== BACKUP CONFIGURATION ==================== */
let backupProviders = {}; // { [repoName]: provider instance }
const backupDoneSessions = new Map(); // { [sessionId]: timestamp }

function getBackupConfigPath() {
  return ppath.join(app.getPath('userData'), 'backup-config.json');
}

function readBackupConfig() {
  try {
    const file = getBackupConfigPath();
    if (!fs.existsSync(file)) return {};
    const encrypted = fs.readFileSync(file);
    const decipher = crypto.createDecipheriv(ALGORITHM, SECRET_KEY, IV);
    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
    return JSON.parse(decrypted.toString('utf8'));
  } catch (e) {
    console.error('readBackupConfig error', e);
    return {};
  }
}

function saveBackupConfig(config) {
  try {
    const file = getBackupConfigPath();
    const dir = app.getPath('userData');
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
    const cipher = crypto.createCipheriv(ALGORITHM, SECRET_KEY, IV);
    const encrypted = Buffer.concat([cipher.update(JSON.stringify(config), 'utf8'), cipher.final()]);
    fs.writeFileSync(file, encrypted);
  } catch (e) {
    console.error('saveBackupConfig error', e);
  }
}

function getGlobalBackupKey(provider) {
  return `__global__:${provider}`;
}

async function createProviderInstance(provider, credentials) {
  if (provider !== 'local') {
    throw new Error('Nur lokaler Backup-Provider wird unterstützt.');
  }
  const providerInstance = new LocalProvider();
  await providerInstance.authenticate(credentials);
  return providerInstance;
}

function resolveBackupConfig(config, repoName, providerHint = '') {
  if (config[repoName] && config[repoName].provider === 'local') {
    return { source: 'repo', entry: config[repoName] };
  }

  if (providerHint === 'local') {
    const gk = getGlobalBackupKey(providerHint);
    if (config[gk] && config[gk].provider === 'local') {
      return { source: 'global', entry: config[gk] };
    }
  }

  for (const [key, value] of Object.entries(config)) {
    if (key.startsWith('__global__:') && value && value.provider === 'local' && value.credentials) {
      return { source: 'global', entry: value };
    }
  }

  return { source: 'none', entry: null };
}

function normalizeBackupRepoName(inputRepoName, folderPath) {
  const raw = String(inputRepoName || '').trim();
  const fromRepo = raw.includes('/') ? raw.split('/').pop() : raw;
  const fallback = String(folderPath || '').split(/[\\/]/).pop() || 'project';
  const candidate = (fromRepo || fallback).trim();
  return candidate.replace(/[<>:"/\\|?*]+/g, '-').replace(/\s+/g, '-');
}

async function ensureLocalBackupConfigured(repoName, basePath) {
  const credentials = { basePath };
  const providerInstance = await createProviderInstance('local', credentials);
  backupProviders[repoName] = providerInstance;

  const config = readBackupConfig();
  config[repoName] = { provider: 'local', credentials };
  config[getGlobalBackupKey('local')] = { provider: 'local', credentials };
  saveBackupConfig(config);
}

function mapIpcError(errorLike) {
  const raw = String(errorLike && errorLike.message ? errorLike.message : errorLike || '').toLowerCase();
  if (!raw) return 'Unbekannter Fehler.';
  if (raw.includes('401') || raw.includes('authentifizierung') || raw.includes('unauthorized')) {
    return 'Authentifizierung fehlgeschlagen. Bitte Token in den Einstellungen prüfen.';
  }
  if (raw.includes('403') || raw.includes('forbidden') || raw.includes('zugriff verweigert')) {
    return 'Zugriff verweigert. Bitte Token-Berechtigungen prüfen.';
  }
  if (raw.includes('404') || raw.includes('not found') || raw.includes('nicht gefunden')) {
    return 'Server oder Ressource nicht gefunden. Bitte URL und Repository prüfen.';
  }
  if (raw.includes('econnrefused') || raw.includes('enotfound') || raw.includes('eai_again') || raw.includes('getaddrinfo')) {
    return 'Server nicht erreichbar. Bitte DNS, IPv4/IPv6 und Port prüfen.';
  }
  if (raw.includes('timeout') || raw.includes('econnaborted')) {
    return 'Zeitüberschreitung bei der Verbindung. Bitte Netzwerk oder Server prüfen.';
  }
  if (raw.includes('http://') || raw.includes('https://') || raw.includes('ungueltige gitea url') || raw.includes('ungültige gitea url') || raw.includes('invalid')) {
    return 'Ungültige URL. Beispiel für IPv6: http://[2001:db8::1]:3000';
  }
  return String(errorLike && errorLike.message ? errorLike.message : errorLike);
}

/* -----------------------------
   Generic concurrency runner (worker pool)
   ----------------------------- */
async function runLimited(tasks, concurrency = DEFAULT_CONCURRENCY, onProgress = null) {
  const results = new Array(tasks.length);
  let index = 0;
  let processed = 0;
  const total = tasks.length;

  async function worker() {
    while (true) {
      const i = index++;
      if (i >= tasks.length) return;
      try {
        const r = await tasks[i]();
        results[i] = { ok: true, result: r };
      } catch (e) {
        results[i] = { ok: false, error: String(e) };
      } finally {
        processed++;
        if (onProgress) {
          try { onProgress(processed, total); } catch (_) {}
        }
      }
    }
  }

  const workers = Array(Math.max(1, Math.min(concurrency, tasks.length))).fill(0).map(() => worker());
  await Promise.all(workers);
  return results;
}

async function createZipFromDirectory(sourceDir, zipFilePath) {
  return new Promise((resolve, reject) => {
    const out = fs.createWriteStream(zipFilePath);
    const archive = archiver('zip', { zlib: { level: 5 } });

    out.on('close', resolve);
    out.on('error', reject);
    archive.on('error', reject);

    archive.pipe(out);
    archive.directory(sourceDir, false);
    archive.finalize();
  });
}

/* -----------------------------
   Basic IPC handlers
   ----------------------------- */
ipcMain.handle('select-folder', async () => {
  const result = await dialog.showOpenDialog({ properties: ['openDirectory'] });
  return result.canceled ? null : result.filePaths[0];
});

ipcMain.handle('select-file', async () => {
  const result = await dialog.showOpenDialog({ properties: ['openFile', 'multiSelections'] });
  if (result.canceled) return { ok: false, files: [] };
  return { ok: true, files: result.filePaths };
});

ipcMain.handle('save-credentials', async (event, data) => {
  try {
    const CREDENTIALS_FILE = getCredentialsFilePath();
    // ✅ Stelle sicher dass das userData Verzeichnis existiert
    const userDataDir = app.getPath('userData');
    if (!fs.existsSync(userDataDir)) {
      fs.mkdirSync(userDataDir, { recursive: true });
    }
    
    const json = JSON.stringify(data);
    const cipher = crypto.createCipheriv(ALGORITHM, SECRET_KEY, IV);
    const encrypted = Buffer.concat([cipher.update(json, 'utf8'), cipher.final()]);
    fs.writeFileSync(CREDENTIALS_FILE, encrypted);
    
    console.log('✅ Credentials gespeichert in:', CREDENTIALS_FILE);
    return { ok: true };
  } catch (e) {
    console.error('save-credentials error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('load-credentials', async () => {
  try {
    return readCredentials();
  } catch (e) {
    console.error('load-credentials', e);
    return null;
  }
});

/* -----------------------------
   Repo & git handlers
   ----------------------------- */
ipcMain.handle('create-repo', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };

    if (data.platform === 'github') {
      const repo = await createRepoGitHub({ 
        name: data.name,
        token: credentials.githubToken,
        auto_init: data.autoInit || true,
        license: data.license || '',
        private: data.private || false
      });
      return { ok: true, repo };
    } else if (data.platform === 'gitea') {
      const repo = await createRepoGitea({ 
        name: data.name,
        token: credentials.giteaToken, 
        url: credentials.giteaURL,
        auto_init: data.autoInit || true,
        license: data.license || '',
        private: data.private || false
      });
      return { ok: true, repo };
    } else return { ok: false, error: 'unknown-platform' };
  } catch (e) {
    console.error('create-repo error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('push-project', async (event, data) => {
  try {
    if (!data.folder || !fs.existsSync(data.folder)) return { ok: false, error: 'folder-not-found' };

    const emitPrePushStatus = (payload) => {
      try { event.sender.send('pre-push-backup-status', payload); } catch (_) {}
    };

    const credentials = readCredentials() || {};
    const autoBackupEnabled = Boolean(data.autoBackup || credentials.autoBackupEnabled);

    if (autoBackupEnabled) {
      const backupTarget = String(data.backupTarget || credentials.backupPrefLocalFolder || '').trim();
      if (!backupTarget) {
        return { ok: false, error: 'Auto-Backup ist aktiv, aber kein lokaler Backup-Zielordner ist gesetzt.' };
      }

      const backupRepoName = normalizeBackupRepoName(data.repoName, data.folder);
      try {
        emitPrePushStatus({ stage: 'backup-start', repoName: backupRepoName, target: backupTarget });
        await ensureLocalBackupConfigured(backupRepoName, backupTarget);
        const backupResult = await ipcMain._handle_create_cloud_backup(event, {
          repoName: backupRepoName,
          projectPath: data.folder
        });

        if (!backupResult?.ok) {
          emitPrePushStatus({ stage: 'backup-failed', repoName: backupRepoName, error: backupResult?.error || 'Unbekannter Fehler' });
          return { ok: false, error: `Auto-Backup vor Upload fehlgeschlagen: ${backupResult?.error || 'Unbekannter Fehler'}` };
        }
        emitPrePushStatus({ stage: 'backup-done', repoName: backupRepoName, filename: backupResult.filename || '' });
      } catch (backupErr) {
        emitPrePushStatus({ stage: 'backup-failed', repoName: backupRepoName, error: mapIpcError(backupErr) });
        return { ok: false, error: `Auto-Backup vor Upload fehlgeschlagen: ${mapIpcError(backupErr)}` };
      }
    }
    
    // Aktuellen Branch ermitteln (NICHT umbenennen!)
    let currentBranch = data.branch || null;
    try {
      const detected = execSync('git branch --show-current', { cwd: data.folder, stdio: 'pipe', encoding: 'utf-8' }).trim();
      if (detected) {
        currentBranch = currentBranch || detected;
        console.log('Current local branch:', detected);
      }
    } catch (e) {
      console.warn('Could not check local branch (maybe not a git repo yet)', e.message);
    }

    // 1. Git initialisieren, adden und commiten
    await initRepo(data.folder);

    // 2. Prüfen, ob ein 'origin' Remote existiert
    let remoteUrl = '';
    try {
      remoteUrl = execSync('git remote get-url origin', { cwd: data.folder, stdio: 'pipe', encoding: 'utf-8' }).trim();
    } catch (e) {
      if (data.repoName && data.platform) {
        const creds = readCredentials();
        if (!creds) return { ok: false, error: 'credentials-missing-for-remote' };
        const parts = data.repoName.split('/');
        if (parts.length === 2) {
          const owner = parts[0];
          const repo = parts[1];
          let constructedUrl = '';
          if (data.platform === 'gitea' && creds.giteaURL) {
            try {
              const urlObj = new URL(creds.giteaURL);
              constructedUrl = `${urlObj.protocol}//${creds.giteaToken}@${urlObj.host}/${owner}/${repo}.git`;
            } catch (err) { console.error('Invalid Gitea URL', err); }
          } else if (data.platform === 'github' && creds.githubToken) {
            constructedUrl = `https://${creds.githubToken}@github.com/${owner}/${repo}.git`;
          }
          if (constructedUrl) {
            try {
              execSync(`git remote add origin "${constructedUrl}"`, { cwd: data.folder, stdio: 'inherit' });
              console.log(`Remote origin added: ${constructedUrl}`);
            } catch (err) {
              return { ok: false, error: 'Failed to add remote origin: ' + String(err) };
            }
          } else {
            return { ok: false, error: 'Could not construct remote URL.' };
          }
        } else {
          return { ok: false, error: 'Use format Owner/RepoName.' };
        }
      }
    }

    // 3. Pushen (nutze den tatsächlichen Branch - main ODER master)
    const progressCb = percent => { try { event.sender.send('push-progress', percent); } catch (_) {} };
    const commitMsg = data.commitMessage || 'Update from Git Manager GUI';
    const pushBranch = currentBranch || 'main';
    if (autoBackupEnabled) {
      emitPrePushStatus({ stage: 'upload-start' });
    }
    await commitAndPush(data.folder, pushBranch, commitMsg, progressCb);
    
    return { ok: true };
  } catch (e) {
    console.error('push-project error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

/* ==================== BACKUP IPC HANDLERS ==================== */

ipcMain.handle('setup-backup-provider', async (event, { repoName, provider, credentials, applyGlobally = true }) => {
  try {
    if (!repoName) return { ok: false, error: 'repoName fehlt' };
    const localProvider = 'local';
    const providerInstance = await createProviderInstance(localProvider, credentials);

    // Store provider and config
    backupProviders[repoName] = providerInstance;
    const config = readBackupConfig();
    config[repoName] = { provider: localProvider, credentials };
    if (applyGlobally) {
      config[getGlobalBackupKey(localProvider)] = { provider: localProvider, credentials };
    }
    saveBackupConfig(config);

    return { ok: true, message: 'Backup provider configured', provider: localProvider, applyGlobally };
  } catch (e) {
    console.error('setup-backup-provider error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('test-backup-provider', async (event, { repoName, provider }) => {
  try {
    if (!backupProviders[repoName]) {
      const config = readBackupConfig();
      const resolved = resolveBackupConfig(config, repoName, provider);
      if (!resolved.entry) {
        return { ok: false, error: 'Backup provider not configured' };
      }
      backupProviders[repoName] = await createProviderInstance(
        resolved.entry.provider,
        resolved.entry.credentials
      );
    }

    const result = await backupProviders[repoName].testConnection();
    return result;
  } catch (e) {
    console.error('test-backup-provider error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('create-cloud-backup', async (event, { repoName, projectPath }) => {
  return ipcMain._handle_create_cloud_backup(event, { repoName, projectPath });
});

ipcMain._handle_create_cloud_backup = async (event, { repoName, projectPath }) => {
  try {
    if (!backupProviders[repoName]) {
      // Try to load from disk
      const config = readBackupConfig();
      const resolved = resolveBackupConfig(config, repoName);
      if (!resolved.entry) {
        return { ok: false, error: 'Backup not configured' };
      }

      const { provider, credentials } = resolved.entry;
      const providerInstance = await createProviderInstance(provider, credentials);

      backupProviders[repoName] = providerInstance;
      // Repo-spezifisch merken, damit es beim naechsten Mal ohne globalen Lookup klappt.
      config[repoName] = { provider, credentials };
      saveBackupConfig(config);
    }

    const manager = new BackupManager(backupProviders[repoName]);
    const result = await manager.createBackup(projectPath, repoName);

    try { event?.sender?.send('backup-created', result); } catch (_) {}
    return { ok: true, ...result };
  } catch (e) {
    console.error('create-cloud-backup error', e);
    return { ok: false, error: mapIpcError(e) };
  }
};

ipcMain.handle('list-cloud-backups', async (event, { repoName, provider }) => {
  try {
    if (!backupProviders[repoName]) {
      // Try to load from disk
      const config = readBackupConfig();
      const resolved = resolveBackupConfig(config, repoName, provider);
      if (!resolved.entry) {
        return { ok: true, backups: [] };
      }

      const entry = resolved.entry;
      const providerInstance = await createProviderInstance(entry.provider, entry.credentials);

      backupProviders[repoName] = providerInstance;
      config[repoName] = { provider: entry.provider, credentials: entry.credentials };
      saveBackupConfig(config);
    }

    const mapBackupMeta = (items) => {
      return (Array.isArray(items) ? items : []).map((b) => ({
        filename: b.filename || b.name || '',
        name: b.name || b.filename || '',
        size: Number(b.size || 0),
        modifiedTime: b.modifiedTime || b.date || null,
        date: b.date || b.modifiedTime || null
      }));
    };

    const providerInstance = backupProviders[repoName];
    const manager = new BackupManager(providerInstance);
    const showAllBackups = !repoName || repoName === 'all-git-projects';

    if (showAllBackups) {
      const backups = await providerInstance.listBackups();
      return { ok: true, backups: mapBackupMeta(backups) };
    }

    const backups = await manager.listBackups(repoName);
    return { ok: true, backups: mapBackupMeta(backups) };
  } catch (e) {
    console.error('list-cloud-backups error', e);
    return { ok: true, backups: [] };
  }
});

ipcMain.handle('restore-cloud-backup', async (event, { repoName, filename, targetPath }) => {
  try {
    if (!backupProviders[repoName]) {
      const config = readBackupConfig();
      const resolved = resolveBackupConfig(config, repoName);
      if (!resolved.entry) {
        return { ok: false, error: 'Backup provider not configured' };
      }
      backupProviders[repoName] = await createProviderInstance(
        resolved.entry.provider,
        resolved.entry.credentials
      );
    }

    const manager = new BackupManager(backupProviders[repoName]);
    const result = await manager.restoreBackup(repoName, filename, targetPath);
    return result;
  } catch (e) {
    console.error('restore-cloud-backup error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('delete-cloud-backup', async (event, { repoName, filename }) => {
  try {
    if (!backupProviders[repoName]) {
      const config = readBackupConfig();
      const resolved = resolveBackupConfig(config, repoName);
      if (!resolved.entry) {
        return { ok: false, error: 'Backup provider not configured' };
      }
      backupProviders[repoName] = await createProviderInstance(
        resolved.entry.provider,
        resolved.entry.credentials
      );
    }

    const manager = new BackupManager(backupProviders[repoName]);
    const result = await manager.deleteBackup(filename);
    return result;
  } catch (e) {
    console.error('delete-cloud-backup error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('get-backup-auth-status', async (event, { repoName, provider }) => {
  try {
    if (!repoName) return { ok: true, connected: false, source: 'none' };
    if (backupProviders[repoName]) {
      return { ok: true, connected: true, source: 'memory' };
    }

    const config = readBackupConfig();
    const resolved = resolveBackupConfig(config, repoName, provider);
    if (!resolved.entry) {
      return { ok: true, connected: false, source: 'none' };
    }

    return {
      ok: true,
      connected: true,
      source: resolved.source,
      provider: resolved.entry.provider
    };
  } catch (e) {
    return { ok: false, connected: false, source: 'none', error: mapIpcError(e) };
  }
});

ipcMain.handle('export-gitea-projects-to-local', async (event, data) => {
  try {
    const destination = String(data && data.destination ? data.destination : '').trim();
    const mode = String(data && data.mode ? data.mode : 'single');
    const owner = String(data && data.owner ? data.owner : '').trim();
    const repo = String(data && data.repo ? data.repo : '').trim();

    if (!destination) return { ok: false, error: 'Zielordner fehlt' };

    const credentials = readCredentials();
    const token = credentials && credentials.giteaToken;
    const url = credentials && credentials.giteaURL;
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };

    fs.mkdirSync(destination, { recursive: true });

    let repos = [];
    if (mode === 'all') {
      const allRepos = await listGiteaRepos({ token, url });
      repos = (allRepos || []).map(r => ({
        owner: (r.owner && (r.owner.login || r.owner.username)) || '',
        repo: r.name || ''
      })).filter(r => r.owner && r.repo);
    } else {
      if (!owner || !repo) return { ok: false, error: 'owner/repo fehlt' };
      repos = [{ owner, repo }];
    }

    let totalRepos = repos.length;
    let totalFiles = 0;
    let exportedFiles = 0;
    const exportedRepos = [];
    const formatStamp = () => {
      const now = new Date();
      const year = now.getFullYear();
      const month = String(now.getMonth() + 1).padStart(2, '0');
      const day = String(now.getDate()).padStart(2, '0');
      const hours = String(now.getHours()).padStart(2, '0');
      const minutes = String(now.getMinutes()).padStart(2, '0');
      const seconds = String(now.getSeconds()).padStart(2, '0');
      return `${year}${month}${day}-${hours}${minutes}${seconds}`;
    };

    for (let i = 0; i < repos.length; i++) {
      const pair = repos[i];
      const tempRoot = fs.mkdtempSync(ppath.join(os.tmpdir(), 'git-manager-backup-'));
      const targetRepoDir = ppath.join(tempRoot, `${pair.owner}__${pair.repo}`);
      fs.mkdirSync(targetRepoDir, { recursive: true });

      const files = [];
      async function gather(pathInRepo) {
        const contentRes = await getGiteaRepoContents({
          token,
          url,
          owner: pair.owner,
          repo: pair.repo,
          path: pathInRepo || '',
          ref: 'HEAD'
        });
        const items = contentRes && contentRes.items ? contentRes.items : contentRes;
        if (!Array.isArray(items)) return;
        for (const item of items) {
          if (item.type === 'dir') {
            await gather(item.path);
          } else if (item.type === 'file') {
            files.push(item.path);
          }
        }
      }

      await gather('');
      totalFiles += files.length;

      for (let f = 0; f < files.length; f++) {
        const remoteFile = files[f];
        const content = await getGiteaFileContent({
          token,
          url,
          owner: pair.owner,
          repo: pair.repo,
          path: remoteFile,
          ref: 'HEAD'
        });
        const localPath = ppath.join(targetRepoDir, remoteFile);
        fs.mkdirSync(ppath.dirname(localPath), { recursive: true });
        fs.writeFileSync(localPath, content, 'utf8');

        exportedFiles++;
        try {
          event.sender.send('folder-download-progress', {
            processed: exportedFiles,
            total: Math.max(totalFiles, exportedFiles),
            percent: Math.round((exportedFiles / Math.max(totalFiles, exportedFiles)) * 100)
          });
        } catch (_) {}
      }

      const stamp = formatStamp();
      const backupFilename = `${pair.repo}-backup-${stamp}-${pair.owner}.zip`;
      const backupPath = ppath.join(destination, backupFilename);

      await createZipFromDirectory(targetRepoDir, backupPath);
      const zipStat = fs.statSync(backupPath);
      fs.rmSync(tempRoot, { recursive: true, force: true });

      exportedRepos.push({
        owner: pair.owner,
        repo: pair.repo,
        filename: backupFilename,
        path: backupPath,
        size: zipStat.size,
        files: files.length
      });
      try {
        event.sender.send('folder-download-progress', {
          processed: i + 1,
          total: totalRepos,
          percent: Math.round(((i + 1) / Math.max(1, totalRepos)) * 100)
        });
      } catch (_) {}
    }

    return {
      ok: true,
      destination,
      repositories: exportedRepos,
      repositoryCount: exportedRepos.length,
      fileCount: exportedFiles
    };
  } catch (e) {
    console.error('export-gitea-projects-to-local error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('getBranches', async (event, data) => {
  try {
    const branches = await getBranches(data.folder);
    // Aktuellen Branch ermitteln und nach oben sortieren
    let currentBranch = null;
    try {
      currentBranch = execSync('git branch --show-current', { cwd: data.folder, stdio: 'pipe', encoding: 'utf-8' }).trim();
    } catch (_) {}
    branches.sort((a, b) => {
      if (a === currentBranch) return -1;
      if (b === currentBranch) return 1;
      if (a === 'main') return -1;
      if (b === 'main') return 1;
      if (a === 'master') return -1;
      if (b === 'master') return 1;
      return 0;
    });
    return { ok: true, branches };
  } catch (e) {
    console.error('getBranches error', e);
    return { ok: false, error: String(e), branches: [] };
  }
});

ipcMain.handle('getCommitLogs', async (event, data) => {
  try {
    const logs = await getCommitLogs(data.folder, data.count || 50);
    return { ok: true, logs };
  } catch (e) {
    console.error('getCommitLogs error', e);
    return { ok: false, error: String(e), logs: [] };
  }
});

/* ----------------------------------------------------------------
   Neue/kompatible Handler: 'get-commits' (Renderer verwendet ggf. diesen)
   - Unterstützt:
     1) Lokale Git-Logs via data.folder -> getCommitLogs
     2) Gitea Commits via owner+repo -> getGiteaCommits
   ---------------------------------------------------------------- */
ipcMain.handle('get-commits', async (event, data) => {
  try {
    // 1) Lokale Git-Logs (folder vorhanden)
    if (data && data.folder) {
      const logs = await getCommitLogs(data.folder, data.count || 50);
      return { ok: true, logs };
    }

    // 2) Gitea-Commits (owner/repo vorhanden)
    if (data && data.owner && data.repo) {
      const credentials = readCredentials();
      const token = (data && data.token) || (credentials && credentials.giteaToken);
      const url = (data && data.url) || (credentials && credentials.giteaURL);
      if (!token || !url) return { ok: false, error: 'missing-token-or-url' };

      // map optional params
      const page = data.page || 1;
      const limit = data.limit || 50;
      const sha = data.sha; // optional branch/sha filter

      const commits = await getGiteaCommits({
        token,
        url,
        owner: data.owner,
        repo: data.repo,
        page,
        limit,
        sha
      });

      return { ok: true, commits };
    }

    return { ok: false, error: 'invalid-parameters-for-get-commits' };
  } catch (e) {
    console.error('get-commits error', e);
    return { ok: false, error: String(e) };
  }
});

/* -----------------------------
   Local file tree functions
   ----------------------------- */
function buildTree(dirPath, options = {}) {
  const { exclude = ['node_modules'], maxDepth = 10 } = options;
  function walk(currentPath, depth) {
    let stat;
    try { stat = fs.statSync(currentPath); } catch (e) { return null; }
    const name = ppath.basename(currentPath);
    const node = { name, path: currentPath, isDirectory: stat.isDirectory(), children: [], depth };
    if (node.isDirectory) {
      if (exclude.some(ex => currentPath.split(ppath.sep).includes(ex))) return null;
      if (depth >= maxDepth) return node;
      let items = [];
      try { items = fs.readdirSync(currentPath); } catch (e) { return node; }
      items.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
      for (const it of items) {
        const childPath = ppath.join(currentPath, it);
        const child = walk(childPath, depth +1);
        if (child) node.children.push(child);
      }
    }
    return node;
  }
  const roots = [];
  const list = fs.readdirSync(dirPath).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
  for (const entry of list) {
    const full = ppath.join(dirPath, entry);
    const n = walk(full, 0);
    if (n) roots.push(n);
  }
  return roots;
}

ipcMain.handle('getFileTree', async (event, data) => {
  try {
    const folder = data && data.folder;
    if (!folder || !fs.existsSync(folder)) return { ok: false, error: 'folder-not-found' };
    const opts = { exclude: (data && data.exclude) || ['node_modules'], maxDepth: (data && data.maxDepth) || 10 };
    const tree = buildTree(folder, opts);
    return { ok: true, tree };
  } catch (e) {
    console.error('getFileTree error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('readFile', async (event, data) => {
  try {
    if (!data || !data.path || !fs.existsSync(data.path)) return { ok: false, error: 'file-not-found' };
    const content = fs.readFileSync(data.path, 'utf8');
    return { ok: true, content };
  } catch (e) {
    console.error('readFile error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('writeFile', async (event, data) => {
  try {
    if (!data || !data.path) return { ok: false, error: 'invalid-path' };
    const dir = ppath.dirname(data.path);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }
    fs.writeFileSync(data.path, data.content || '', 'utf8');
    return { ok: true };
  } catch (e) {
    console.error('writeFile error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('deleteFile', async (event, data) => {
  try {
    // --- GITEA DELETION ---
    if (data && data.isGitea) {
      const credentials = readCredentials();
      const token = (data.token) || (credentials && credentials.giteaToken);
      const giteaUrl = (data.url) || (credentials && credentials.giteaURL);
      if (!token || !giteaUrl) return { ok: false, error: 'missing-token-or-url' };

      const owner = data.owner;
      const repo = data.repo;
      const filePath = data.path;
      if (!owner || !repo || !filePath) return { ok: false, error: 'missing-owner-repo-or-path' };

      const urlObj = new URL(giteaUrl);
      const protocol = urlObj.protocol === 'https:' ? https : http;
      const port = urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80);

      // Helper: GET contents from Gitea API
      function giteaGet(path) {
        return new Promise((resolve, reject) => {
          const req = protocol.request({
            hostname: urlObj.hostname, port,
            path: `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${path.split('/').map(encodeURIComponent).join('/')}?ref=${data.ref || 'HEAD'}`,
            method: 'GET',
            headers: { 'Authorization': `token ${token}`, 'Content-Type': 'application/json' }
          }, (res) => {
            let body = '';
            res.on('data', chunk => body += chunk);
            res.on('end', () => {
              try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
            });
          });
          req.on('error', reject);
          req.end();
        });
      }

      // Helper: DELETE a single file by path + sha
      function giteaDeleteFile(filePath, sha) {
        return new Promise((resolve) => {
          const body = JSON.stringify({
            message: `Delete ${filePath} via Git Manager GUI`,
            sha,
            branch: data.ref || 'HEAD'
          });
          const req = protocol.request({
            hostname: urlObj.hostname, port,
            path: `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${filePath.split('/').map(encodeURIComponent).join('/')}`,
            method: 'DELETE',
            headers: {
              'Authorization': `token ${token}`,
              'Content-Type': 'application/json',
              'Content-Length': Buffer.byteLength(body)
            }
          }, (res) => {
            let respBody = '';
            res.on('data', chunk => respBody += chunk);
            res.on('end', () => {
              if (res.statusCode >= 200 && res.statusCode < 300) resolve({ ok: true });
              else resolve({ ok: false, error: `HTTP ${res.statusCode}: ${respBody}` });
            });
          });
          req.on('error', (e) => resolve({ ok: false, error: String(e) }));
          req.write(body);
          req.end();
        });
      }

      // Helper: Recursively collect all files in a folder
      async function collectAllFiles(path) {
        const contents = await giteaGet(path);
        const files = [];
        if (Array.isArray(contents)) {
          // It's a folder — recurse into it
          for (const item of contents) {
            if (item.type === 'dir') {
              const sub = await collectAllFiles(item.path);
              files.push(...sub);
            } else if (item.type === 'file') {
              files.push({ path: item.path, sha: item.sha });
            }
          }
        } else if (contents && contents.sha) {
          // It's a single file
          files.push({ path: contents.path, sha: contents.sha });
        } else {
          throw new Error(`Unbekannte Antwort: ${JSON.stringify(contents)}`);
        }
        return files;
      }

      // Collect all files to delete (handles both file and folder)
      const filesToDelete = await collectAllFiles(filePath);

      if (filesToDelete.length === 0) {
        return { ok: false, error: 'Keine Dateien zum Löschen gefunden' };
      }

      // Delete all files sequentially
      let failed = 0;
      for (const f of filesToDelete) {
        const res = await giteaDeleteFile(f.path, f.sha);
        if (!res.ok) {
          console.error(`Fehler beim Löschen von ${f.path}:`, res.error);
          failed++;
        }
      }

      if (failed > 0) {
        return { ok: false, error: `${failed} von ${filesToDelete.length} Dateien konnten nicht gelöscht werden` };
      }

      return { ok: true, deleted: filesToDelete.length };
    }

    // --- LOCAL DELETION ---
    if (!data || !data.path || !fs.existsSync(data.path)) return { ok: false, error: 'file-not-found' };
    fs.rmSync(data.path, { recursive: true, force: true });
    return { ok: true };
  } catch (e) {
    console.error('deleteFile error', e);
    return { ok: false, error: String(e) };
  }
});

/* -----------------------------
   Gitea: list repos, contents, file content
   ----------------------------- */
ipcMain.handle('list-gitea-repos', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const repos = await listGiteaRepos({ token, url });
    return { ok: true, repos };
  } catch (e) {
    console.error('list-gitea-repos error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('get-gitea-user-heatmap', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };

    const result = await getGiteaUserHeatmap({ token, url });
    return { ok: true, ...result };
  } catch (e) {
    console.error('get-gitea-user-heatmap error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('get-gitea-repo-contents', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const p = data.path || '';
    
    // FIXED: Pass data.ref directly to apiHandler without forcing 'main'
    // This allows apiHandler.js to try ['main', 'master'] if no ref is passed
    const ref = data.ref; 
    
    const result = await getGiteaRepoContents({ token, url, owner, repo, path: p, ref });
    return { ok: true, items: result.items || result, empty: result.empty || false };
  } catch (e) {
    console.error('get-gitea-repo-contents error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('get-gitea-file-content', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const p = data.path;
    
    // FIXED: Pass data.ref directly
    const ref = data.ref;
    
    const content = await getGiteaFileContent({ token, url, owner, repo, path: p, ref });
    return { ok: true, content };
  } catch (e) {
    console.error('get-gitea-file-content error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

// Alias für Editor: read-gitea-file (für Text und Bilder)
ipcMain.handle('read-gitea-file', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) {
      console.error('Missing token or URL');
      return { ok: false, error: 'missing-token-or-url' };
    }
    
    const owner = data.owner;
    const repo = data.repo;
    const p = data.path;
    const ref = data.ref || 'HEAD';
    
    console.log(`read-gitea-file: ${owner}/${repo}/${p} (ref: ${ref})`);
    
    // Prüfe ob es eine Bilddatei ist
    const isImage = /\.(png|jpg|jpeg|gif|webp|svg)$/i.test(p);
    
    if (isImage) {
      // Für Bilder: Lade als Base64
      console.log('Loading as image (Base64)');
      const apiUrl = `${url}/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/raw/${encodeURIComponent(p)}?ref=${ref}`;
      console.log('Image URL:', apiUrl);
      
      return new Promise((resolve) => {
        try {
          const protocol = url.startsWith('https') ? https : http;
          protocol.get(apiUrl, { 
            headers: { 
              'Authorization': `token ${token}`,
              'User-Agent': 'Git-Manager-GUI'
            } 
          }, (res) => {
            console.log(`Image response status: ${res.statusCode}`);
            if (res.statusCode !== 200) {
              resolve({ ok: false, error: `HTTP ${res.statusCode}` });
              return;
            }
            
            const chunks = [];
            res.on('data', chunk => chunks.push(chunk));
            res.on('end', () => {
              try {
                const buffer = Buffer.concat(chunks);
                const base64 = buffer.toString('base64');
                console.log(`Image loaded: ${base64.length} bytes`);
                resolve({ ok: true, content: base64 });
              } catch (e) {
                console.error('Base64 conversion error:', e.message);
                resolve({ ok: false, error: String(e) });
              }
            });
          }).on('error', (e) => {
            console.error('Image HTTP error:', e.message);
            resolve({ ok: false, error: String(e) });
          });
        } catch (e) {
          console.error('Image load try error:', e.message);
          resolve({ ok: false, error: String(e) });
        }
      });
    } else {
      // Für Text: Nutze normale Funktion
      console.log('Loading as text file');
      const content = await getGiteaFileContent({ token, url, owner, repo, path: p, ref });
      console.log(`Text file loaded: ${content.length} chars`);
      return { ok: true, content };
    }
  } catch (e) {
    console.error('read-gitea-file error:', e.message, e.stack);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('upload-gitea-file', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    // destPath is the target folder in the repo
    const destPath = (data.destPath || '').replace(/^\//, '').replace(/\/$/, '');
    // Branch wird unverändert übernommen (main UND master werden unterstützt)
    let branch = data.branch || 'HEAD';
    const message = data.message || 'Upload via Git Manager GUI';
    const localFiles = Array.isArray(data.localPath) ? data.localPath : (data.localPath ? [data.localPath] : []);
    const results = [];
    for (const localFile of localFiles) {
      if (!fs.existsSync(localFile)) {
        results.push({ file: localFile, ok: false, error: 'local-file-not-found' });
        continue;
      }
      const raw = fs.readFileSync(localFile);
      const base64 = raw.toString('base64');
      const fileName = ppath.basename(localFile);
      
      // FIXED: Handle destPath correctly. Always combine destPath + filename.
      let targetPath;
      if (destPath && destPath.length > 0) {
        targetPath = `${destPath}/${fileName}`;
      } else {
        targetPath = fileName;
      }

      try {
        const uploaded = await uploadGiteaFile({
          token,
          url,
          owner,
          repo,
          path: targetPath,
          contentBase64: base64,
          message: `${message} - ${fileName}`,
          branch
        });
        results.push({ file: localFile, ok: true, uploaded });
      } catch (e) {
        console.error('upload error for', localFile, e);
        results.push({ file: localFile, ok: false, error: String(e) });
      }
    }
    return { ok: true, results };
  } catch (e) {
    console.error('upload-gitea-file error', e);
    return { ok: false, error: String(e) };
  }
});

// Alias für Editor: write-gitea-file
ipcMain.handle('write-gitea-file', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    
    const owner = data.owner;
    const repo = data.repo;
    const path = data.path;
    const content = data.content || '';
    const ref = data.ref || 'HEAD';
    
    // Konvertiere Content zu Base64
    const base64 = Buffer.from(content, 'utf8').toString('base64');
    
    const uploaded = await uploadGiteaFile({
      token,
      url,
      owner,
      repo,
      path,
      contentBase64: base64,
      message: `Edit ${path} via Git Manager GUI`,
      branch: ref
    });
    
    return { ok: true, uploaded };
  } catch (e) {
    console.error('write-gitea-file error', e);
    if (isRetryableNetworkError(e)) {
      const queued = enqueueRetryWriteTask(data || {}, e && e.message ? e.message : String(e));
      return {
        ok: true,
        queued: true,
        queueId: queued.id,
        message: 'Netzwerkproblem erkannt. Änderung wurde in die Retry-Queue gelegt.'
      };
    }
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('get-retry-queue', async () => {
  try {
    return { ok: true, size: retryQueue.length, items: retryQueue.slice(0, 100) };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('process-retry-queue-now', async () => {
  try {
    return await processRetryQueueOnce();
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('remove-retry-queue-item', async (event, data) => {
  try {
    const id = data && data.id;
    if (!id) return { ok: false, error: 'missing-id' };
    const before = retryQueue.length;
    retryQueue = retryQueue.filter(item => item.id !== id);
    if (retryQueue.length !== before) {
      saveRetryQueueToDisk();
      broadcastRetryQueueUpdate({ event: 'removed', id });
    }
    return { ok: true, size: retryQueue.length };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('upload-local-folder-to-gitea', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const localFolder = data.localFolder;
    const owner = data.owner;
    const repo = data.repo;
    // destPath is the target directory in the repo
    const destPath = (data.destPath || '').replace(/^\//, '').replace(/\/$/, '');
    // Branch wird unverändert übernommen (main UND master werden unterstützt)
    let branch = data.branch || 'HEAD';
    const messagePrefix = data.messagePrefix || 'Upload folder via GUI';
    const concurrency = data.concurrency || DEFAULT_CONCURRENCY;
    if (!localFolder || !fs.existsSync(localFolder)) return { ok: false, error: 'local-folder-not-found' };

    const items = [];
    const folderName = ppath.basename(localFolder);

    // FIXED EXCLUDE LIST: Filter out .git, node_modules etc.
    const excludeList = ['.git', 'node_modules', '.DS_Store', 'thumbs.db', '.vscode', '.idea'];

    (function walk(dir) {
      const entries = fs.readdirSync(dir);
      for (const entry of entries) {
        if (excludeList.includes(entry)) continue; // Skip excluded folders/files

        const full = ppath.join(dir, entry);
        let stat;
        try {
            stat = fs.statSync(full);
        } catch(e) { continue; } // Skip unreadable files

        if (stat.isDirectory()) {
          walk(full);
        } else if (stat.isFile()) {
          const rel = ppath.relative(localFolder, full).split(ppath.sep).join('/');
          // FIXED: Respect folder structure. Result: destPath/folderName/rel
          let targetPath;
          if (destPath && destPath.length > 0) {
            targetPath = `${destPath}/${folderName}/${rel}`;
          } else {
            targetPath = `${folderName}/${rel}`;
          }
          items.push({ localFile: full, targetPath });
        }
      }
    })(localFolder);

    const total = items.length;
    if (total === 0) return { ok: true, results: [] };

    const tasks = items.map(it => async () => {
      const raw = fs.readFileSync(it.localFile);
      const base64 = raw.toString('base64');
      return uploadGiteaFile({
        token,
        url,
        owner,
        repo,
        path: it.targetPath,
        contentBase64: base64,
        message: `${messagePrefix} - ${ppath.basename(it.localFile)}`,
        branch
      });
    });

    const onProgress = (processed, t) => {
      try { event.sender.send('folder-upload-progress', { processed, total: t, percent: Math.round((processed / t) * 100) }); } catch (_) {}
    };

    const results = await runLimited(tasks, concurrency, (proc, t) => onProgress(proc, total));
    return { ok: true, results };
  } catch (e) {
    console.error('upload-local-folder-to-gitea error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('download-gitea-file', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const filePath = data.path;
    if (!owner || !repo || !filePath) return { ok: false, error: 'missing-owner-repo-or-path' };
    const content = await getGiteaFileContent({ token, url, owner, repo, path: filePath, ref: data.ref || 'HEAD' });
    const save = await dialog.showSaveDialog({ defaultPath: ppath.basename(filePath) });
    if (save.canceled || !save.filePath) return { ok: false, error: 'save-canceled' };
    fs.writeFileSync(save.filePath, content, 'utf8');
    return { ok: true, savedTo: save.filePath };
  } catch (e) {
    console.error('download-gitea-file error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('download-gitea-folder', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const remotePath = (data.path || '').replace(/^\/+/, '').replace(/\/+$/, '');
    const concurrency = data.concurrency || DEFAULT_CONCURRENCY;

    const result = await dialog.showOpenDialog({ properties: ['openDirectory', 'createDirectory'] });
    if (result.canceled || !result.filePaths || result.filePaths.length === 0) return { ok: false, error: 'save-canceled' };
    const destBase = result.filePaths[0];

    const allFiles = [];
    async function gather(pathInRepo) {
      const _r = await getGiteaRepoContents({ token, url, owner, repo, path: pathInRepo, ref: data.ref || 'HEAD' });
      const items = _r.items || _r;
      for (const item of items) {
        if (item.type === 'dir') await gather(item.path);
        else if (item.type === 'file') allFiles.push(item.path);
      }
    }
    await gather(remotePath || '');

    const total = allFiles.length;
    if (total === 0) return { ok: true, savedTo: destBase, files: [] };

    const tasks = allFiles.map(remoteFile => async () => {
      const content = await getGiteaFileContent({ token, url, owner, repo, path: remoteFile, ref: data.ref || 'HEAD' });
      const localPath = ppath.join(destBase, remoteFile);
      fs.mkdirSync(ppath.dirname(localPath), { recursive: true });
      fs.writeFileSync(localPath, content, 'utf8');
      return localPath;
    });

    const onProgress = (processed, t) => {
      try { event.sender.send('folder-download-progress', { processed, total: t, percent: Math.round((processed / t) * 100) }); } catch (_) {}
    };

    const results = await runLimited(tasks, concurrency, (proc, t) => onProgress(proc, total));
    const savedFiles = results.filter(r => r.ok).map(r => r.result);
    return { ok: true, savedTo: destBase, files: savedFiles };
  } catch (e) {
    console.error('download-gitea-folder error', e);
    return { ok: false, error: String(e) };
  }
});

/* -----------------------------
   prepare-download-drag (robust)
   - stellt sicher, dass alle Dateien komplett geschrieben sind
   - erkennt Base64 vs UTF-8 und schreibt als Buffer wenn nötig
   - nutzt getSafeTmpDir() (siehe oben in deiner main.js)
   ----------------------------- */
function isBase64Like(str) {
  if (typeof str !== 'string') return false;
  // Strip whitespace/newlines
  const s = str.replace(/\s+/g, '');
  if (s.length === 0) return false;
  // Base64 valid chars + padding
  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(s)) return false;
  // length must be multiple of 4 (except maybe line breaks removed)
  if (s.length % 4 !== 0) return false;
  try {
    // Round-trip check (cheap and practical)
    const decoded = Buffer.from(s, 'base64');
    return decoded.toString('base64') === s;
  } catch (e) {
    return false;
  }
}

ipcMain.handle('prepare-download-drag', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !url) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const remotePath = (data.path || '').replace(/^\/+/, '').replace(/\/+$/, '');

    // Create a unique temp directory (guarantees clean state)
    const tmpBase = getSafeTmpDir(repo || 'gitea-repo');

    // Gather list of files (recursive)
    const allFiles = [];
    async function gather(pathInRepo) {
      const _r2 = await getGiteaRepoContents({ token, url, owner, repo, path: pathInRepo, ref: data.ref || 'HEAD' });
      const items = (_r2.items || _r2) || [];
      for (const item of items) {
        if (item.type === 'dir') await gather(item.path);
        else if (item.type === 'file') allFiles.push(item.path);
      }
    }
    await gather(remotePath || '');

    // If no files, return early (still provide empty dir)
    if (allFiles.length === 0) {
      // schedule cleanup
      setTimeout(() => { try { if (fs.existsSync(tmpBase)) fs.rmSync(tmpBase, { recursive: true, force: true }); } catch (_) {} }, TMP_CLEANUP_MS);
      return { ok: true, tempPath: tmpBase, files: [] };
    }

    // Download files sequentially or with limited concurrency:
    const tasks = allFiles.map(remoteFile => async () => {
      const content = await getGiteaFileContent({ token, url, owner, repo, path: remoteFile, ref: data.ref || 'HEAD' });
      const localPath = ppath.join(tmpBase, remoteFile);
      ensureDir(ppath.dirname(localPath));

      // Decide how to write: if Buffer already, write directly. If string, try base64 detection
      if (Buffer.isBuffer(content)) {
        fs.writeFileSync(localPath, content);
      } else if (typeof content === 'string') {
        if (isBase64Like(content)) {
          const buf = Buffer.from(content, 'base64');
          fs.writeFileSync(localPath, buf);
        } else {
          // treat as utf8 text
          fs.writeFileSync(localPath, content, 'utf8');
        }
      } else {
        // fallback: convert to string
        fs.writeFileSync(localPath, String(content), 'utf8');
      }
      return localPath;
    });

    // runLimited ensures concurrency and waits for all writes to finish
    const results = await runLimited(tasks, data.concurrency || DEFAULT_CONCURRENCY);

    // verify at least one successful file
    const successFiles = results.filter(r => r.ok).map(r => r.result);
    if (successFiles.length === 0) {
      // cleanup on complete failure
      try { if (fs.existsSync(tmpBase)) fs.rmSync(tmpBase, { recursive: true, force: true }); } catch (_) {}
      return { ok: false, error: 'no-files-downloaded' };
    }

    // give renderer the temp dir (renderer should then call 'ondragstart' with the folder path)
    // schedule cleanup after delay to keep files available for drag & drop
    setTimeout(() => { try { if (fs.existsSync(tmpBase)) fs.rmSync(tmpBase, { recursive: true, force: true }); } catch (_) {} }, TMP_CLEANUP_MS);

    return { ok: true, tempPath: tmpBase, files: successFiles };
  } catch (e) {
    console.error('prepare-download-drag error', e);
    return { ok: false, error: String(e) };
  }
});

/* -----------------------------
   ondragstart (no change to API but more defensive)
   - expects renderer to call window.electronAPI.ondragStart(tempPath)
   ----------------------------- */
ipcMain.on('ondragstart', async (event, filePath) => {
  try {
    if (!filePath || !fs.existsSync(filePath)) {
      console.warn('ondragstart: path missing or not exists:', filePath);
      return;
    }
    // Prefer folder icon when dragging a directory
    let icon = nativeImage.createEmpty();
    try {
      // ask platform for file icon; large size for clearer drag icon
      icon = await app.getFileIcon(filePath, { size: 'large' });
    } catch (e) {
      // ignore, keep empty icon
    }

    // startDrag accepts { file } where file can be a directory
    try {
      event.sender.startDrag({ file: filePath, icon });
    } catch (e) {
      // some platforms may require a single file — if folder fails, try to drop a placeholder file
      console.error('startDrag failed for', filePath, e);
    }
  } catch (e) {
    console.error('ondragstart error', e);
  }
});


ipcMain.handle('delete-gitea-repo', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const urlStr = (data && data.url) || (credentials && credentials.giteaURL);
    if (!token || !urlStr) return { ok: false, error: 'missing-token-or-url' };
    const owner = data.owner;
    const repo = data.repo;
    const urlObj = new URL(urlStr);
    const protocol = urlObj.protocol === 'https:' ? https : http;
    const deletePath = `/api/v1/repos/${owner}/${repo}`;

    return new Promise((resolve) => {
      const options = {
        hostname: urlObj.hostname,
        port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
        path: deletePath,
        method: 'DELETE',
        headers: { 'Authorization': `token ${token}`, 'Content-Type': 'application/json' }
      };
      const req = protocol.request(options, (res) => {
        let body = '';
        res.on('data', chunk => body += chunk);
        res.on('end', () => {
          if (res.statusCode >= 200 && res.statusCode < 300) resolve({ ok: true });
          else resolve({ ok: false, error: `HTTP ${res.statusCode}: ${body}` });
        });
      });
      req.on('error', (e) => resolve({ ok: false, error: String(e) }));
      req.end();
    });
  } catch (e) {
    console.error('delete-gitea-repo error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('upload-and-push', async (event, data) => {
  try {
    if (!data || !data.localFolder || !fs.existsSync(data.localFolder)) return { ok: false, error: 'local-folder-not-found' };
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const giteaUrl = (data && data.url) || (credentials && credentials.giteaURL);
    const owner = data.owner;
    const repo = data.repo;
    // Branch wird unverändert übernommen (main UND master werden unterstützt)
    let branch = data.branch || 'HEAD';
    const cloneUrl = data.cloneUrl || null;
    const destPath = (data.destPath || '').replace(/^\//, '').replace(/\/$/, '');
    if (!owner || !repo) return { ok: false, error: 'missing-owner-or-repo' };

    const gitExecOptions = {
      stdio: 'pipe',
      encoding: 'utf8',
      env: {
        ...process.env,
        GIT_TERMINAL_PROMPT: '0',
        GIT_PAGER: 'cat',
        PAGER: 'cat'
      },
      maxBuffer: 10 * 1024 * 1024
    };

    // Auto-Backup vor Upload (wenn in Einstellungen aktiviert)
    const autoBackupEnabled = Boolean(credentials && credentials.autoBackupEnabled);
    const uploadSessionId = String(data.uploadSessionId || '').trim();
    const shouldSkipBySession = Boolean(uploadSessionId && backupDoneSessions.has(uploadSessionId));
    if (autoBackupEnabled && !data.skipBackup && !shouldSkipBySession) {
      const backupTarget = String((credentials && credentials.backupPrefLocalFolder) || '').trim();
      const emitStatus = (payload) => {
        try { event.sender.send('pre-push-backup-status', payload); } catch (_) {}
      };
      if (!backupTarget) {
        return { ok: false, error: 'Auto-Backup ist aktiv, aber kein lokaler Backup-Zielordner ist gesetzt.' };
      }
      // Nur den Repo-Namen ohne Owner verwenden (verhindert "/" im Dateinamen)
      const backupRepoName = String(repo || ppath.basename(data.localFolder)).replace(/[<>:"/\\|?*]+/g, '-');
      // Wenn localFolder eine Datei ist, den Elternordner sichern
      const statForBackup = fs.statSync(data.localFolder);
      const backupProjectPath = statForBackup.isFile() ? ppath.dirname(data.localFolder) : data.localFolder;
      try {
        emitStatus({ stage: 'backup-start', repoName: backupRepoName, target: backupTarget });
        await ensureLocalBackupConfigured(backupRepoName, backupTarget);
        const backupResult = await ipcMain._handle_create_cloud_backup(event, {
          repoName: backupRepoName,
          projectPath: backupProjectPath
        });
        if (!backupResult?.ok) {
          emitStatus({ stage: 'backup-failed', repoName: backupRepoName, error: backupResult?.error || 'Unbekannter Fehler' });
          return { ok: false, error: `Auto-Backup vor Upload fehlgeschlagen: ${backupResult?.error || 'Unbekannter Fehler'}` };
        }
        if (uploadSessionId) {
          backupDoneSessions.set(uploadSessionId, Date.now());
          setTimeout(() => backupDoneSessions.delete(uploadSessionId), 10 * 60 * 1000);
        }
        emitStatus({ stage: 'backup-done', repoName: backupRepoName, filename: backupResult.filename || '' });
        emitStatus({ stage: 'upload-start' });
      } catch (backupErr) {
        emitStatus({ stage: 'backup-failed', repoName: backupRepoName, error: mapIpcError(backupErr) });
        return { ok: false, error: `Auto-Backup vor Upload fehlgeschlagen: ${mapIpcError(backupErr)}` };
      }
    }

    // Prüfen ob es eine Datei oder ein Ordner ist
    const stat = fs.statSync(data.localFolder);
    const isFile = stat.isFile();
    const isDirectory = stat.isDirectory();

    // --- FALL 1: Einzelne Datei ---
    if (isFile) {
      console.log('Detected single file. Attempting API upload...');
      const raw = fs.readFileSync(data.localFolder);
      const base64 = raw.toString('base64');
      const fileName = ppath.basename(data.localFolder);
      
      // Pfad-Logik für Ziel
      let targetPath;
      if (destPath && destPath.length > 0) {
        targetPath = `${destPath}/${fileName}`;
      } else {
        targetPath = fileName;
      }
      
      try {
        // VERSUCH 1: API Upload
        const result = await uploadGiteaFile({
          token,
          url: giteaUrl,
          owner,
          repo,
          path: targetPath,
          contentBase64: base64,
          message: `Upload ${fileName} via GUI`,
          branch
        });
        return { ok: true, usedGit: false, singleFile: true, uploaded: result };
      } catch (e) {
        console.error('Single file API upload error:', e.message);
        
        // FALLBACK: Wenn API fehlschlägt (z.B. 422 SHA Fehler), nutze Git
        // Git löst das "Überschreiben"-Problem zuverlässig.
        console.log('Falling back to Git for single file...');
        
        let finalCloneUrl = cloneUrl;
        if (!finalCloneUrl && giteaUrl) {
          try {
            const base = giteaUrl.replace(/\/$/, '');
            const urlObj = new URL(base);
            finalCloneUrl = `${urlObj.protocol}//${urlObj.host}/${owner}/${repo}.git`;
          } catch (err) { console.error('Invalid URL', err); }
        }
        
        if (!finalCloneUrl) return { ok: false, error: 'Cannot fallback to Git: No Clone URL' };

        // Git-Workflow für einzelne Datei simulieren:
        // 1. Temp Ordner erstellen
        // 2. Repo klonen
        // 3. Datei in Ordner kopieren
        // 4. Commit & Push
        
        let authClone = finalCloneUrl;
        try {
          const urlObj = new URL(finalCloneUrl);
          if (token && (urlObj.protocol.startsWith('http'))) {
            urlObj.username = encodeURIComponent(token);
            authClone = urlObj.toString();
          }
        } catch (err) {}

        const tmpDir = getSafeTmpDir(`git-push-file-${owner}-${repo}`);
        try {
          execSync(`git clone --depth 1 --branch ${branch} "${authClone}" "${tmpDir}"`, gitExecOptions);
          
          // Zielort im Repo bestimmen
          let destDirInRepo = tmpDir;
          if (destPath) {
            destDirInRepo = ppath.join(tmpDir, destPath.split('/').join(ppath.sep));
            ensureDir(destDirInRepo);
          }
          
          const finalFileDest = ppath.join(destDirInRepo, fileName);
          
          // Datei kopieren
          fs.copyFileSync(data.localFolder, finalFileDest);

          // Git Befehle
          execSync(`git -C "${tmpDir}" add .`, gitExecOptions);
          try { execSync(`git -C "${tmpDir}" commit -m "Upload file ${fileName} via GUI"`, gitExecOptions); } catch (_) {}
          execSync(`git -C "${tmpDir}" push origin ${branch}`, gitExecOptions);

          setTimeout(() => { try { if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {} }, 5_000);
          return { ok: true, usedGit: true, singleFile: true, msg: 'Uploaded via Git (Fallback)' };
        } catch (gitErr) {
          console.error('Git Fallback failed:', gitErr);
          if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
          return { ok: false, error: `API failed: ${e.message}. Git fallback failed: ${String(gitErr)}` };
        }
      }
    }

    // --- FALL 2: Ordner (Normale Git-Logik) ---
    if (!isDirectory) {
      return { ok: false, error: 'Path is neither file nor directory' };
    }

    let gitAvailable = true;
    try { execSync('git --version', { stdio: 'ignore', env: gitExecOptions.env }); } catch (e) { gitAvailable = false; }

    let finalCloneUrl = cloneUrl;
    if (!finalCloneUrl && giteaUrl) {
      try {
        const base = giteaUrl.replace(/\/$/, '');
        const urlObj = new URL(base);
        finalCloneUrl = `${urlObj.protocol}//${urlObj.host}/${owner}/${repo}.git`;
      } catch (e) {}
    }

    if (gitAvailable && finalCloneUrl) {
      let authClone = finalCloneUrl;
      try {
        const urlObj = new URL(finalCloneUrl);
        if (token && (urlObj.protocol.startsWith('http'))) {
          urlObj.username = encodeURIComponent(token);
          authClone = urlObj.toString();
        }
      } catch (e) {}

      const tmpDir = getSafeTmpDir(`gitea-push-${owner}-${repo}`);

      try {
        execSync(`git clone --depth 1 --branch ${branch} "${authClone}" "${tmpDir}"`, gitExecOptions);

        // FIXED: Respektieren von destPath und Ordnernamen im Git-Workflow
        const folderName = ppath.basename(data.localFolder);
        let targetBaseDir = tmpDir;
        
        if (destPath) {
          // Wenn ein Zielpfad angegeben ist (z.B. 'src'), erstelle diesen Ordner im Repo
          const osDestPath = destPath.split('/').join(ppath.sep);
          targetBaseDir = ppath.join(tmpDir, osDestPath);
          ensureDir(targetBaseDir);
        }

        // Ziel ist immer: targetBaseDir/folderName
        const finalDest = ppath.join(targetBaseDir, folderName);

        // FIXED: Korrekter Umgang mit fs.cpSync
        // Wenn finalDest bereits existiert, muss es entfernt werden, damit cpSync funktioniert
        if (fs.existsSync(finalDest)) {
            fs.rmSync(finalDest, { recursive: true, force: true });
        }
        
        // Kopieren
        if (fs.cpSync) {
          fs.cpSync(data.localFolder, finalDest, { recursive: true, force: true });
        } else {
          if (process.platform === 'win32') {
            execSync(`robocopy "${data.localFolder}" "${finalDest}" /E /NFL /NDL /NJH /NJS /nc /ns`, { ...gitExecOptions, shell: true });
          } else {
            execSync(`cp -r "${data.localFolder}/." "${finalDest}"`, { ...gitExecOptions, shell: true });
          }
        }

        try {
          execSync(`git -C "${tmpDir}" add .`, gitExecOptions);
          try { execSync(`git -C "${tmpDir}" commit -m "Update from Git Manager GUI"`, gitExecOptions); } catch (_) {}
          execSync(`git -C "${tmpDir}" push origin ${branch}`, gitExecOptions);
        } catch (e) { throw e; }

        setTimeout(() => { try { if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {} }, 5_000);
        return { ok: true, usedGit: true, msg: 'Uploaded via git push' };
      } catch (e) {
        console.error('upload-and-push git-flow error', e);
        try { if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
      }
    }

    // Fallback: API Upload (paralleler Upload)
    const items = [];
    const folderName = ppath.basename(data.localFolder);

    // FIXED EXCLUDE LIST: Filter out .git, node_modules etc.
    const excludeList = ['.git', 'node_modules', '.DS_Store', 'thumbs.db', '.vscode', '.idea'];

    (function walk(dir) {
      const entries = fs.readdirSync(dir);
      for (const entry of entries) {
        if (excludeList.includes(entry)) continue; // Skip excluded folders/files

        const full = ppath.join(dir, entry);
        let stat;
        try {
            stat = fs.statSync(full);
        } catch(e) { continue; }

        if (stat.isDirectory()) {
          walk(full);
        } else if (stat.isFile()) {
          const rel = ppath.relative(data.localFolder, full).split(ppath.sep).join('/');
          // FIXED: Pfad-Respektierung: destPath/folderName/rel
          let targetPath;
          if (destPath && destPath.length > 0) {
            targetPath = `${destPath}/${folderName}/${rel}`;
          } else {
            targetPath = `${folderName}/${rel}`;
          }
          items.push({ localFile: full, targetPath });
        }
      }
    })(data.localFolder);

    const total = items.length;
    const concurrency = data.concurrency || DEFAULT_CONCURRENCY;
    if (total === 0) return { ok: true, usedGit: false, results: [] };

    const tasks = items.map(it => async () => {
      const raw = fs.readFileSync(it.localFile);
      const base64 = raw.toString('base64');
      return uploadGiteaFile({
        token,
        url: giteaUrl,
        owner,
        repo,
        path: it.targetPath,
        contentBase64: base64,
        message: `Upload via GUI - ${ppath.basename(it.localFile)}`,
        branch
      });
    });

    const onProgress = (processed, t) => {
      try { event.sender.send('folder-upload-progress', { processed, total: t, percent: Math.round((processed / t) * 100) }); } catch (_) {}
    };

    const uploadResults = await runLimited(tasks, concurrency, (proc, t) => onProgress(proc, total));
    return { ok: true, usedGit: false, results: uploadResults };
  } catch (e) {
    console.error('upload-and-push error', e);
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('run-batch-repo-action', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials || !credentials.giteaToken || !credentials.giteaURL) {
      return { ok: false, error: 'missing-token-or-url' };
    }

    const action = (data && data.action) || 'refresh';
    const rawRepos = Array.isArray(data && data.repos) ? data.repos : [];
    const options = (data && data.options) || {};

    const repos = rawRepos
      .map(r => String(r || '').trim())
      .filter(Boolean)
      .map(v => {
        const [owner, repo] = v.split('/');
        return { owner, repo, id: `${owner}/${repo}` };
      })
      .filter(r => r.owner && r.repo);

    if (repos.length === 0) {
      return { ok: false, error: 'no-valid-repositories' };
    }

    const cloneBaseUrl = String(credentials.giteaURL || '').replace(/\/$/, '');
    const token = credentials.giteaToken;

    const sendProgress = (payload) => {
      try { event.sender.send('batch-action-progress', payload); } catch (_) {}
    };

    const results = [];
    for (let i = 0; i < repos.length; i++) {
      const item = repos[i];
      const progressBase = { index: i + 1, total: repos.length, repo: item.id, action };
      sendProgress({ ...progressBase, status: 'running' });

      try {
        if (action === 'refresh') {
          await getGiteaRepoContents({
            token,
            url: credentials.giteaURL,
            owner: item.owner,
            repo: item.repo,
            path: '',
            ref: 'HEAD'
          });
          results.push({ repo: item.id, ok: true, message: 'Repository aktualisiert' });
        } else if (action === 'clone') {
          const targetDir = options.cloneTargetDir;
          if (!targetDir) throw new Error('clone-target-missing');
          const repoDir = ppath.join(targetDir, item.repo);
          if (fs.existsSync(repoDir)) throw new Error(`target-exists: ${repoDir}`);

          const cloneUrl = `${cloneBaseUrl}/${item.owner}/${item.repo}.git`;
          let authCloneUrl = cloneUrl;
          try {
            const u = new URL(cloneUrl);
            if (u.protocol.startsWith('http')) {
              u.username = encodeURIComponent(token);
              authCloneUrl = u.toString();
            }
          } catch (_) {}

          execSync(`git clone --depth 1 \"${authCloneUrl}\" \"${repoDir}\"`, { stdio: 'ignore' });
          results.push({ repo: item.id, ok: true, message: `Geklont nach ${repoDir}` });
        } else if (action === 'create-tag') {
          const tag = String(options.tag || '').trim();
          if (!tag) throw new Error('tag-missing');
          await createGiteaRelease({
            token,
            url: credentials.giteaURL,
            owner: item.owner,
            repo: item.repo,
            data: {
              tag_name: tag,
              name: tag,
              body: options.body || '',
              draft: false,
              prerelease: !!options.prerelease,
              target_commitish: options.target_commitish || 'HEAD'
            }
          });
          results.push({ repo: item.id, ok: true, message: `Tag erstellt: ${tag}` });
        } else if (action === 'create-release') {
          const tag = String(options.tag || '').trim();
          if (!tag) throw new Error('tag-missing');
          const name = String(options.name || tag).trim();
          await createGiteaRelease({
            token,
            url: credentials.giteaURL,
            owner: item.owner,
            repo: item.repo,
            data: {
              tag_name: tag,
              name,
              body: options.body || '',
              draft: !!options.draft,
              prerelease: !!options.prerelease,
              target_commitish: options.target_commitish || 'HEAD'
            }
          });
          results.push({ repo: item.id, ok: true, message: `Release erstellt: ${name}` });
        } else {
          throw new Error(`unknown-action: ${action}`);
        }

        sendProgress({ ...progressBase, status: 'ok' });
      } catch (e) {
        const msg = mapIpcError(e);
        results.push({ repo: item.id, ok: false, error: msg });
        sendProgress({ ...progressBase, status: 'error', error: msg });
      }
    }

    const success = results.filter(r => r.ok).length;
    const failed = results.length - success;
    return {
      ok: true,
      action,
      summary: { total: results.length, success, failed },
      results
    };
  } catch (e) {
    console.error('run-batch-repo-action error', e);
    return { ok: false, error: String(e) };
  }
});
/* ================================
   RENAME / CREATE / MOVE HANDLERS
   ================================ */

// Gitea: Datei/Ordner umbenennen (= alle Dateien kopieren + alte löschen)
ipcMain.handle('rename-gitea-item', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = credentials?.giteaToken;
    const giteaUrl = credentials?.giteaURL;
    if (!token || !giteaUrl) return { ok: false, error: 'missing-token-or-url' };

    const { owner, repo, oldPath, newPath, isDir } = data;
    const urlObj = new URL(giteaUrl);
    const protocol = urlObj.protocol === 'https:' ? https : http;
    const port = urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80);

    function giteaRequest(method, apiPath, body) {
      return new Promise((resolve, reject) => {
        const bodyStr = body ? JSON.stringify(body) : null;
        const req = protocol.request({
          hostname: urlObj.hostname, port,
          path: apiPath, method,
          headers: {
            'Authorization': `token ${token}`,
            'Content-Type': 'application/json',
            ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {})
          }
        }, (res) => {
          let b = '';
          res.on('data', c => b += c);
          res.on('end', () => {
            try { resolve({ status: res.statusCode, body: JSON.parse(b) }); }
            catch (_) { resolve({ status: res.statusCode, body: b }); }
          });
        });
        req.on('error', reject);
        if (bodyStr) req.write(bodyStr);
        req.end();
      });
    }

    async function collectFiles(path) {
      const r = await giteaRequest('GET', `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${path.split('/').map(encodeURIComponent).join('/')}?ref=HEAD`, null);
      const files = [];
      if (Array.isArray(r.body)) {
        for (const item of r.body) {
          if (item.type === 'dir') files.push(...await collectFiles(item.path));
          else files.push({ path: item.path, sha: item.sha });
        }
      } else if (r.body?.sha) {
        files.push({ path: r.body.path, sha: r.body.sha });
      }
      return files;
    }

    async function readFileContent(filePath) {
      const r = await giteaRequest('GET', `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${filePath.split('/').map(encodeURIComponent).join('/')}?ref=HEAD`, null);
      return r.body?.content ? r.body.content.replace(/\n/g, '') : '';
    }

    async function uploadFile(targetPath, contentBase64, message) {
      // Check if exists first (need SHA for update)
      const check = await giteaRequest('GET', `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${targetPath.split('/').map(encodeURIComponent).join('/')}?ref=HEAD`, null);
      const body = { message, content: contentBase64, branch: 'HEAD' };
      if (check.body?.sha) body.sha = check.body.sha;
      return giteaRequest('POST', `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${targetPath.split('/').map(encodeURIComponent).join('/')}`, body);
    }

    async function deleteFile(filePath, sha) {
      return giteaRequest('DELETE', `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${filePath.split('/').map(encodeURIComponent).join('/')}`, {
        message: `Delete ${filePath} (rename)`, sha, branch: 'HEAD'
      });
    }

    // Collect all files under oldPath
    const files = await collectFiles(oldPath);

    // For each file: read content, upload to newPath, delete from oldPath
    for (const f of files) {
      const content = await readFileContent(f.path);
      const relPath = isDir ? f.path.slice(oldPath.length + 1) : '';
      const targetPath = isDir ? `${newPath}/${relPath}` : newPath;
      await uploadFile(targetPath, content, `Rename: move ${f.path} to ${targetPath}`);
      await deleteFile(f.path, f.sha);
    }

    return { ok: true };
  } catch (e) {
    console.error('rename-gitea-item error', e);
    return { ok: false, error: String(e) };
  }
});

// Gitea: Neue Datei oder Ordner (Ordner = Datei mit .gitkeep)
ipcMain.handle('create-gitea-item', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = credentials?.giteaToken;
    const giteaUrl = credentials?.giteaURL;
    if (!token || !giteaUrl) return { ok: false, error: 'missing-token-or-url' };

    const { owner, repo, path: itemPath, type } = data;
    const urlObj = new URL(giteaUrl);
    const protocol = urlObj.protocol === 'https:' ? https : http;
    const port = urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80);

    // Für Ordner: .gitkeep Datei anlegen
    const targetPath = type === 'folder' ? `${itemPath}/.gitkeep` : itemPath;
    const content = Buffer.from('').toString('base64');

    return new Promise((resolve) => {
      const body = JSON.stringify({ message: `Create ${itemPath}`, content, branch: data.branch || 'HEAD' });
      const req = protocol.request({
        hostname: urlObj.hostname, port,
        path: `/api/v1/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${targetPath.split('/').map(encodeURIComponent).join('/')}`,
        method: 'POST',
        headers: { 'Authorization': `token ${token}`, 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }
      }, (res) => {
        let b = '';
        res.on('data', c => b += c);
        res.on('end', () => {
          if (res.statusCode >= 200 && res.statusCode < 300) resolve({ ok: true });
          else resolve({ ok: false, error: `HTTP ${res.statusCode}: ${b}` });
        });
      });
      req.on('error', e => resolve({ ok: false, error: String(e) }));
      req.write(body);
      req.end();
    });
  } catch (e) {
    console.error('create-gitea-item error', e);
    return { ok: false, error: String(e) };
  }
});

// Lokal: Umbenennen
ipcMain.handle('rename-local-item', async (event, data) => {
  try {
    const { oldPath, newName } = data;
    if (!oldPath || !fs.existsSync(oldPath)) return { ok: false, error: 'path-not-found' };
    const dir = ppath.dirname(oldPath);
    const newPath = ppath.join(dir, newName);
    fs.renameSync(oldPath, newPath);
    return { ok: true, newPath };
  } catch (e) {
    console.error('rename-local-item error', e);
    return { ok: false, error: String(e) };
  }
});

// Lokal: Neue Datei oder Ordner erstellen
ipcMain.handle('create-local-item', async (event, data) => {
  try {
    const { parentDir, name, type } = data;
    const targetPath = ppath.join(parentDir, name);
    if (type === 'folder') {
      fs.mkdirSync(targetPath, { recursive: true });
    } else {
      // Sicherstellen dass Elternordner existiert
      fs.mkdirSync(ppath.dirname(targetPath), { recursive: true });
      fs.writeFileSync(targetPath, '', 'utf8');
    }
    return { ok: true, path: targetPath };
  } catch (e) {
    console.error('create-local-item error', e);
    return { ok: false, error: String(e) };
  }
});

// Lokal: Verschieben (Cut & Paste)
ipcMain.handle('move-local-item', async (event, data) => {
  try {
    const { srcPath, destDir } = data;
    if (!srcPath || !fs.existsSync(srcPath)) return { ok: false, error: 'source-not-found' };
    const name = ppath.basename(srcPath);
    const destPath = ppath.join(destDir, name);
    fs.mkdirSync(destDir, { recursive: true });
    fs.renameSync(srcPath, destPath);
    return { ok: true, destPath };
  } catch (e) {
    // renameSync kann über Laufwerke nicht funktionieren — dann cpSync + rmSync
    try {
      const { srcPath, destDir } = data;
      const name = ppath.basename(srcPath);
      const destPath = ppath.join(destDir, name);
      if (fs.statSync(srcPath).isDirectory()) {
        fs.cpSync(srcPath, destPath, { recursive: true });
      } else {
        fs.copyFileSync(srcPath, destPath);
      }
      fs.rmSync(srcPath, { recursive: true, force: true });
      return { ok: true, destPath };
    } catch (e2) {
      console.error('move-local-item error', e2);
      return { ok: false, error: String(e2) };
    }
  }
});

// Lokal: Kopieren
ipcMain.handle('copy-local-item', async (event, data) => {
  try {
    const { src, destDir } = data;
    if (!src || !fs.existsSync(src)) return { ok: false, error: 'source-not-found' };
    const name = ppath.basename(src);
    const dest = ppath.join(destDir, name);
    fs.mkdirSync(destDir, { recursive: true });
    if (fs.statSync(src).isDirectory()) {
      fs.cpSync(src, dest, { recursive: true });
    } else {
      fs.copyFileSync(src, dest);
    }
    return { ok: true, dest };
  } catch (e) {
    console.error('copy-local-item error', e);
    return { ok: false, error: String(e) };
  }
});

/* ================================
   RELEASE MANAGEMENT IPC HANDLERS
   ================================ */

// List all releases for a repository
ipcMain.handle('list-releases', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const releases = await listGiteaReleases({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo
    });
    
    return { ok: true, releases };
  } catch (error) {
    console.error('list-releases error:', error);
    return { ok: false, error: String(error) };
  }
});

// Get a specific release by tag
ipcMain.handle('get-release', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const release = await getGiteaRelease({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      tag: data.tag
    });
    
    return { ok: true, release };
  } catch (error) {
    console.error('get-release error:', error);
    return { ok: false, error: String(error) };
  }
});

// Create a new release
ipcMain.handle('create-release', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const releaseData = {
      tag_name: data.tag_name,
      name: data.name,
      body: data.body,
      draft: data.draft,
      prerelease: data.prerelease,
      target_commitish: data.target_commitish
    };
    
    const release = await createGiteaRelease({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      data: releaseData
    });
    
    return { ok: true, release };
  } catch (error) {
    console.error('create-release error:', error);
    const errorMsg = error.message || String(error);
    return { ok: false, error: errorMsg };
  }
});

// Edit/update a release
ipcMain.handle('edit-release', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const updateData = {};
    if (data.name !== undefined) updateData.name = data.name;
    if (data.body !== undefined) updateData.body = data.body;
    if (data.draft !== undefined) updateData.draft = data.draft;
    if (data.prerelease !== undefined) updateData.prerelease = data.prerelease;
    
    const release = await editGiteaRelease({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      releaseId: data.releaseId,
      data: updateData
    });
    
    return { ok: true, release };
  } catch (error) {
    console.error('edit-release error:', error);
    return { ok: false, error: String(error) };
  }
});

// Delete a release
ipcMain.handle('delete-release', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    await deleteGiteaRelease({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      releaseId: data.releaseId
    });
    
    return { ok: true };
  } catch (error) {
    console.error('delete-release error:', error);
    return { ok: false, error: String(error) };
  }
});

// Upload a release asset
ipcMain.handle('upload-release-asset', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const asset = await uploadReleaseAsset({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      releaseId: data.releaseId,
      filePath: data.filePath,
      fileName: data.fileName
    });
    
    return { ok: true, asset };
  } catch (error) {
    console.error('upload-release-asset error:', error);
    return { ok: false, error: String(error) };
  }
});

// Delete a release asset
ipcMain.handle('delete-release-asset', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    await deleteReleaseAsset({
      token: credentials.giteaToken,
      url: credentials.giteaURL,
      owner: data.owner,
      repo: data.repo,
      assetId: data.assetId
    });
    
    return { ok: true };
  } catch (error) {
    console.error('delete-release-asset error:', error);
    return { ok: false, error: String(error) };
  }
});

// Download release archive (ZIP/TAR)
ipcMain.handle('download-release-archive', async (event, data) => {
  try {
    const credentials = readCredentials();
    if (!credentials) return { ok: false, error: 'no-credentials' };
    
    const base = credentials.giteaURL.replace(/\/$/, '');
    const archiveUrl = `${base}/${data.owner}/${data.repo}/archive/${data.tag}.zip`;
    
    // Ask user where to save
    const result = await dialog.showSaveDialog({
      defaultPath: `${data.repo}-${data.tag}.zip`,
      filters: [{ name: 'ZIP Archive', extensions: ['zip'] }]
    });
    
    if (result.canceled) return { ok: false, canceled: true };
    
    const savePath = result.filePath;
    
    // Download archive
    const axios = require('axios');
    const fs = require('fs');
    const writer = fs.createWriteStream(savePath);
    
    const response = await axios({
      url: archiveUrl,
      method: 'GET',
      responseType: 'stream',
      headers: { Authorization: `token ${credentials.giteaToken}` }
    });
    
    response.data.pipe(writer);
    
    return new Promise((resolve, reject) => {
      writer.on('finish', () => resolve({ ok: true, savedTo: savePath }));
      writer.on('error', (err) => reject(err));
    });
    
  } catch (error) {
    console.error('download-release-archive error:', error);
    return { ok: false, error: String(error) };
  }
});

/* ========================
   LOCAL COMMIT HANDLERS
   ======================== */
ipcMain.handle('get-local-commits', async (event, data) => {
  try {
    const { getCommitLogs } = require('./src/git/gitHandler.js');
    const commits = await getCommitLogs(data.folderPath, data.branch || 'HEAD');
    return { ok: true, commits };
  } catch (error) {
    console.error('get-local-commits error:', error);
    return { ok: false, error: String(error) };
  }
});

ipcMain.handle('get-local-commit-details', async (event, data) => {
  try {
    const { getCommitDetails } = require('./src/git/gitHandler.js');
    const details = await getCommitDetails(data.folderPath, data.sha);
    return { ok: true, ...details };
  } catch (error) {
    console.error('get-local-commit-details error:', error);
    return { ok: false, error: String(error) };
  }
});

ipcMain.handle('get-local-commit-diff', async (event, data) => {
  try {
    const { getCommitDiff } = require('./src/git/gitHandler.js');
    const diff = await getCommitDiff(data.folderPath, data.sha);
    return { ok: true, diff };
  } catch (error) {
    console.error('get-local-commit-diff error:', error);
    return { ok: false, error: String(error) };
  }
});

ipcMain.handle('get-local-commit-files', async (event, data) => {
  try {
    const { getCommitDetails } = require('./src/git/gitHandler.js');
    const details = await getCommitDetails(data.folderPath, data.sha);
    return { ok: true, files: details.files || [], stats: { additions: 0, deletions: 0 } };
  } catch (error) {
    console.error('get-local-commit-files error:', error);
    return { ok: false, error: String(error) };
  }
});

/* ========================
   GITEA COMMIT HANDLERS
   ======================== */
ipcMain.handle('get-commit-diff', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    
    if (!token || !url) {
      return { ok: false, error: 'missing-token-or-url' };
    }

    const diff = await getGiteaCommitDiff({
      token,
      url,
      owner: data.owner,
      repo: data.repo,
      sha: data.sha
    });

    return { ok: true, diff };
  } catch (error) {
    console.error('get-commit-diff error:', error);
    return { ok: false, error: String(error) };
  }
});

ipcMain.handle('get-commit-files', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    
    if (!token || !url) {
      return { ok: false, error: 'missing-token-or-url' };
    }

    const result = await getGiteaCommitFiles({
      token,
      url,
      owner: data.owner,
      repo: data.repo,
      sha: data.sha
    });

    return { ok: true, files: result.files, stats: result.stats };
  } catch (error) {
    console.error('get-commit-files error:', error);
    return { ok: false, error: String(error) };
  }
});





/* ============================================
   FAVORITEN & ZULETZT GEÖFFNET - Persistenz
   ============================================ */

function getFavoritesFilePath() {
  return ppath.join(app.getPath('userData'), 'favorites.json');
}

function getRecentFilePath() {
  return ppath.join(app.getPath('userData'), 'recent.json');
}

ipcMain.handle('load-favorites', async () => {
  try {
    const p = getFavoritesFilePath();
    if (!fs.existsSync(p)) return { ok: true, favorites: [] };
    return { ok: true, favorites: JSON.parse(fs.readFileSync(p, 'utf8')) || [] };
  } catch (e) {
    return { ok: true, favorites: [] };
  }
});

ipcMain.handle('save-favorites', async (event, favorites) => {
  try {
    fs.writeFileSync(getFavoritesFilePath(), JSON.stringify(favorites || [], null, 2), 'utf8');
    return { ok: true };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('load-recent', async () => {
  try {
    const p = getRecentFilePath();
    if (!fs.existsSync(p)) return { ok: true, recent: [] };
    return { ok: true, recent: JSON.parse(fs.readFileSync(p, 'utf8')) || [] };
  } catch (e) {
    return { ok: true, recent: [] };
  }
});

ipcMain.handle('save-recent', async (event, recent) => {
  try {
    const trimmed = (recent || []).slice(0, 20);
    fs.writeFileSync(getRecentFilePath(), JSON.stringify(trimmed, null, 2), 'utf8');
    return { ok: true };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

// main.js - Updater IPC Handlers

// Window Controls
ipcMain.on('window-minimize', (event) => {
  const win = BrowserWindow.fromWebContents(event.sender);
  if (win) win.minimize();
});
ipcMain.on('window-maximize', (event) => {
  const win = BrowserWindow.fromWebContents(event.sender);
  if (win) { win.isMaximized() ? win.unmaximize() : win.maximize(); }
});
ipcMain.on('window-close', (event) => {
  const win = BrowserWindow.fromWebContents(event.sender);
  if (win) win.close();
});

// Autostart
ipcMain.handle('set-autostart', (event, enable) => {
  app.setLoginItemSettings({
    openAtLogin: enable,
    openAsHidden: true,
    args: ['--hidden']
  });
  return { ok: true };
});

ipcMain.handle('get-autostart', () => {
  const settings = app.getLoginItemSettings({ args: ['--hidden'] });
  return { ok: true, enabled: settings.openAtLogin };
});

ipcMain.handle('copy-to-clipboard', async (_event, text) => {
  try {
    clipboard.writeText(String(text || ''));
    return { ok: true };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('open-external-url', async (_event, rawUrl) => {
  try {
    const url = String(rawUrl || '').trim();
    if (!url) return { ok: false, error: 'Leere URL' };
    await shell.openExternal(url);
    return { ok: true };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

// 1. Version abfragen
ipcMain.handle('get-app-version', async () => {
  return { ok: true, version: app.getVersion() }; 
});

// 2. Suche nach Updates (Manuell oder Automatisch)
ipcMain.handle('check-for-updates', async (event) => {
  console.log("[Main] Update-Check angefordert...");
  try {
    if (!updater) {
      const win = BrowserWindow.fromWebContents(event.sender);
      if (win) updater = new Updater(win);
    }
    if (updater) await updater.checkForUpdates(false); 
    return { ok: true };
  } catch (error) {
    console.error('[Main] Fehler beim Update-Check:', error);
    return { ok: false, error: String(error) };
  }
});

// 3. Download starten (wird vom "Jetzt installieren" Button gerufen)
ipcMain.handle('start-update-download', async (event, asset) => {
  console.log("[Main] Download-Signal erhalten für:", asset ? asset.name : "Unbekannt");
  try {
    if (!updater) {
      const win = BrowserWindow.fromWebContents(event.sender);
      updater = new Updater(win);
    }
    if (asset && asset.browser_download_url) {
      await updater.startDownload(asset);
      return { ok: true };
    }
    return { ok: false, error: 'Ungültiges Asset' };
  } catch (error) {
    console.error('[Main] Download-Fehler:', error);
    return { ok: false, error: String(error) };
  }
});

ipcMain.handle('test-gitea-connection', async (event, data) => {
  try {
    const credentials = readCredentials();
    const token = (data && data.token) || (credentials && credentials.giteaToken);
    const url = (data && data.url) || (credentials && credentials.giteaURL);
    if (!url) return { ok: false, error: 'Gitea URL fehlt.' };

    const result = await checkGiteaConnection({
      token,
      url,
      timeout: (data && data.timeout) || 8000
    });

    return { ok: result.ok, result };
  } catch (e) {
    console.error('test-gitea-connection error', e);
    return { ok: false, error: mapIpcError(e) };
  }
});

ipcMain.handle('validate-repo-name', async (_event, data) => {
  try {
    const name = String(data && data.name || '').trim();
    const platform = String(data && data.platform || 'gitea').trim().toLowerCase();
    const validPattern = /^[a-zA-Z0-9](?:[a-zA-Z0-9._-]{0,98}[a-zA-Z0-9])?$/;
    const validFormat = validPattern.test(name);

    if (!name) {
      return { ok: true, validFormat: false, existsExact: false, similar: [], checked: false, reason: 'empty-name' };
    }

    if (!validFormat) {
      return { ok: true, validFormat: false, existsExact: false, similar: [], checked: false, reason: 'invalid-format' };
    }

    if (platform !== 'gitea') {
      return { ok: true, validFormat: true, existsExact: false, similar: [], checked: false, reason: 'platform-not-supported' };
    }

    const credentials = readCredentials();
    if (!credentials || !credentials.giteaToken || !credentials.giteaURL) {
      return { ok: true, validFormat: true, existsExact: false, similar: [], checked: false, reason: 'missing-credentials' };
    }

    const list = await listGiteaRepos({ token: credentials.giteaToken, url: credentials.giteaURL });
    const repos = Array.isArray(list) ? list : [];
    const allNames = repos
      .map(r => String(r && r.name || '').trim())
      .filter(Boolean);

    const lower = name.toLowerCase();
    const normalized = lower.replace(/[\s._-]+/g, '');
    const existsExact = allNames.some(n => n.toLowerCase() === lower);

    const similar = allNames
      .filter(n => {
        const nLower = n.toLowerCase();
        const nNorm = nLower.replace(/[\s._-]+/g, '');
        return nLower.includes(lower) || lower.includes(nLower) || nNorm.includes(normalized) || normalized.includes(nNorm);
      })
      .filter(n => n.toLowerCase() !== lower)
      .slice(0, 8);

    return {
      ok: true,
      validFormat: true,
      existsExact,
      similar,
      checked: true,
      totalKnown: allNames.length
    };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});

ipcMain.handle('check-clone-target-collisions', async (_event, data) => {
  try {
    const targetDir = String(data && data.targetDir || '').trim();
    const rawRepos = Array.isArray(data && data.repos) ? data.repos : [];
    const repos = rawRepos
      .map(v => String(v || '').trim())
      .filter(Boolean)
      .map(v => {
        const parts = v.split('/');
        const repo = (parts[1] || '').trim();
        return { input: v, repo };
      })
      .filter(r => r.repo);

    const duplicateRepoNames = [];
    const seen = new Map();
    for (const item of repos) {
      const key = item.repo.toLowerCase();
      const count = (seen.get(key) || 0) + 1;
      seen.set(key, count);
    }
    for (const [name, count] of seen.entries()) {
      if (count > 1) duplicateRepoNames.push(name);
    }

    const existingTargets = [];
    if (targetDir) {
      for (const item of repos) {
        const repoDir = ppath.join(targetDir, item.repo);
        if (fs.existsSync(repoDir)) {
          existingTargets.push(repoDir);
        }
      }
    }

    return {
      ok: true,
      duplicateRepoNames,
      existingTargets,
      hasCollisions: duplicateRepoNames.length > 0 || existingTargets.length > 0
    };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
});