(* 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 (%.1f MB)\n%!"
      (Bytes.length pill_bytes)
      (float_of_int (Bytes.length pill_bytes) /. 1024.0 /. 1024.0);

    Printf.printf "[Boot] Cuing pill (this may take a while)...\n%!";
    let start = Unix.gettimeofday () in

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

    let elapsed = Unix.gettimeofday () -. start in
    Printf.printf "[Boot] Pill cued successfully in %.2f seconds\n%!" elapsed;

    (* 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

(* u3v_life: Execute lifecycle formula on ivory core
 *
 * From C Vere vortex.c:26:
 *   u3_noun lyf = u3nt(2, u3nc(0, 3), u3nc(0, 2));  // [2 [0 3] [0 2]]
 *   u3_noun gat = u3n_nock_on(eve, lyf);
 *   u3_noun cor = u3k(u3x_at(7, gat));
 *
 * The lifecycle formula [2 [0 3] [0 2]] means:
 * - Opcode 2: nock on computed subject
 * - [0 3] gets the formula at slot 3
 * - [0 2] gets the sample at slot 2
 * This calls the lifecycle arm, then we extract slot 7 (context)
 *)
let life eve =
  try
    (* Build lifecycle formula: [2 [0 3] [0 2]] *)
    let lyf = Noun.cell (Noun.atom 2)
      (Noun.cell
        (Noun.cell (Noun.atom 0) (Noun.atom 3))
        (Noun.cell (Noun.atom 0) (Noun.atom 2))) in

    Printf.printf "[Boot] Running lifecycle formula [2 [0 3] [0 2]]...\n%!";

    (* Debug: check what's in slot 2 and slot 3 *)
    (try
      let slot2 = Noun.slot (Z.of_int 2) eve in
      let slot3 = Noun.slot (Z.of_int 3) eve in
      Printf.printf "[Boot]   Slot 2: %s\n%!"
        (if Noun.is_cell slot2 then "cell" else "atom");
      Printf.printf "[Boot]   Slot 3: %s\n%!"
        (if Noun.is_cell slot3 then "cell" else "atom");
    with _ -> ());

    (* Run lifecycle formula on ivory core *)
    let gat =
      try
        Nock.nock_on eve lyf
      with e ->
        Printf.printf "[Boot] ✗ Nock failed during lifecycle: %s\n%!"
          (Printexc.to_string e);
        raise e
    in

    Printf.printf "[Boot] ✓ Lifecycle formula completed\n%!";
    Printf.printf "[Boot] Result is: %s\n%!"
      (if Noun.is_cell gat then "cell" else "atom");

    (* Extract slot 7 (the context) from resulting gate *)
    let cor =
      try
        Noun.slot (Z.of_int 7) gat
      with e ->
        Printf.printf "[Boot] ✗ Failed to extract slot 7: %s\n%!"
          (Printexc.to_string e);
        Printf.printf "[Boot]   (Result type: %s)\n%!"
          (if Noun.is_cell gat then "cell" else "atom");
        raise e
    in

    Printf.printf "[Boot] ✓ Extracted slot 7 from result\n%!";
    cor

  with e ->
    Printf.printf "[Boot] ✗ u3v_life failed: %s\n%!" (Printexc.to_string e);
    raise e

(* Boot from ivory pill - the lightweight boot sequence
 *
 * Ivory pills have structure: ["ivory" core]
 * The core contains a lifecycle formula that must be executed
 *)
let boot_ivory ~fs state pill_path =
  Printf.printf "[Boot] Booting from ivory pill...\n%!";

  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 ->
      (* Check if pill has ivory tag *)
      if not (Noun.is_cell pill.kernel) then
        Error "Ivory pill must be a cell"
      else begin
        let hed = Noun.head pill.kernel in
        let tal = Noun.tail pill.kernel in

        (* Check for "ivory" tag *)
        (* "ivory" as cord (little-endian): 0x79726f7669 = 521610950249 *)
        let ivory_tag = Z.of_string "521610950249" in

        match hed with
        | Noun.Atom z when Z.equal z ivory_tag ->
            Printf.printf "[Boot] ✓ Found ivory tag\n%!";
            Printf.printf "[Boot] Running lifecycle formula...\n%!";

            (try
              let start = Unix.gettimeofday () in
              let core = life tal in
              let elapsed = Unix.gettimeofday () -. start in

              Printf.printf "[Boot] ✓ Lifecycle completed in %.4fs\n%!" elapsed;
              Printf.printf "[Boot] Setting Arvo core...\n%!";

              State.boot state core;
              Printf.printf "[Boot] ✓ Ivory pill booted!\n%!";
              Ok ()
            with e ->
              Error ("Lifecycle failed: " ^ Printexc.to_string e))

        | _ ->
            Printf.printf "[Boot] Warning: No ivory tag found, trying regular boot...\n%!";
            boot_from_pill state pill
      end