import { NextResponse } from "next/server";
import { SessionManager } from "@/lib/agents/SessionManager";
import { promisify } from "util";
import { execFile } from "child_process";
import os from "os";

const execFilePromise = promisify(execFile);

// Real per-process stats for the PTY. Returns null when unavailable (pidusage
// not installed, or no live pid) so callers report honestly instead of faking it.
async function getProcessStats(pid: number | undefined): Promise<{ cpu: number; memory: number } | null> {
  if (!pid) return null;
  try {
    /* eslint-disable @typescript-eslint/no-require-imports */
    const pidusage = eval("require")("pidusage");
    const stat = await pidusage(pid);
    return { cpu: stat.cpu, memory: stat.memory };
  } catch {
    return null;
  }
}

export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const id = searchParams.get("id");

    if (!id) {
      return NextResponse.json({ error: "Missing session id" }, { status: 400 });
    }

    const manager = SessionManager.getInstance();
    const session = manager.getSession(id);
    if (!session) {
      return NextResponse.json({ error: "Session not found" }, { status: 404 });
    }

    // Default response metrics. `available` reports whether these are real
    // measurements (vs. a placeholder when telemetry can't be collected).
    let cpu = "0.0%";
    let memory = "0.0MiB";
    let memoryPercent = "0.0%";
    let available = false;

    if (session.status === "running") {
      const isDocker = session.type === "claude-docker" || session.type === "aider-docker";
      if (isDocker) {
        try {
          // Real container stats from the Docker daemon.
          const containerName = `neural-loom-session-${id}`;
          const { stdout } = await execFilePromise("docker", [
            "stats",
            containerName,
            "--no-stream",
            "--format",
            "{{.CPUPerc}},{{.MemUsage}},{{.MemPerc}}",
          ]);
          const parts = stdout.toString().trim().split(",");
          if (parts.length >= 3) {
            cpu = parts[0].trim();
            memory = parts[1].trim().split(" / ")[0]; // used part, e.g. "142.2MiB"
            memoryPercent = parts[2].trim();
            available = true;
          }
        } catch {
          // Docker daemon/container not reachable — leave defaults, available=false.
        }
      } else {
        // Real per-process stats for the local/SSH PTY process.
        const stats = await getProcessStats(session.getPid());
        if (stats) {
          cpu = stats.cpu.toFixed(1) + "%";
          memory = (stats.memory / (1024 * 1024)).toFixed(1) + "MiB";
          memoryPercent = ((stats.memory / os.totalmem()) * 100).toFixed(2) + "%";
          available = true;
        }
      }
    }

    return NextResponse.json({
      success: true,
      id,
      status: session.status,
      type: session.type,
      cpu,
      memory,
      memoryPercent,
      available,
    });
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : "Unknown error";
    return NextResponse.json({ error: errorMessage }, { status: 500 });
  }
}