use alloc::vec::Vec;

pub fn rhai_shell() {
    let mut engine = rhai::Engine::new();

    engine.on_print(|x| println!("{}", x));

    engine.on_debug(|x, src, pos| {
        let src = src.unwrap_or("unknown");
        println!("DEBUG: {} at {:?}: {}", src, pos, x);
        debug!("{} at {:?}: {}", src, pos, x);
    });

    engine.register_fn("afetch", afetch);
    engine.register_fn("set_hostname", set_hostname);
    engine.register_fn("shutdown", shutdown);

    let mut scope = rhai::Scope::new();

    let mut buf = String::new();
    print!("> ");

    loop {
        match x86_64::instructions::interrupts::without_interrupts(|| KEYBUFF.lock().pop()) {
            Some('\n') => {
                match engine.eval_with_scope::<rhai::Dynamic>(&mut scope, &buf) {
                    Ok(o) => println!("{o}"),
                    Err(e) => println!("Eval error: {e}"),
                };

                buf.clear();
                print!("> ");
            }
            Some('\u{0008}') => {
                buf.pop();
            }
            Some(chr) => buf.push(chr),
            None => (),
        }
    }
}
lazy_static::lazy_static!(
    pub static ref KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(
        Vec::new())
    ;
);

use alloc::string::{String, ToString};
use x86_64::instructions::interrupts::{disable, enable};

use crate::{
    arch::{shutdown, sloop},
    kmain::{tick, TICK},
    systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
    KERNEL_STATE,
};

pub fn afetch() {
    let kstate = KERNEL_STATE.lock();
    use core::sync::atomic::Ordering::*;

    disable();
    let tick_time = TICK.load(Relaxed);
    enable();

    println!("OS: AbleOS");
    println!("Host: {}", kstate.hostname);
    println!("Kernel: AKern-{}-v{}", RELEASE_TYPE, KERNEL_VERSION);
    println!("Uptime: {}", tick_time);

    drop(kstate);
}
pub fn set_hostname(name: String) {
    let mut kstate = KERNEL_STATE.lock();
    kstate.hostname = name;
}