const { app, BrowserWindow, dialog, ipcMain, shell } = require('electron');
const path = require('path');
const fs = require('fs');
const fsp = fs.promises;
const { emptyDropStats, mergeDropStatsInto } = require('./lib/dropstats');

// Stocké automatiquement dans ~/.config/farm-tracker/ sur Linux (géré par Electron).
const userDataDir = app.getPath('userData');
const APP_STATE_FILE = path.join(userDataDir, 'app-state.json');
const DROPSTATS_FILE = path.join(userDataDir, 'dropstats.json');
const COMMUNITY_DROPSTATS_FILE = path.join(userDataDir, 'community-dropstats.json');
const SESSION_HISTORY_FILE = path.join(userDataDir, 'session-history.json');
const UPDATE_PREFS_FILE = path.join(userDataDir, 'update-prefs.json');

const RELEASES_API = 'https://git.shamiiow.com/api/v1/repos/shamiiow/farm-tracker-sao/releases/latest';

// ---------- Lecture / écriture disque (JSON indenté = facilement lisible) ----------

function readJsonSafe(filePath, fallback) {
  try {
    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
  } catch (e) {
    return fallback;
  }
}

function writeJsonAtomic(filePath, obj) {
  try {
    if (!fs.existsSync(userDataDir)) fs.mkdirSync(userDataDir, { recursive: true });
    const tmp = filePath + '.tmp';
    fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
    fs.renameSync(tmp, filePath);
    return true;
  } catch (e) {
    console.error('Erreur de sauvegarde (' + filePath + '):', e);
    return false;
  }
}

function loadAppState() { return readJsonSafe(APP_STATE_FILE, null); }
function saveAppState(obj) { return writeJsonAtomic(APP_STATE_FILE, obj); }
function loadDropStats() { return readJsonSafe(DROPSTATS_FILE, emptyDropStats()); }
function saveDropStats(obj) { return writeJsonAtomic(DROPSTATS_FILE, obj); }
function loadCommunityDropStats() { return readJsonSafe(COMMUNITY_DROPSTATS_FILE, null); }
function saveCommunityDropStats(obj) { return writeJsonAtomic(COMMUNITY_DROPSTATS_FILE, obj); }
function loadSessionHistory() { return readJsonSafe(SESSION_HISTORY_FILE, { type: 'farm-tracker-session-history', version: 1, sessions: [] }); }
function saveSessionHistory(obj) { return writeJsonAtomic(SESSION_HISTORY_FILE, obj); }
function loadUpdatePrefs() { return readJsonSafe(UPDATE_PREFS_FILE, { snoozedUntil: null }); }
function saveUpdatePrefs(obj) { return writeJsonAtomic(UPDATE_PREFS_FILE, obj); }

function resolveLogPath(folderPath) {
  const candidate1 = path.join(folderPath, 'logs', 'latest.log');
  const candidate2 = path.join(folderPath, 'latest.log');
  if (fs.existsSync(candidate1)) return candidate1;
  if (fs.existsSync(candidate2)) return candidate2;
  return null;
}

// ---------- Mise à jour ----------

function isNewerVersion(remote, current) {
  const r = remote.split('.').map(Number);
  const c = current.split('.').map(Number);
  for (let i = 0; i < 3; i++) {
    if ((r[i] || 0) > (c[i] || 0)) return true;
    if ((r[i] || 0) < (c[i] || 0)) return false;
  }
  return false;
}

const SNOOZE_OPTIONS = [
  { label: '1 jour',       days: 1    },
  { label: '2 jours',      days: 2    },
  { label: '5 jours',      days: 5    },
  { label: '1 semaine',    days: 7    },
  { label: '2 semaines',   days: 14   },
  { label: 'Indéfiniment', days: null },
  { label: 'Annuler',      days: -1   }
];

function fetchLatestRelease() {
  return new Promise((resolve, reject) => {
    const https = require('https');
    const req = https.get(RELEASES_API, {
      timeout: 10000,
      headers: { 'User-Agent': 'farm-tracker-updater' }
    }, (res) => {
      let data = '';
      res.on('data', chunk => { data += chunk; });
      res.on('end', () => {
        try { resolve(JSON.parse(data)); }
        catch (e) { reject(new Error('Réponse invalide')); }
      });
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
  });
}

function resolveAssetUrl(release) {
  const ext = process.platform === 'win32' ? '.exe' : '.AppImage';
  const asset = (release.assets || []).find(a => a.name.endsWith(ext));
  return asset ? asset.browser_download_url : null;
}

function sendUpdateProgress(percent, status, error) {
  if (mainWindow && !mainWindow.isDestroyed())
    mainWindow.webContents.send('update-progress', { percent, status, error });
}

function downloadFileWithProgress(url, destPath, onProgress) {
  return new Promise((resolve, reject) => {
    const follow = (currentUrl, redirects) => {
      if (redirects > 5) return reject(new Error('Trop de redirections'));
      const mod = currentUrl.startsWith('https') ? require('https') : require('http');
      const req = mod.get(currentUrl, { timeout: 120000, headers: { 'User-Agent': 'farm-tracker-updater' } }, (res) => {
        if ([301, 302, 307, 308].includes(res.statusCode))
          return follow(res.headers.location, redirects + 1);
        if (res.statusCode !== 200)
          return reject(new Error(`HTTP ${res.statusCode}`));
        const total = parseInt(res.headers['content-length'] || '0', 10);
        let downloaded = 0;
        const file = fs.createWriteStream(destPath);
        res.on('data', chunk => {
          downloaded += chunk.length;
          file.write(chunk);
          if (total > 0 && onProgress) onProgress(Math.round(downloaded / total * 100));
        });
        res.on('end', () => file.close(() => resolve(destPath)));
        res.on('error', err => { file.close(); try { fs.unlinkSync(destPath); } catch (_) {} reject(err); });
      });
      req.on('error', reject);
      req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
    };
    follow(url, 0);
  });
}

async function downloadAndInstall(downloadUrl, version) {
  if (!app.isPackaged) {
    dialog.showMessageBox(mainWindow, {
      type: 'info', title: 'Mode développement',
      message: 'Auto-install non disponible en mode dev.',
      buttons: ['OK']
    });
    return;
  }
  const ext = process.platform === 'win32' ? '.exe' : '.AppImage';
  const tmpPath = path.join(app.getPath('temp'), `farm-tracker-${version}${ext}`);
  try {
    sendUpdateProgress(0, 'downloading');
    await downloadFileWithProgress(downloadUrl, tmpPath, pct => sendUpdateProgress(pct, 'downloading'));
    sendUpdateProgress(100, 'installing');
    if (process.platform === 'linux') {
      fs.chmodSync(tmpPath, 0o755);
      const { spawn } = require('child_process');
      spawn(tmpPath, [], { detached: true, stdio: 'ignore' }).unref();
      app.quit();
    } else if (process.platform === 'win32') {
      const { spawn } = require('child_process');
      spawn(tmpPath, ['/S'], { detached: true, stdio: 'ignore' }).unref();
      app.quit();
    }
  } catch (e) {
    sendUpdateProgress(0, 'error', e.message);
  }
}

async function showUpdateDialog(version, downloadUrl, ignoreSnooze = false) {
  const current = app.getVersion();
  if (!isNewerVersion(version, current)) return false;

  if (!ignoreSnooze) {
    const prefs = loadUpdatePrefs();
    if (prefs.snoozedUntil === 'indefinite') return false;
    if (prefs.snoozedUntil && new Date(prefs.snoozedUntil) > new Date()) return false;
  }

  const { response } = await dialog.showMessageBox(mainWindow, {
    type: 'info',
    title: 'Mise à jour disponible',
    message: `Version ${version} disponible`,
    detail: `Version actuelle : ${current}\nL'application se relancera automatiquement après la mise à jour.`,
    buttons: ['Installer maintenant', 'Me rappeler dans...'],
    defaultId: 0,
    cancelId: 1
  });

  if (response === 0) {
    downloadAndInstall(downloadUrl, version);
    return true;
  }

  const { response: snoozeResponse } = await dialog.showMessageBox(mainWindow, {
    type: 'question',
    title: 'Me rappeler dans...',
    message: 'Ne plus afficher cette mise à jour pendant :',
    buttons: SNOOZE_OPTIONS.map(o => o.label),
    defaultId: 0,
    cancelId: SNOOZE_OPTIONS.length - 1
  });

  const chosen = SNOOZE_OPTIONS[snoozeResponse];
  if (chosen.days === -1) return false;
  if (chosen.days === null) {
    saveUpdatePrefs({ snoozedUntil: 'indefinite' });
  } else {
    const until = new Date();
    until.setDate(until.getDate() + chosen.days);
    saveUpdatePrefs({ snoozedUntil: until.toISOString() });
  }
  return false;
}

async function checkForUpdates(ignoreSnooze = false) {
  try {
    const release = await fetchLatestRelease();
    const version = (release.tag_name || '').replace(/^v/, '');
    const downloadUrl = resolveAssetUrl(release);
    if (!version || !downloadUrl) return false;
    return await showUpdateDialog(version, downloadUrl, ignoreSnooze);
  } catch (_) {
    return false;
  }
}

let mainWindow;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1180,
    height: 880,
    minWidth: 760,
    minHeight: 600,
    backgroundColor: '#0B0F0C',
    autoHideMenuBar: true,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false
    }
  });
  mainWindow.setMenuBarVisibility(false);
  mainWindow.loadFile(path.join(__dirname, 'renderer', 'index.html'));
}

function selfInstallLinux() {
  if (process.platform !== 'linux' || !app.isPackaged) return;
  const appImagePath = process.env.APPIMAGE;
  if (!appImagePath) return;
  const stablePath = path.join(require('os').homedir(), '.local', 'bin', 'farm-tracker.AppImage');
  if (appImagePath === stablePath) return;
  try {
    fs.mkdirSync(path.dirname(stablePath), { recursive: true });
    fs.copyFileSync(appImagePath, stablePath);
    fs.chmodSync(stablePath, 0o755);
  } catch (_) {}
}

app.whenReady().then(() => {
  selfInstallLinux();
  createWindow();
  setTimeout(() => checkForUpdates(false), 5000);
});
app.on('window-all-closed', () => { if (process.platform !== 'darwin') app.quit(); });
app.on('activate', () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); });

// ---------- IPC : sélection et lecture du dossier Minecraft ----------

ipcMain.handle('pick-folder', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory'],
    title: 'Choisis ton dossier .minecraft (ou directement le dossier logs)'
  });
  if (result.canceled || !result.filePaths.length) return { canceled: true };
  const folder = result.filePaths[0];
  const logPath = resolveLogPath(folder);
  if (!logPath) {
    return {
      canceled: false,
      error: 'Impossible de trouver "latest.log" dans ce dossier ni dans son sous-dossier "logs". Sélectionne ton dossier .minecraft, ou le dossier logs directement.'
    };
  }
  return { canceled: false, logPath };
});

ipcMain.handle('check-log-path', async (event, logPath) => {
  try { await fsp.access(logPath, fs.constants.R_OK); return { ok: true }; }
  catch (e) { return { ok: false }; }
});

ipcMain.handle('get-file-size', async (event, logPath) => {
  try { const st = await fsp.stat(logPath); return { size: st.size }; }
  catch (e) { return { size: 0, error: e.message }; }
});

ipcMain.handle('read-chunk', async (event, logPath, start, end) => {
  if (end <= start) return { text: '' };
  let fd;
  try {
    fd = await fsp.open(logPath, 'r');
    const length = end - start;
    const buffer = Buffer.alloc(length);
    await fd.read(buffer, 0, length, start);
    return { text: buffer.toString('utf8') };
  } catch (e) {
    return { text: '', error: e.message };
  } finally {
    if (fd) await fd.close().catch(() => {});
  }
});

// ---------- IPC : état général de l'appli ----------

ipcMain.handle('load-app-state', async () => loadAppState());
ipcMain.handle('save-app-state', async (event, obj) => saveAppState(obj));

// ---------- IPC : stats de chance de drop personnelles ----------

ipcMain.handle('load-drop-stats', async () => loadDropStats());
ipcMain.handle('save-drop-stats', async (event, obj) => saveDropStats(obj));

ipcMain.handle('export-drop-stats', async () => {
  const current = loadDropStats();
  const defaultName = 'farm-tracker-dropstats-' + new Date().toISOString().slice(0, 10) + '.json';
  const result = await dialog.showSaveDialog(mainWindow, {
    title: 'Exporter mes stats de chance de drop',
    defaultPath: defaultName,
    filters: [{ name: 'JSON', extensions: ['json'] }]
  });
  if (result.canceled || !result.filePath) return { canceled: true };
  fs.writeFileSync(result.filePath, JSON.stringify(current, null, 2));
  return { canceled: false, filePath: result.filePath };
});

ipcMain.handle('import-merge-drop-stats', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    title: 'Importer et fusionner des fichiers de stats de drop (plusieurs fichiers possibles)',
    properties: ['openFile', 'multiSelections'],
    filters: [{ name: 'JSON', extensions: ['json'] }]
  });
  if (result.canceled || !result.filePaths.length) return { canceled: true };

  const current = loadDropStats();
  const details = [];
  let totalAdded = 0;

  for (const filePath of result.filePaths) {
    try {
      const raw = fs.readFileSync(filePath, 'utf8');
      const data = JSON.parse(raw);
      const added = mergeDropStatsInto(current, data);
      totalAdded += added;
      details.push({ file: path.basename(filePath), addedKills: added, ok: true });
    } catch (e) {
      details.push({ file: path.basename(filePath), ok: false, error: e.message });
    }
  }

  current.updatedAt = new Date().toISOString();
  saveDropStats(current);

  return { canceled: false, totalAdded, details, dropStats: current };
});

// ---------- IPC : stats communautaires (reçues du serveur de sync) ----------

ipcMain.handle('load-community-drop-stats', async () => loadCommunityDropStats());
ipcMain.handle('save-community-drop-stats', async (event, obj) => saveCommunityDropStats(obj));
ipcMain.handle('get-file-paths', () => ({ dropStats: DROPSTATS_FILE, communityDropStats: COMMUNITY_DROPSTATS_FILE }));

// ---------- IPC : historique des sessions ----------

ipcMain.handle('load-session-history', async () => loadSessionHistory());
ipcMain.handle('save-session-history', async (event, obj) => saveSessionHistory(obj));

// ---------- IPC : mise à jour ----------

ipcMain.handle('check-update-manual', async () => {
  try {
    const release = await fetchLatestRelease();
    const version = (release.tag_name || '').replace(/^v/, '');
    const downloadUrl = resolveAssetUrl(release);
    const current = app.getVersion();
    if (!version || !downloadUrl || !isNewerVersion(version, current)) {
      return { checked: true, hasUpdate: false, current };
    }
    await showUpdateDialog(version, downloadUrl, true);
    return { checked: true, hasUpdate: true };
  } catch (e) {
    return { checked: false, error: e.message };
  }
});

// ---------- IPC : sync avec le serveur VPS ----------

ipcMain.handle('fetch-community-stats', async (event, { serverUrl }) => {
  return new Promise((resolve) => {
    try {
      const url = new URL('/stats', serverUrl);
      const mod = url.protocol === 'https:' ? require('https') : require('http');
      const req = mod.get({
        hostname: url.hostname,
        port: url.port || (url.protocol === 'https:' ? 443 : 80),
        path: '/stats'
      }, (res) => {
        let data = '';
        res.on('data', chunk => { data += chunk; });
        res.on('end', () => {
          try { resolve({ ok: true, ...JSON.parse(data) }); }
          catch { resolve({ ok: false, error: 'Réponse invalide du serveur' }); }
        });
      });
      req.setTimeout(15000, () => { req.destroy(); resolve({ ok: false, error: 'Timeout (15s)' }); });
      req.on('error', (e) => resolve({ ok: false, error: e.message }));
    } catch (e) {
      resolve({ ok: false, error: e.message });
    }
  });
});

ipcMain.handle('sync-drop-stats', async (event, { serverUrl, clientId, dropStats }) => {
  return new Promise((resolve) => {
    try {
      const url = new URL('/sync', serverUrl);
      const body = JSON.stringify({ clientId, dropStats });
      const mod = url.protocol === 'https:' ? require('https') : require('http');
      const options = {
        hostname: url.hostname,
        port: url.port || (url.protocol === 'https:' ? 443 : 80),
        path: '/sync',
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(body)
        }
      };
      const req = mod.request(options, (res) => {
        let data = '';
        res.on('data', chunk => { data += chunk; });
        res.on('end', () => {
          try { resolve({ ok: true, ...JSON.parse(data) }); }
          catch { resolve({ ok: false, error: 'Réponse invalide du serveur' }); }
        });
      });
      req.setTimeout(15000, () => { req.destroy(); resolve({ ok: false, error: 'Timeout (15s)' }); });
      req.on('error', (e) => resolve({ ok: false, error: e.message }));
      req.write(body);
      req.end();
    } catch (e) {
      resolve({ ok: false, error: e.message });
    }
  });
});