#!/usr/bin/env bun
import minimist from "minimist";
import { generateEnvTypes } from "./generate/env.generate.js";
import path from "path";
import net from "net";

interface CheckPortResult {
  port: number;
  open: boolean;
}

const args = minimist(process.argv.slice(2));

const help = `
g3n [command] [options]

Commands:
  env     Generate env.d.ts from .env file
  scan    Scan port range (default 3000-4000)

Options:
  --env    Path ke file .env (default: .env)
  --out    Path file output (default: types/env.d.ts)
  --start  Port awal scan (default: 3000)
  --end    Port akhir scan (default: 4000)
  --host   Host/IP target (default: 127.0.0.1)

Examples:
  g3n env --env .env.local --out src/types/env.d.ts
  g3n scan --start 7700 --end 7800 --host 127.0.0.1
`;

(async () => {
  const cmd = args._[0];

  if (cmd === "env") {
    generateEnvTypes({
      envFilePath: args.env,
      outputDir: args.out ? path.dirname(args.out) : undefined,
      outputFileName: args.out ? path.basename(args.out) : undefined,
    });
    return;
  }

  if (cmd === "scan") {
    const start: number = args.start ? parseInt(args.start, 10) : 3000;
    const end: number = args.end ? parseInt(args.end, 10) : 4000;
    const host: string = args.host || "127.0.0.1";

    console.log(`🔍 Scan port ${start}-${end} di host ${host} ...`);

    const ports: number[] = Array.from(
      { length: end - start + 1 },
      (_, i) => start + i
    );

    const results: CheckPortResult[] = await Promise.all(
      ports.map((p) => checkPort(p, host))
    );

    results.filter((r) => r.open).forEach((r) => {
      console.log(`✅ Port ${r.port} sedang digunakan`);
    });

    console.log("✅ Selesai");
    return;
  }

  console.error(help);
})();

function checkPort(port: number, host: string): Promise<CheckPortResult> {
  return new Promise((resolve) => {
    const socket = new net.Socket();
    socket.setTimeout(200);

    socket.once("connect", () => {
      socket.destroy();
      resolve({ port, open: true });
    });

    socket.once("timeout", () => {
      socket.destroy();
      resolve({ port, open: false });
    });

    socket.once("error", () => {
      socket.destroy();
      resolve({ port, open: false });
    });

    socket.connect(port, host);
  });
}