// app/api/vps/bandwidth/route.ts
import { NextResponse } from 'next/server';
import { execSync } from 'child_process';
import { readFile, writeFile, mkdir } from 'fs/promises';
import path from 'path';

const DATA_DIR = path.join(process.cwd(), 'data');
const BANDWIDTH_FILE = path.join(DATA_DIR, 'bandwidth.json');

interface BandwidthData {
  date: string;
  rx_bytes: number;
  tx_bytes: number;
  interfaces: Record<string, { rx: number; tx: number }>;
}

function formatBytes(bytes: number): string {
  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
  let i = 0;
  while (bytes >= 1024 && i < units.length - 1) {
    bytes /= 1024;
    i++;
  }
  return `${bytes.toFixed(1)} ${units[i]}`;
}

export async function GET() {
  try {
    // Baca data bandwidth dari vnstat
    const output = execSync('vnstat --json d 1', { encoding: 'utf-8' });
    const vnstat = JSON.parse(output);

    // Baca data historis
    let history: BandwidthData[] = [];
    try {
      const raw = await readFile(BANDWIDTH_FILE, 'utf-8');
      history = JSON.parse(raw);
    } catch {
      // File belum ada, abaikan
    }

    const today = new Date().toISOString().split('T')[0];
    const todayData: BandwidthData = {
      date: today,
      rx_bytes: vnstat.interfaces?.eth0?.day?.[0]?.rx ?? 0,
      tx_bytes: vnstat.interfaces?.eth0?.day?.[0]?.tx ?? 0,
      interfaces: {},
    };

    // Update history, max simpan 30 hari
    const idx = history.findIndex((d) => d.date === today);
    if (idx >= 0) history[idx] = todayData;
    else history.push(todayData);

    history = history.slice(-30);

    // Simpan ke file
    await mkdir(DATA_DIR, { recursive: true });
    await writeFile(BANDWIDTH_FILE, JSON.stringify(history, null, 2));

    return NextResponse.json({
      today: {
        ...todayData,
        rx_human: formatBytes(todayData.rx_bytes),
        tx_human: formatBytes(todayData.tx_bytes),
      },
      history,
    });
  } catch (error) {
    return NextResponse.json(
      { error: 'Failed to read bandwidth data' },
      { status: 500 }
    );
  }
}

// app/api/vps/interfaces/route.ts
import { NextResponse } from 'next/server';
import { execSync } from 'child_process';

export async function GET() {
  try {
    const output = execSync("ip -j addr show", { encoding: 'utf-8' });
    const interfaces = JSON.parse(output)
      .filter((iface: any) => iface.ifname !== 'lo')
      .map((iface: any) => ({
        name: iface.ifname,
        state: iface.operstate,
        mtu: iface.mtu,
        addresses: iface.addr_info?.map((addr: any) => ({
          family: addr.family,
          local: addr.local,
          prefixlen: addr.prefixlen,
        })) ?? [],
      }));

    return NextResponse.json({ interfaces });
  } catch {
    return NextResponse.json(
      { error: 'Failed to read interfaces' },
      { status: 500 }
    );
  }
}

// app/api/vps/speedtest/route.ts
import { NextResponse } from 'next/server';
import { execSync } from 'child_process';

export async function POST() {
  try {
    // Timeout 60 detik soalnya speedtest butuh waktu
    const output = execSync('speedtest-cli --json', {
      encoding: 'utf-8',
      timeout: 60000,
    });

    const result = JSON.parse(output);

    return NextResponse.json({
      download: {
        bits: result.download,
        bandwidth: (result.download / 1_000_000).toFixed(2),
        unit: 'Mbps',
      },
      upload: {
        bits: result.upload,
        bandwidth: (result.upload / 1_000_000).toFixed(2),
        unit: 'Mbps',
      },
      ping: result.ping,
      server: result.server?.sponsor,
      timestamp: result.timestamp,
    });
  } catch (error: any) {
    if (error.killed) {
      return NextResponse.json(
        { error: 'Speedtest timeout (60s)' },
        { status: 504 }
      );
    }
    return NextResponse.json(
      { error: 'Speedtest failed' },
      { status: 500 }
    );
  }
}