server.js

const express = require('express');
const fs = require('fs');
const path = require('path');
const os = require('os');
const { execSync } = require('child_process');

const app = express();
const PORT = 3847;

app.use(express.static(path.join(__dirname, 'public')));
app.use(express.json());

// Get home path
app.get('/api/home', (req, res) => {
  res.json({ home: os.homedir() });
});

// Get disk overview
app.get('/api/disk-info', (req, res) => {
  try {
    const output = execSync("df -h / | tail -1").toString().trim();
    const parts = output.split(/\s+/);
    const totalRaw = execSync("df -k / | tail -1").toString().trim().split(/\s+/);
    res.json({
      filesystem: parts[0],
      total: parts[1],
      used: parts[2],
      available: parts[3],
      usedPercent: parseInt(parts[4]),
      totalBytes: parseInt(totalRaw[1]) * 1024,
      usedBytes: parseInt(totalRaw[2]) * 1024,
      availableBytes: parseInt(totalRaw[3]) * 1024,
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Scan a directory
app.get('/api/scan', (req, res) => {
  let targetPath = req.query.path || os.homedir();
  if (targetPath === '~') targetPath = os.homedir();
  const depthLimit = parseInt(req.query.depth) || 1;

  try {
    const realPath = fs.realpathSync(targetPath);
    const results = scanDirectory(realPath, depthLimit, 0);
    results.sort((a, b) => b.size - a.size);
    res.json({
      path: realPath,
      children: results,
      totalSize: results.reduce((sum, item) => sum + item.size, 0),
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Quick scan using a single du call for all top-level entries
app.get('/api/quick-scan', (req, res) => {
  let targetPath = req.query.path || os.homedir();
  if (targetPath === '~') targetPath = os.homedir();

  try {
    const realPath = fs.realpathSync(targetPath);

    let entries;
    try {
      entries = fs.readdirSync(realPath, { withFileTypes: true });
    } catch {
      return res.json({ path: realPath, children: [], totalSize: 0 });
    }

    // Use a single du -sk -d 0 on each item via xargs for speed
    const sizeMap = {};
    try {
      const duOutput = execSync(
        `du -sk "${realPath}"/* "${realPath}"/.[!.]* 2>/dev/null || true`,
        { timeout: 30000, maxBuffer: 10 * 1024 * 1024 }
      ).toString().trim();

      for (const line of duOutput.split('\n')) {
        if (!line) continue;
        const match = line.match(/^(\d+)\s+(.+)$/);
        if (match) {
          sizeMap[match[2]] = parseInt(match[1]) * 1024;
        }
      }
    } catch {
      // Fallback: sizes will be 0
    }

    const results = [];
    for (const entry of entries) {
      try {
        if (entry.isSymbolicLink()) continue;
        const fullPath = path.join(realPath, entry.name);
        const isDir = entry.isDirectory();
        let size = sizeMap[fullPath] || 0;

        if (!isDir && size === 0) {
          try {
            const stats = fs.statSync(fullPath);
            size = stats.size;
          } catch {}
        }

        results.push({
          name: entry.name,
          path: fullPath,
          size,
          isDirectory: isDir,
          children: [],
        });
      } catch {
        // Skip inaccessible items
      }
    }

    results.sort((a, b) => b.size - a.size);
    const totalSize = results.reduce((sum, item) => sum + item.size, 0);

    res.json({ path: realPath, children: results, totalSize });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

function scanDirectory(dirPath, depthLimit, currentDepth) {
  const results = [];

  let entries;
  try {
    entries = fs.readdirSync(dirPath, { withFileTypes: true });
  } catch {
    return results;
  }

  for (const entry of entries) {
    const fullPath = path.join(dirPath, entry.name);

    try {
      if (entry.isSymbolicLink()) continue;

      if (entry.isDirectory()) {
        let size = 0;
        let children = [];

        if (currentDepth < depthLimit) {
          children = scanDirectory(fullPath, depthLimit, currentDepth + 1);
          size = children.reduce((sum, child) => sum + child.size, 0);
        } else {
          try {
            const duOutput = execSync(
              `du -sk "${fullPath}" 2>/dev/null || echo "0"`,
              { timeout: 5000 }
            ).toString().trim();
            const match = duOutput.match(/^(\d+)/);
            size = match ? parseInt(match[1]) * 1024 : 0;
          } catch {
            size = 0;
          }
        }

        children.sort((a, b) => b.size - a.size);
        results.push({
          name: entry.name,
          path: fullPath,
          size,
          isDirectory: true,
          children,
        });
      } else {
        const stats = fs.statSync(fullPath);
        results.push({
          name: entry.name,
          path: fullPath,
          size: stats.size,
          isDirectory: false,
          children: [],
        });
      }
    } catch {
      // Skip inaccessible files
    }
  }

  return results;
}

// Move items to Trash (macOS)
app.post('/api/trash', (req, res) => {
  const { paths } = req.body;

  if (!paths || !Array.isArray(paths) || paths.length === 0) {
    return res.status(400).json({ error: 'No paths provided' });
  }

  // Safety: block critical system paths
  const blocked = ['/', '/System', '/usr', '/bin', '/sbin', '/var', '/etc', '/tmp',
    '/Applications', '/Library', os.homedir()];

  const results = [];

  for (const itemPath of paths) {
    const resolved = path.resolve(itemPath);

    if (blocked.includes(resolved)) {
      results.push({ path: resolved, success: false, error: 'Protected system path' });
      continue;
    }

    // Must be under home directory
    if (!resolved.startsWith(os.homedir() + '/')) {
      results.push({ path: resolved, success: false, error: 'Can only delete files under home directory' });
      continue;
    }

    try {
      // Use macOS trash via osascript (moves to Trash, recoverable)
      execSync(
        `osascript -e 'tell application "Finder" to delete POSIX file "${resolved}"'`,
        { timeout: 15000 }
      );
      results.push({ path: resolved, success: true });
    } catch (err) {
      results.push({ path: resolved, success: false, error: err.message });
    }
  }

  const succeeded = results.filter(r => r.success).length;
  const failed = results.filter(r => !r.success).length;
  res.json({ results, succeeded, failed });
});

// Permanent delete
app.post('/api/delete', (req, res) => {
  const { paths } = req.body;

  if (!paths || !Array.isArray(paths) || paths.length === 0) {
    return res.status(400).json({ error: 'No paths provided' });
  }

  const blocked = ['/', '/System', '/usr', '/bin', '/sbin', '/var', '/etc', '/tmp',
    '/Applications', '/Library', os.homedir()];

  const results = [];

  for (const itemPath of paths) {
    const resolved = path.resolve(itemPath);

    if (blocked.includes(resolved)) {
      results.push({ path: resolved, success: false, error: 'Protected system path' });
      continue;
    }

    if (!resolved.startsWith(os.homedir() + '/')) {
      results.push({ path: resolved, success: false, error: 'Can only delete files under home directory' });
      continue;
    }

    try {
      fs.rmSync(resolved, { recursive: true, force: true });
      results.push({ path: resolved, success: true });
    } catch (err) {
      results.push({ path: resolved, success: false, error: err.message });
    }
  }

  const succeeded = results.filter(r => r.success).length;
  const failed = results.filter(r => !r.success).length;
  res.json({ results, succeeded, failed });
});

app.listen(PORT, () => {
  console.log(`Disk Analyzer running at http://localhost:${PORT}`);
});