//! AbleOS Kernel Entrypoint

use {
    crate::{alloc::string::ToString, arch::logging::SERIAL_CONSOLE, device_tree::DeviceTree},
    clparse::Arguments,
    hbvm::engine::Engine,
    log::{debug, trace},
    spin::{Lazy, Mutex},
    xml::XMLElement,
};

pub fn kmain(cmdline: &str, bootstrap: Option<&'static [u8]>) -> ! {
    debug!("Entered kmain");

    let mut cmdline = cmdline.to_string();
    cmdline.pop();
    cmdline.remove(0);

    let kcmd = Arguments::parse(cmdline.to_string()).unwrap();
    trace!("Cmdline: {kcmd:?}");

    let mut kcl = XMLElement::new("Kernel Command Line");
    for (key, value) in kcmd.arguments {
        kcl.set_attribute(key, value);
    }
    debug!("kernel command line object: {:?}", kcl);

    let bootstrap = bootstrap/*.expect("no bootstrap found")*/;
    match bootstrap {
        Some(bootstrap_mod) => {
            debug!("Bootstrap Module: {:?}", bootstrap_mod);
        }
        None => {
            debug!("No bootstrap module loaded.")
        }
    }
    let dt = DEVICE_TREE.lock();

    log::info!("Device Tree{}", dt);

    let bytes = alloc::vec![0];
    let mut prog = Engine::new(bytes);
    // prog.enviroment_call_table[0] = read_device_tree;
    let _ = prog.run();
    prog.dump();

    // TODO: change this to a driver
    {
        let _buf = [8; 128 * 4];

        let mut sc = SERIAL_CONSOLE.lock();
        loop {
            // TODO: Implement an API for sending and recieving serial stuff
            {
                fn read_ipc_buff() {}
                fn write_ipc_buff() {}
                // TODO: read from the IPC buffer and push to serial stream
                let _msg = read_ipc_buff();
                for byte in 0..0 {
                    sc.send(byte);
                }
            }

            match sc.receive() {
                b'\r' => {
                    sc.send(b'\n');
                }
                byte => {
                    sc.send(byte);
                }
            }
        }
    }
}

pub static DEVICE_TREE: Lazy<Mutex<DeviceTree>> = Lazy::new(|| {
    let dt = DeviceTree::new();
    Mutex::new(dt)
});

#[test_case]
fn trivial_assertion() {
    trace!("trivial assertion... ");
    assert_eq!(1, 1);
    info!("[ok]");
}