(* Boot - Arvo Kernel Boot System
 *
 * This module handles:
 * - Loading pill files (jammed Arvo kernels)
 * - Parsing pill structure
 * - Initial boot sequence
 *
 * Pill Structure:
 * - A pill is a jammed noun containing the Arvo kernel
 * - Format varies, but typically: [kernel-gate initial-state]
 * - Or just the kernel-gate itself
 *)

(* Boot error *)
type error =
  | FileNotFound of string
  | InvalidPill of string
  | BootFailed of string

(* Pill type *)
type pill = {
  kernel: Noun.noun;        (* The Arvo kernel gate *)
  boot_ova: Noun.noun list; (* Initial events to process *)
}

(* Load pill from file using Eio
 *
 * Steps:
 * 1. Read jammed pill file
 * 2. Cue to get kernel noun
 * 3. Parse pill structure
 *)
let load_pill ~fs pill_path =
  try
    Printf.printf "[Boot] Loading pill from %s...\n%!" pill_path;

    (* Read pill file *)
    let file_path = Eio.Path.(fs / pill_path) in
    let pill_bytes = Eio.Path.load file_path |> Bytes.of_string in

    Printf.printf "[Boot] Pill file: %d bytes\n%!" (Bytes.length pill_bytes);

    (* Cue the pill to get kernel noun *)
    let kernel_noun = Serial.cue pill_bytes in

    Printf.printf "[Boot] Pill cued successfully\n%!";

    (* For now, treat the entire pill as the kernel
     * In a real implementation, we'd parse the structure:
     *   - Check if it's a cell with [kernel boot-events]
     *   - Or just a single kernel gate
     *)
    Ok {
      kernel = kernel_noun;
      boot_ova = [];  (* No boot events for now *)
    }

  with
  | Sys_error msg ->
      Error (FileNotFound msg)
  | e ->
      Error (InvalidPill (Printexc.to_string e))

(* Create a minimal fake pill for testing
 *
 * This creates a trivial kernel that's just an atom.
 * In reality, the kernel is a huge compiled gate, but for
 * testing we can use this simple version.
 *)
let fake_pill () = {
  kernel = Noun.atom 0;  (* Minimal kernel - just 0 *)
  boot_ova = [];
}

(* Boot Arvo from a pill
 *
 * Steps:
 * 1. Set kernel state to pill's kernel
 * 2. Process boot events if any
 * 3. Initialize event counter to 0
 *)
let boot_from_pill state pill =
  Printf.printf "[Boot] Initializing Arvo kernel...\n%!";

  (* Set kernel state *)
  State.boot state pill.kernel;

  (* Process boot events if any *)
  List.iteri (fun i _ovum ->
    Printf.printf "[Boot] Processing boot event %d\n%!" i;
    (* In real implementation: State.poke state ovum *)
  ) pill.boot_ova;

  Printf.printf "[Boot] ✓ Arvo kernel booted!\n%!";
  Ok ()

(* Boot from pill file - convenience function *)
let boot_from_file ~fs state pill_path =
  match load_pill ~fs pill_path with
  | Error err ->
      let msg = match err with
        | FileNotFound s -> "File not found: " ^ s
        | InvalidPill s -> "Invalid pill: " ^ s
        | BootFailed s -> "Boot failed: " ^ s
      in
      Printf.printf "[Boot] Error: %s\n%!" msg;
      Error msg

  | Ok pill ->
      boot_from_pill state pill

(* Create minimal boot for testing (no pill file needed) *)
let boot_fake state =
  Printf.printf "[Boot] Creating fake minimal kernel...\n%!";
  let pill = fake_pill () in
  boot_from_pill state pill