# Rumpk Layer 1: The Logic Core
# Markus Maiwald (Architect) | Voxis Forge (AI)
#
# This is the Nim kernel entry point.
# Compiled with --os:standalone --mm:arc

{.push stackTrace: off, lineTrace: off.}

import fiber

# =========================================================
# HAL Imports from Zig (Layer 0)
# =========================================================

proc console_write(p: pointer, len: csize_t) {.importc, cdecl.}
proc rumpk_halt() {.importc, cdecl, noreturn.}

# =========================================================
# Kernel I/O
# =========================================================

proc kprint(s: string) =
  if s.len > 0:
    console_write(unsafeAddr s[0], csize_t(s.len))

proc kprintln(s: string) =
  kprint(s)
  kprint("\n")

# =========================================================
# Panic Handler (Required for --os:standalone)
# =========================================================

proc nimPanic(msg: cstring) {.exportc: "panic", cdecl, noreturn.} =
  kprint("\n[PANIC] ")
  if msg != nil:
    var i = 0
    while msg[i] != '\0':
      var buf: array[1, char]
      buf[0] = msg[i]
      console_write(addr buf[0], 1)
      inc i
  kprint("\n")
  rumpk_halt()

# =========================================================
# Memory Allocator - Provided by Zig L0 (hal/stubs.zig)
# =========================================================

# Zig exports: malloc, free, realloc, calloc
# We just import them for any explicit usage
proc malloc(size: csize_t): pointer {.importc, cdecl.}
proc free(p: pointer) {.importc, cdecl.}
proc realloc(p: pointer, size: csize_t): pointer {.importc, cdecl.}

# =========================================================
# Fiber Test: Ping Pong
# =========================================================

var fiber_a: FiberObject
var stack_a: array[4096, uint8]

var fiber_b: FiberObject
var stack_b: array[4096, uint8]

proc thread_a_entry() {.cdecl.} =
  kprintln("[Fiber A] I am alive! Yielding to B...")
  switch(addr fiber_b)
  kprintln("[Fiber A] I am back! Yielding to B...")
  switch(addr fiber_b)
  kprintln("[Fiber A] Final return. Halting.")
  while true:
    {.emit: "asm volatile(\"wfi\");".}

proc thread_b_entry() {.cdecl.} =
  kprintln("[Fiber B] Hello from B! Yielding to A...")
  switch(addr fiber_a)
  kprintln("[Fiber B] Returned! Yielding to A...")
  switch(addr fiber_a)
  kprintln("[Fiber B] Final return. Halting.")
  while true:
    {.emit: "asm volatile(\"wfi\");".}

# =========================================================
# Kernel Main Entry
# =========================================================

proc kmain() {.exportc, cdecl.} =
  kprintln("╔═══════════════════════════════════════╗")
  kprintln("║     Layer 1: Nim Kernel Alive!        ║")
  kprintln("╚═══════════════════════════════════════╝")
  kprintln("")
  kprintln("[Rumpk L1] Memory: ARC (Deterministic)")
  kprintln("[Rumpk L1] POSIX: None (Hostile)")
  kprintln("[Rumpk L1] Status: OPERATIONAL")
  kprintln("")
  kprintln("[Rumpk L1] The Rubicon is crossed.")
  kprintln("[Rumpk L1] Zig + Nim = Sovereign Metal.")
  kprintln("")
  kprintln("[Rumpk L1] Initializing Fibers...")

  # Initialize Fibers
  fiber_a.name = "Fiber A"
  fiber_b.name = "Fiber B"

  init_fiber(addr fiber_a, thread_a_entry, addr stack_a[0])
  init_fiber(addr fiber_b, thread_b_entry, addr stack_b[0])

  # Jump into the matrix
  kprintln("[Kernel] Switching to Fiber A...")
  kprintln("")
  switch(addr fiber_a)

  # We should never get here unless Fiber A switches back to Main
  nimPanic("Main thread returned!")

{.pop.}