import express from 'express';
import os from 'os';
import { promises as fs } from 'fs';

const app = express();
const PORT = process.env.PORT || 5000;

app.get('/', (req, res) => {
  res.send('Hello, This is LumaKit Backend!');
});

app.all('/stats', async (req, res) => {
  try {
    // Check the request query and check is it correct value as process.env.SECRET
    if (req.query.secret !== process.env.SECRET) {
      return res.status(403).json({ error: 'Forbidden' });
    }

    // Get network interfaces
    const networkInterfaces = os.networkInterfaces();
    const ipAddresses = [];

    for (const [name, interfaces] of Object.entries(networkInterfaces)) {
      for (const iface of interfaces) {
        if (!iface.internal) {
          ipAddresses.push({
            interface: name,
            address: iface.address,
            family: iface.family,
            mac: iface.mac,
          });
        }
      }
    }

    // Get memory information
    const totalMemory = os.totalmem();
    const freeMemory = os.freemem();
    const usedMemory = totalMemory - freeMemory;

    // Get CPU information
    const cpus = os.cpus();
    const loadAverage = os.loadavg();

    // Get uptime
    const systemUptime = os.uptime();
    const processUptime = process.uptime();

    // Get platform and architecture
    const platform = os.platform();
    const architecture = os.arch();
    const release = os.release();
    const hostname = os.hostname();

    // Get Node.js/Bun version and environment
    const nodeVersion = process.version;
    const bunVersion = process.versions?.bun || 'N/A';

    // Try to get container information if available
    let containerInfo = null;
    try {
      const cgroupData = await fs
        .readFile('/proc/1/cgroup', 'utf8')
        .catch(() => null);
      if (cgroupData && cgroupData.includes('docker')) {
        containerInfo = { type: 'docker', detected: true };
      } else if (cgroupData && cgroupData.includes('kubepods')) {
        containerInfo = { type: 'kubernetes', detected: true };
      }
    } catch (error) {
      containerInfo = { type: 'unknown', detected: false };
    }

    // Get disk usage for the current directory
    let diskUsage = null;
    try {
      const stats = await fs.stat(process.cwd());
      diskUsage = {
        currentDirectory: process.cwd(),
        accessible: true,
      };
    } catch (error) {
      diskUsage = {
        currentDirectory: process.cwd(),
        accessible: false,
        error: error.message,
      };
    }

    const serverStats = {
      timestamp: new Date().toISOString(),
      server: {
        name: 'LumaKit Backend',
        version: require('../package.json').version,
        environment: process.env.NODE_ENV || 'development',
        port: PORT,
        pid: process.pid,
        uptime: {
          process: Math.floor(processUptime),
          system: Math.floor(systemUptime),
        },
      },
      machine: {
        hostname: hostname,
        platform: platform,
        architecture: architecture,
        release: release,
        endianness: os.endianness(),
        tmpdir: os.tmpdir(),
        homedir: os.homedir(),
      },
      network: {
        ipAddresses: ipAddresses,
        hostname: hostname,
      },
      runtime: {
        node: nodeVersion,
        bun: bunVersion,
        engine: bunVersion !== 'N/A' ? 'bun' : 'node',
      },
      memory: {
        total: Math.round(totalMemory / 1024 / 1024),
        free: Math.round(freeMemory / 1024 / 1024),
        used: Math.round(usedMemory / 1024 / 1024),
        percentage: Math.round((usedMemory / totalMemory) * 100),
        unit: 'MB',
      },
      cpu: {
        count: cpus.length,
        model: cpus[0]?.model || 'Unknown',
        speed: cpus[0]?.speed || 0,
        loadAverage: {
          '1min': loadAverage[0]?.toFixed(2) || 0,
          '5min': loadAverage[1]?.toFixed(2) || 0,
          '15min': loadAverage[2]?.toFixed(2) || 0,
        },
      },
      container: containerInfo,
      disk: diskUsage,
      environment: {
        nodeEnv: process.env.NODE_ENV,
        port: process.env.PORT,
        pwd: process.env.PWD,
        user: process.env.USER || process.env.USERNAME,
        shell: process.env.SHELL,
        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
      },
    };

    res.status(200).json(serverStats);
  } catch (error) {
    res.status(500).json({
      error: 'Failed to retrieve server stats',
      message: error.message,
      timestamp: new Date().toISOString(),
    });
  }
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server is running on http://0.0.0.0:${PORT}`);
});