server.ts

/**
 * @license
 * SPDX-License-Identifier: Apache-2.0
 */

import express from 'express';
import path from 'path';
import fs from 'fs';
import http from 'http';
import { exec } from 'child_process';
import { simulator } from './src/utils/debianSimulator.js';

const STATE_PORT_FILE = '/tmp/spaceguard.port';

// Helper to check if a daemon is already running
async function checkDaemonRunning(): Promise<string | null> {
  if (!fs.existsSync(STATE_PORT_FILE)) return null;
  try {
    const url = fs.readFileSync(STATE_PORT_FILE, 'utf8').trim();
    return new Promise((resolve) => {
      const req = http.get(`${url}/api/status`, { timeout: 1000 }, (res) => {
        if (res.statusCode === 200) resolve(url);
        else resolve(null);
      });
      req.on('error', () => resolve(null));
      req.end();
    });
  } catch {
    return null;
  }
}

// Open default browser helper
function openBrowser(url: string) {
  console.log(`[SpaceGuard] Otwieranie interfejsu GUI w przeglądarce: ${url}`);
  const startCmd = process.platform === 'darwin'
    ? `open "${url}"`
    : process.platform === 'win32'
    ? `start "${url}"`
    : `xdg-open "${url}" || sensible-browser "${url}" || x-www-browser "${url}"`;

  exec(startCmd, (err) => {
    if (err) {
      console.log(`[SpaceGuard] Aby otworzyć interfejs GUI, wejdź w przeglądarce pod adres: ${url}`);
    }
  });
}

// CLI Arg handler
async function handleCLIArgs(): Promise<boolean> {
  const args = process.argv.slice(2);
  if (args.length === 0) return false;

  const command = args[0].toLowerCase();

  if (command === '--help' || command === '-h' || command === 'help') {
    console.log(`
🛡️  SpaceGuard v1.2.0 - Standalone Disk Space Optimizer & Live System Audit Daemon

SKŁADNIA:
  spaceguard [KOMENDA] [OPCJE]

KOMENDY:
  open, gui           Otwiera interfejs graficzny SpaceGuard w domyślnej przeglądarce
  status              Wyświetla bieżący status dysku oraz zużycie pamięci demona
  scan                Uruchamia głęboki skan struktury katalogów i pakietów dpkg/brew
  clean               Opróżnia kosz oraz archiwum podrzędne pakietów (.deb/.dmg)
  daemon, start       Uruchamia usługę demona w tle (obsługuje automatyczny port fallback)
  --version, -v       Wyświetla zainstalowaną wersję aplikacji SpaceGuard
  --help, -h          Wyświetla tę pomoc

PRZYKŁADY:
  spaceguard open      # Otwiera GUI
  spaceguard status    # Status z wiersza poleceń
  spaceguard clean     # Szybkie czyszczenie w terminalu
    `);
    process.exit(0);
  }

  if (command === '--version' || command === '-v' || command === 'version') {
    console.log('SpaceGuard v1.2.0 (standalone daemon & storage analyzer)');
    process.exit(0);
  }

  const runningUrl = await checkDaemonRunning();

  if (command === 'open' || command === 'gui') {
    if (runningUrl) {
      openBrowser(runningUrl);
    } else {
      console.log('[SpaceGuard] Usługa demona nie jest jeszcze uruchomiona. Uruchamianie nowego demona...');
      return false; // Continues to start server
    }
    process.exit(0);
  }

  if (command === 'status' || command === 'scan' || command === 'clean') {
    if (runningUrl) {
      try {
        const endpoint = command === 'status' ? '/api/status' : command === 'scan' ? '/api/scan' : '/api/clean';
        const method = command === 'status' ? 'GET' : 'POST';
        
        const req = http.request(`${runningUrl}${endpoint}`, { method }, (res) => {
          let data = '';
          res.on('data', chunk => data += chunk);
          res.on('end', () => {
            try {
              const parsed = JSON.parse(data);
              if (parsed.output) {
                console.log(parsed.output);
              } else {
                console.log(`[SpaceGuard Status] Zajęte miejsce: ${parsed.disk.usedGb} GB / ${parsed.disk.totalGb} GB (${Math.round((parsed.disk.usedGb / parsed.disk.totalGb) * 100)}%)`);
                console.log(`Zainstalowane pakiety: ${parsed.packagesCount} | Kosz: ${parsed.disk.trashSizeMb} MB | APT Cache: ${parsed.disk.cacheSizeMb} MB`);
              }
            } catch {
              console.log(data);
            }
            process.exit(0);
          });
        });
        req.on('error', (err) => {
          console.error(`[SpaceGuard CLI Error] Błąd połączenia z demonem: ${err.message}`);
          process.exit(1);
        });
        req.end();
        return true;
      } catch (e: any) {
        console.error(`[SpaceGuard CLI Error] ${e.message}`);
        process.exit(1);
      }
    } else {
      // Direct local execution if daemon is not running
      const output = simulator.executeCLI(command);
      console.log(output);
      process.exit(0);
    }
  }

  return false;
}

async function startServer() {
  const handled = await handleCLIArgs();
  if (handled) return;

  // Check if daemon is ALREADY running on system
  const runningUrl = await checkDaemonRunning();
  if (runningUrl) {
    console.log(`[SpaceGuard Daemon] Demon już działa w tle na porcie: ${runningUrl}`);
    if (process.argv.includes('--open') || process.argv.includes('open')) {
      openBrowser(runningUrl);
    } else {
      console.log(`[SpaceGuard Daemon] Użyj 'spaceguard open' aby otworzyć interfejs GUI.`);
    }
    process.exit(0);
  }

  const app = express();
  let preferredPort = parseInt(process.env.PORT || '3000', 10);

  app.use(express.json());

  // API Route: Get system disk and indicator tray status
  app.get('/api/status', (req, res) => {
    try {
      res.json({
        disk: simulator.getDiskStatus(),
        packagesCount: simulator.getPackages().filter(p => p.status === 'installed').length
      });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Get full packages list
  app.get('/api/packages', (req, res) => {
    try {
      res.json(simulator.getPackages());
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Get Disk Space Treemap and File Mapping
  app.get('/api/diskmap', (req, res) => {
    try {
      const mode = (req.query.mode as 'folders' | 'applications') || 'applications';
      res.json(simulator.getDiskMap(mode));
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Get a specific package's metadata and connections
  app.get('/api/packages/:name', (req, res) => {
    try {
      const pkg = simulator.getPackage(req.params.name);
      if (!pkg) {
        return res.status(404).json({ error: 'Pakiet nie odnaleziony.' });
      }
      res.json(pkg);
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Install a simulated Debian package
  app.post('/api/packages/install', (req, res) => {
    try {
      const { name, installer, hasSudo, method, sourceUrl } = req.body;
      if (!name) {
        return res.status(400).json({ error: 'Brak nazwy pakietu.' });
      }
      const success = simulator.installPackage(
        name,
        installer || 'root',
        hasSudo !== undefined ? hasSudo : true,
        method || 'apt',
        sourceUrl || ''
      );
      if (!success) {
        return res.status(400).json({ error: 'Instalacja nie powiodła się.' });
      }
      res.json({ success: true, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Add simulated custom wget/curl/zip file footprint
  app.post('/api/packages/custom', (req, res) => {
    try {
      const { name, sizeMb, url, installer, hasSudo, method, createdFiles, collaboratingWith } = req.body;
      if (!name || !sizeMb) {
        return res.status(400).json({ error: 'Nazwa i rozmiar (MB) są wymagane.' });
      }
      const pkg = simulator.addCustomDownload({
        name,
        sizeMb: parseFloat(sizeMb),
        url: url || `https://custom-dl.org/${name}`,
        installer: installer || 'kali',
        hasSudo: hasSudo !== undefined ? hasSudo : false,
        method: method || 'wget',
        createdFiles,
        collaboratingWith
      });
      res.json({ success: true, pkg, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Remove/Free a simulated package
  app.post('/api/packages/remove', (req, res) => {
    try {
      const { name } = req.body;
      if (!name) {
        return res.status(400).json({ error: 'Brak nazwy pakietu.' });
      }
      const result = simulator.removePackage(name);
      if (!result.success) {
        return res.status(400).json({ error: result.reason });
      }
      res.json({ success: true, freedMb: result.freedMb, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Run full scan and synchronize metrics
  app.post('/api/scan', (req, res) => {
    try {
      const output = simulator.executeCLI('scan');
      res.json({ output, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Free target space recommendations
  app.get('/api/recommendations', (req, res) => {
    try {
      const targetGb = parseFloat(req.query.target as string || '2.0');
      const recs = simulator.generateRecommendations(targetGb);
      res.json(recs);
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Wipe system cache and garbage-collect
  app.post('/api/clean', (req, res) => {
    try {
      const output = simulator.executeCLI('clean');
      res.json({ output, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Get Docker and Podman resources
  app.get('/api/containers/resources', (req, res) => {
    try {
      res.json({
        dockerImages: simulator.getDockerImages(),
        dockerContainers: simulator.getDockerContainers(),
        podmanImages: simulator.getPodmanImages(),
        podmanContainers: simulator.getPodmanContainers(),
        disk: simulator.getDiskStatus()
      });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Remove a resource
  app.post('/api/containers/remove', (req, res) => {
    try {
      const { engine, type, id } = req.body;
      if (!engine || !type || !id) {
        return res.status(400).json({ error: 'engine, type i id są wymagane.' });
      }

      let success = false;
      if (engine === 'docker') {
        if (type === 'image') success = simulator.removeDockerImage(id);
        else if (type === 'container') success = simulator.removeDockerContainer(id);
      } else if (engine === 'podman') {
        if (type === 'image') success = simulator.removePodmanImage(id);
        else if (type === 'container') success = simulator.removePodmanContainer(id);
      }

      if (!success) {
        return res.status(400).json({ error: 'Nie udało się usunąć zasobu.' });
      }

      res.json({ success: true, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Prune an engine
  app.post('/api/containers/prune', (req, res) => {
    try {
      const { engine } = req.body;
      if (!engine) {
        return res.status(400).json({ error: 'engine jest wymagany.' });
      }

      let result;
      if (engine === 'docker') {
        result = simulator.pruneDocker();
      } else if (engine === 'podman') {
        result = simulator.prunePodman();
      } else {
        return res.status(400).json({ error: 'Nieobsługiwany silnik.' });
      }

      res.json({
        success: true,
        freedMb: result.freedMb,
        deletedContainers: result.deletedContainers,
        deletedImages: result.deletedImages,
        disk: simulator.getDiskStatus()
      });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Execute interactive CLI commands from UI Terminal
  app.post('/api/cli', (req, res) => {
    try {
      const { command } = req.body;
      if (command === undefined) {
        return res.status(400).json({ error: 'Brak polecenia.' });
      }
      const output = simulator.executeCLI(command);
      res.json({ output, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Reset simulated state
  app.post('/api/reset', (req, res) => {
    try {
      simulator.reset();
      res.json({ success: true, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Software Update Check & Apply
  let appVersion = '1.2.0';
  const latestRelease = {
    version: '1.2.5',
    releaseDate: '2026-07-22',
    changelog: [
      'Enhanced Docker & Podman layer disk space reclamation',
      'Optimized D3 dependency graph rendering performance',
      'Added MacOS and multi-OS storage analyzer compatibility hooks',
      'Updated security audit rules & orphan package heuristics'
    ]
  };

  app.get('/api/update/check', (req, res) => {
    try {
      const hasUpdate = appVersion !== latestRelease.version;
      res.json({
        currentVersion: appVersion,
        latestVersion: latestRelease.version,
        hasUpdate,
        release: latestRelease
      });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  app.post('/api/update/apply', (req, res) => {
    try {
      appVersion = latestRelease.version;
      res.json({
        success: true,
        version: appVersion,
        message: 'SpaceGuard updated successfully. All user settings, logs, and state preserved.'
      });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // API Route: Simulate external background installation / download
  app.post('/api/simulate-external', (req, res) => {
    try {
      const result = simulator.simulateExternalInstallation();
      res.json({ success: true, item: result, disk: simulator.getDiskStatus() });
    } catch (err: any) {
      res.status(500).json({ error: err.message });
    }
  });

  // Vite middleware for development or Static Assets for production
  if (process.env.NODE_ENV !== 'production') {
    const { createServer: createViteServer } = await import('vite');
    const vite = await createViteServer({
      server: { middlewareMode: true },
      appType: 'spa',
    });
    app.use(vite.middlewares);
  } else {
    const distPath = path.join(process.cwd(), 'dist');
    app.use(express.static(distPath));
    app.get('*', (req, res) => {
      res.sendFile(path.join(distPath, 'index.html'));
    });
  }

  // Resilient listener with EADDRINUSE auto port fallback
  const listenWithFallback = (port: number) => {
    const server = app.listen(port, '0.0.0.0', () => {
      const activeUrl = `http://localhost:${port}`;
      console.log(`[SpaceGuard Backend Server] Aktywny pod adresem: ${activeUrl}`);
      try {
        fs.writeFileSync(STATE_PORT_FILE, activeUrl, 'utf8');
      } catch {}

      if (process.argv.includes('--open') || process.argv.includes('open')) {
        openBrowser(activeUrl);
      }
    });

    server.on('error', (err: any) => {
      if (err.code === 'EADDRINUSE') {
        console.warn(`[SpaceGuard Warn] Port ${port} jest już zajęty przez inną usługę. Wybieranie wolnego portu zapasowego...`);
        // Retry on port + 1 or 0 (random free OS port if > 3010)
        const nextPort = port >= 3010 ? 0 : port + 1;
        setTimeout(() => listenWithFallback(nextPort), 200);
      } else {
        console.error(`[SpaceGuard Error] Błąd serwera: ${err.message}`);
      }
    });
  };

  listenWithFallback(preferredPort);
}

startServer();