// Permissions granulari Deno
deno run \
  --allow-read=/etc,/home \
  --allow-write=/tmp \
  --allow-net=127.0.0.1:8080 \
  eggs.ts

// TypeScript nativo (no transpilation)
// ESM imports standard
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
import { Command } from "https://deno.land/x/cliffy@v1.0.0/command/mod.ts";

// Già funzionanti con Deno 2.0
import axios from "npm:axios@^1.7.9";
import yaml from "npm:js-yaml@^4.1.0";
import Mustache from "npm:mustache@^4.2.0";
import chalk from "npm:chalk@^5.4.0";
import inquirer from "npm:inquirer@^9.3.7";

// OCLIF → Cliffy
import { Command } from "https://deno.land/x/cliffy@v1.0.0/command/mod.ts";

// Ink → Cliffy prompts + custom TUI
import { Input, Confirm, Progress } from "https://deno.land/x/cliffy@v1.0.0/prompt/mod.ts";

// node-static → Deno.serve nativo
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

// File operations
await Deno.writeTextFile("config.yaml", data);
const content = await Deno.readTextFile("config.yaml");

// Process execution
const command = new Deno.Command("ls", { args: ["-la"] });
const { code, stdout } = await command.output();

// HTTP server
serve({ port: 8080 }, (req) => new Response("Hello"));

// deps.ts - Centralizza tutte le dipendenze esterne
export { Command, EnumType } from "https://deno.land/x/cliffy@v1.0.0/command/mod.ts";
export { Input, Confirm, Select, Progress } from "https://deno.land/x/cliffy@v1.0.0/prompt/mod.ts";
export { Table } from "https://deno.land/x/cliffy@v1.0.0/table/mod.ts";
export { colors } from "https://deno.land/x/cliffy@v1.0.0/ansi/colors.ts";

// Standard library
export { serve } from "https://deno.land/std@0.208.0/http/server.ts";
export { parse as parseYaml, stringify as stringifyYaml } from "https://deno.land/std@0.208.0/yaml/mod.ts";
export { join, dirname, basename } from "https://deno.land/std@0.208.0/path/mod.ts";
export { ensureDir, exists } from "https://deno.land/std@0.208.0/fs/mod.ts";

// NPM compatibility per dipendenze critiche
export { default as axios } from "npm:axios@^1.7.9";
export { default as Mustache } from "npm:mustache@^4.2.0";

// PRIMA: OCLIF Command
import { Command, Flags } from '@oclif/core';

export default class Produce extends Command {
  static description = 'produce a live image from your system';
  
  static flags = {
    clone: Flags.boolean({
      char: 'c',
      description: 'clone mode'
    }),
    cryptedclone: Flags.boolean({
      char: 'C', 
      description: 'crypted clone mode'
    }),
    max: Flags.boolean({
      char: 'm',
      description: 'max compression'
    })
  };

  async run(): Promise<void> {
    const { flags } = await this.parse(Produce);
    
    if (flags.clone) {
      await this.produceClone();
    } else if (flags.cryptedclone) {
      await this.produceCryptedClone();
    } else {
      await this.produceStandard();
    }
  }
}

// DOPO: Cliffy Command
import { Command } from "../deps.ts";
import { ProduceService } from "../services/produce.ts";

export const produceCommand = new Command()
  .name("produce")
  .description("produce a live image from your system")
  .option("-c, --clone", "Clone mode")
  .option("-C, --crypted-clone", "Crypted clone mode") 
  .option("-m, --max", "Max compression")
  .option("--basename <name:string>", "Base name for ISO")
  .option("--theme <theme:string>", "Theme for live CD")
  .action(async (options) => {
    const service = new ProduceService();
    
    if (options.cryptedClone) {
      await service.produceCryptedClone(options);
    } else if (options.clone) {
      await service.produceClone(options);
    } else {
      await service.produceStandard(options);
    }
  });

// src/main.ts - Entry point principale
import { Command } from "./deps.ts";
import { produceCommand } from "./commands/produce.ts";
import { installCommand } from "./commands/install.ts";
import { configCommand } from "./commands/config.ts";
import { statusCommand } from "./commands/status.ts";
import { cuckooCommand } from "./commands/cuckoo.ts";

const cli = new Command()
  .name("eggs")
  .version("11.0.0")
  .description("A remaster system tool for Linux distributions")
  .globalOption("--verbose", "Enable verbose logging")
  .globalOption("--dry-run", "Show what would be done without executing")
  .command("produce", produceCommand)
  .command("install", installCommand)
  .command("krill", installCommand) // Alias
  .command("config", configCommand)
  .command("status", statusCommand) 
  .command("cuckoo", cuckooCommand);

if (import.meta.main) {
  await cli.parse(Deno.args);
}

// src/services/config.ts
import { parseYaml, stringifyYaml, ensureDir, join } from "../deps.ts";

export interface EggsConfig {
  snapshot: {
    dir: string;
    prefix: string;
    excludes: string[];
  };
  distro: {
    familyId: string;
    codenameLikeId: string;
    distroId: string;
  };
  user: {
    liveUser: string;
    liveUserFullname: string;
  };
}

export class ConfigService {
  private configPath = "/etc/penguins-eggs.d/eggs.yaml";
  
  async load(): Promise<EggsConfig> {
    try {
      const content = await Deno.readTextFile(this.configPath);
      return parseYaml(content) as EggsConfig;
    } catch (error) {
      if (error instanceof Deno.errors.NotFound) {
        return this.getDefaultConfig();
      }
      throw error;
    }
  }
  
  async save(config: EggsConfig): Promise<void> {
    const dir = dirname(this.configPath);
    await ensureDir(dir);
    
    const yaml = stringifyYaml(config);
    await Deno.writeTextFile(this.configPath, yaml);
  }
  
  private getDefaultConfig(): EggsConfig {
    return {
      snapshot: {
        dir: "/home/eggs",
        prefix: "",
        excludes: []
      },
      distro: {
        familyId: "debian", 
        codenameLikeId: "bookworm",
        distroId: "debian"
      },
      user: {
        liveUser: "live",
        liveUserFullname: "Live User"
      }
    };
  }
}

// src/services/shell.ts
export class ShellService {
  async exec(cmd: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
    const command = new Deno.Command(cmd[0], {
      args: cmd.slice(1),
      stdout: "piped",
      stderr: "piped"
    });
    
    const { code, stdout, stderr } = await command.output();
    
    return {
      code,
      stdout: new TextDecoder().decode(stdout),
      stderr: new TextDecoder().decode(stderr)
    };
  }
  
  async execLive(cmd: string[]): Promise<number> {
    const command = new Deno.Command(cmd[0], {
      args: cmd.slice(1),
      stdout: "inherit",
      stderr: "inherit"
    });
    
    const { code } = await command.output();
    return code;
  }
  
  async execWithProgress(cmd: string[], onProgress?: (line: string) => void): Promise<void> {
    const command = new Deno.Command(cmd[0], {
      args: cmd.slice(1),
      stdout: "piped",
      stderr: "piped"
    });
    
    const child = command.spawn();
    
    if (onProgress) {
      const reader = child.stdout.getReader();
      const decoder = new TextDecoder();
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        const text = decoder.decode(value);
        const lines = text.split('\n');
        lines.forEach(line => line.trim() && onProgress(line));
      }
    }
    
    await child.status;
  }
}

// src/services/pxe-server.ts
import { serve } from "../deps.ts";
import { join } from "../deps.ts";

export class PXEServer {
  private isoPath: string;
  private port = 8080;
  
  constructor(isoPath: string) {
    this.isoPath = isoPath;
  }
  
  async start(): Promise<void> {
    console.log(`🐦 Cuckoo PXE server starting on port ${this.port}`);
    
    await serve({ port: this.port }, async (req) => {
      const url = new URL(req.url);
      
      // Serve ISO files
      if (url.pathname.startsWith('/iso/')) {
        return await this.serveISO(url.pathname);
      }
      
      // Serve PXE boot files
      if (url.pathname.startsWith('/pxe/')) {
        return await this.servePXEFile(url.pathname);
      }
      
      // iPXE boot script
      if (url.pathname === '/boot.ipxe') {
        return new Response(this.generateBootScript(), {
          headers: { 'Content-Type': 'text/plain' }
        });
      }
      
      return new Response('Not Found', { status: 404 });
    });
  }
  
  private async serveISO(path: string): Promise<Response> {
    try {
      const filePath = join(this.isoPath, path.replace('/iso/', ''));
      const file = await Deno.readFile(filePath);
      
      return new Response(file, {
        headers: {
          'Content-Type': 'application/octet-stream',
          'Content-Length': file.length.toString()
        }
      });
    } catch {
      return new Response('File not found', { status: 404 });
    }
  }
  
  private generateBootScript(): string {
    return `#!ipxe
echo Starting Penguins Eggs PXE Boot
echo
menu Please choose boot option
item live Boot Live System  
item install Install System
item local Boot Local System
choose option

:live
echo Booting live system...
kernel http://\${next-server}/pxe/vmlinuz boot=live
initrd http://\${next-server}/pxe/initrd.img
boot

:install
echo Starting installation...
kernel http://\${next-server}/pxe/vmlinuz boot=live eggs-install
initrd http://\${next-server}/pxe/initrd.img  
boot

:local
echo Booting local system...
exit
`;
  }
}

// src/packaging/debian-builder.ts
export interface DebianPackageConfig {
  name: string;
  version: string;
  architecture: string;
  description: string;
  maintainer: string;
  dependencies: string[];
  binaryPath: string;
  installDir: string;
  scripts: {
    postinst?: string;
    prerm?: string;
    postrm?: string;
    preinst?: string;
  };
}

export class DebianBuilder {
  async build(config: DebianPackageConfig): Promise<string> {
    const tempDir = await Deno.makeTempDir({ prefix: "deb-build-" });
    const debianDir = join(tempDir, "DEBIAN");
    
    // Create DEBIAN directory structure
    await ensureDir(debianDir);
    await ensureDir(join(tempDir, config.installDir));
    
    // Generate control file
    const control = this.generateControl(config);
    await Deno.writeTextFile(join(debianDir, "control"), control);
    
    // Copy binary
    await Deno.copyFile(config.binaryPath, join(tempDir, config.installDir, "eggs"));
    
    // Add lifecycle scripts
    for (const [script, content] of Object.entries(config.scripts)) {
      if (content) {
        const scriptPath = join(debianDir, script);
        await Deno.writeTextFile(scriptPath, content);
        await Deno.chmod(scriptPath, 0o755);
      }
    }
    
    // Build package
    const packageName = `${config.name}_${config.version}_${config.architecture}.deb`;
    const shell = new ShellService();
    
    await shell.exec([
      "fakeroot", "dpkg-deb", "--build", tempDir, packageName
    ]);
    
    // Cleanup
    await Deno.remove(tempDir, { recursive: true });
    
    return packageName;
  }
  
  private generateControl(config: DebianPackageConfig): string {
    return `Package: ${config.name}
Version: ${config.version}
Architecture: ${config.architecture}
Maintainer: ${config.maintainer}
Description: ${config.description}
Depends: ${config.dependencies.join(', ')}
Section: utils
Priority: optional
`;
  }
}

// scripts/build-all.ts
import { DebianBuilder } from "../src/packaging/debian-builder.ts";

const targets = [
  { arch: "amd64", target: "x86_64-unknown-linux-gnu" },
  { arch: "arm64", target: "aarch64-unknown-linux-gnu" },
  { arch: "i386", target: "i686-unknown-linux-gnu" }
];

async function buildAll() {
  const version = "11.0.0";
  
  for (const { arch, target } of targets) {
    console.log(`🔨 Building for ${arch}...`);
    
    // Compile binary
    const binaryName = `eggs-${arch}`;
    const command = new Deno.Command("deno", {
      args: [
        "compile",
        "--allow-all",
        `--target=${target}`,
        `--output=dist/${binaryName}`,
        "src/main.ts"
      ]
    });
    
    await command.output();
    
    // Build Debian package
    const builder = new DebianBuilder();
    const packageName = await builder.build({
      name: "penguins-eggs",
      version,
      architecture: arch,
      description: "A remaster system tool for Linux distributions",
      maintainer: "Piero Proietti <pieroproietti@gmail.com>",
      dependencies: [],
      binaryPath: `dist/${binaryName}`,
      installDir: "usr/bin",
      scripts: {
        postinst: await Deno.readTextFile("debian/postinst"),
        prerm: await Deno.readTextFile("debian/prerm")
      }
    });
    
    console.log(`✅ Created ${packageName}`);
  }
}

if (import.meta.main) {
  await buildAll();
}

// src/ui/progress.ts
import { Progress, colors } from "../deps.ts";

export class EggsProgress {
  private progress?: ReturnType<typeof Progress.render>;
  
  start(message: string, total = 100): void {
    this.progress = Progress.render({
      title: `🥚 ${message}`,
      total,
      complete: colors.green("█"),
      incomplete: colors.gray("░"),
      display: ":title :percent :bar :time"
    });
  }
  
  update(current: number, message?: string): void {
    if (this.progress) {
      this.progress.render(current);
      if (message) {
        console.log(`   ${colors.cyan("→")} ${message}`);
      }
    }
  }
  
  finish(message = "Completed"): void {
    if (this.progress) {
      this.progress.end();
      console.log(`${colors.green("✅")} ${message}\n`);
    }
  }
}

// src/commands/dad.ts
import { Command, Input, Select, Confirm, colors } from "../deps.ts";
import { ConfigService } from "../services/config.ts";

export const dadCommand = new Command()
  .name("dad")
  .description("ask help from daddy - TUI configuration helper")
  .option("--clean", "Remove old configuration")
  .option("--default", "Reset to default values")
  .action(async (options) => {
    console.log(colors.blue(`
🐧 Penguins Eggs Configuration Helper (Dad)
Let's configure your eggs environment!
`));
    
    const configService = new ConfigService();
    
    if (options.clean) {
      const confirm = await Confirm.prompt("Remove existing configuration?");
      if (confirm) {
        // Remove config logic
      }
    }
    
    if (options.default) {
      const config = configService.getDefaultConfig();
      await configService.save(config);
      console.log(colors.green("✅ Configuration reset to defaults"));
      return;
    }
    
    // Interactive configuration
    const liveUser = await Input.prompt({
      message: "Live user name:",
      default: "live"
    });
    
    const liveUserFullname = await Input.prompt({
      message: "Live user full name:",
      default: "Live User"
    });
    
    const snapshotDir = await Input.prompt({
      message: "Snapshot directory:",
      default: "/home/eggs"
    });
    
    const compression = await Select.prompt({
      message: "Default compression:",
      options: [
        { name: "Fast (zstd)", value: "fast" },
        { name: "Standard (xz)", value: "standard" },
        { name: "Max (xz)", value: "max" }
      ]
    });
    
    const config = {
      snapshot: {
        dir: snapshotDir,
        prefix: "",
        excludes: [],
        compression
      },
      user: {
        liveUser,
        liveUserFullname
      }
    };
    
    await configService.save(config);
    console.log(colors.green("✅ Configuration saved successfully!"));
  });

// src/commands/status.ts (OCLIF Version)
import { Command, Flags } from '@oclif/core';
import * as fs from 'fs';
import * as os from 'os';

export default class Status extends Command {
  static description = 'show eggs status and configuration';
  
  static flags = {
    verbose: Flags.boolean({char: 'v', description: 'verbose output'})
  };

  async run(): Promise<void> {
    const {flags} = await this.parse(Status);
    
    // System info
    const platform = os.platform();
    const arch = os.arch();
    const release = os.release();
    
    // Config check
    const configExists = fs.existsSync('/etc/penguins-eggs.d/eggs.yaml');
    
    this.log(`Platform: ${platform}`);
    this.log(`Architecture: ${arch}`);
    this.log(`Kernel: ${release}`);
    this.log(`Configuration: ${configExists ? 'Found' : 'Missing'}`);
    
    if (flags.verbose) {
      // Additional verbose info
      this.log(`Memory: ${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`);
      this.log(`CPUs: ${os.cpus().length}`);
      this.log(`Uptime: ${Math.round(os.uptime() / 3600)}h`);
    }
  }
}

// deno-src/commands/status.ts (Deno/Cliffy Version)
import { Command, colors, Table } from "../deps.ts";
import { ConfigService } from "../services/config.ts";

export const statusCommand = new Command()
  .name("status")
  .description("show eggs status and configuration")
  .option("-v, --verbose", "Enable verbose output")
  .action(async (options) => {
    console.log(colors.cyan(`
🐧 Penguins Eggs System Status
═══════════════════════════════`));

    // System Information
    const systemInfo = await getSystemInfo();
    const configService = new ConfigService();
    
    // Check configuration
    let configStatus = "❌ Missing";
    let config = null;
    
    try {
      config = await configService.load();
      configStatus = "✅ Found";
    } catch {
      configStatus = "❌ Missing";
    }

    // Create status table
    const table = new Table()
      .header(["Property", "Value"])
      .body([
        ["Platform", `${systemInfo.os} ${systemInfo.arch}`],
        ["Kernel", systemInfo.kernel],
        ["Distribution", systemInfo.distro],
        ["Configuration", configStatus],
        ["Eggs Version", "11.0.0-deno"],
        ["Runtime", `Deno ${Deno.version.deno}`],
      ]);

    console.log(table.toString());

    // Verbose information
    if (options.verbose && config) {
      console.log(colors.cyan("\n📊 Detailed Configuration"));
      console.log("─".repeat(30));
      
      const configTable = new Table()
        .header(["Setting", "Value"])
        .body([
          ["Snapshot Dir", config.snapshot.dir],
          ["Live User", config.user.liveUser],
          ["Live User Name", config.user.liveUserFullname],
          ["Distro Family", config.distro.familyId],
          ["Codename", config.distro.codenameLikeId],
        ]);
      
      console.log(configTable.toString());
      
      // System resources
      const resources = await getSystemResources();
      console.log(colors.cyan("\n🖥️  System Resources"));
      console.log("─".repeat(20));
      console.log(`Memory: ${resources.totalMemory}GB total, ${resources.freeMemory}GB free`);
      console.log(`Storage: ${resources.freeSpace}GB available in ${config.snapshot.dir}`);
      console.log(`Load Average: ${resources.loadAverage}`);
    }

    // Health checks
    await performHealthChecks();
  });

async function getSystemInfo() {
  const decoder = new TextDecoder();
  
  // Get OS info
  const osRelease = await Deno.readTextFile("/etc/os-release").catch(() => "");
  const distro = osRelease.match(/PRETTY_NAME="([^"]+)"/)?.[1] || "Unknown";
  
  // Get kernel version
  const unameResult = await new Deno.Command("uname", { 
    args: ["-r"], 
    stdout: "piped" 
  }).output();
  const kernel = decoder.decode(unameResult.stdout).trim();
  
  return {
    os: Deno.build.os,
    arch: Deno.build.arch,
    kernel,
    distro
  };
}

async function getSystemResources() {
  const decoder = new TextDecoder();
  
  // Get memory info
  const meminfo = await Deno.readTextFile("/proc/meminfo");
  const totalMatch = meminfo.match(/MemTotal:\s+(\d+)/);
  const freeMatch = meminfo.match(/MemAvailable:\s+(\d+)/);
  
  const totalMemory = totalMatch ? Math.round(parseInt(totalMatch[1]) / 1024 / 1024) : 0;
  const freeMemory = freeMatch ? Math.round(parseInt(freeMatch[1]) / 1024 / 1024) : 0;
  
  // Get load average
  const loadavg = await Deno.readTextFile("/proc/loadavg");
  const loadAverage = loadavg.split(" ")[0];
  
  // Get disk space for snapshot directory
  const dfResult = await new Deno.Command("df", {
    args: ["-h", "/home"],
    stdout: "piped"
  }).output();
  const dfOutput = decoder.decode(dfResult.stdout);
  const freeSpace = dfOutput.split("\n")[1]?.split(/\s+/)[3] || "Unknown";
  
  return {
    totalMemory,
    freeMemory,
    loadAverage,
    freeSpace: freeSpace.replace("G", "")
  };
}

async function performHealthChecks() {
  console.log(colors.cyan("\n🔍 Health Checks"));
  console.log("─".repeat(15));
  
  const checks = [
    {
      name: "Root privileges",
      check: () => Deno.getUid() === 0,
      required: true
    },
    {
      name: "Squashfs tools",
      check: async () => {
        try {
          await new Deno.Command("mksquashfs", { args: ["-version"] }).output();
          return true;
        } catch {
          return false;
        }
      },
      required: true
    },
    {
      name: "ISO tools",
      check: async () => {
        try {
          await new Deno.Command("xorriso", { args: ["-version"] }).output();
          return true;
        } catch {
          return false;
        }
      },
      required: true
    },
    {
      name: "LUKS support",
      check: async () => {
        try {
          await new Deno.Command("cryptsetup", { args: ["--version"] }).output();
          return true;
        } catch {
          return false;
        }
      },
      required: false
    }
  ];
  
  for (const check of checks) {
    const result = typeof check.check === 'function' 
      ? await check.check() 
      : check.check;
    
    const status = result ? "✅" : check.required ? "❌" : "⚠️";
    const color = result ? colors.green : check.required ? colors.red : colors.yellow;
    
    console.log(`${status} ${color(check.name)}`);
  }
}