use crate::holeybytes::{kernel_services::block_read, Vm};

#[derive(Debug)]
pub enum LogError {
    InvalidLogFormat,
}
use log::Record;

pub fn log_msg_handler(_vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
    let msg_vec = block_read(mem_addr, length);

    use log::Level::*;
    let log_level = match msg_vec[0] {
        0 | 48 => Error,
        1 | 49 => Warn,
        2 | 50 => Info,
        3 | 51 => Debug,
        4 | 52 => Trace,
        _ => {
            return Err(LogError::InvalidLogFormat);
        }
    };
    if log_level > log::max_level() {
        return Ok(());
    }
    let strptr = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap());
    let strlen = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap()) as usize;

    let str = block_read(strptr, strlen);

    let file_name = "None";
    let line_number = 0;

    match core::str::from_utf8(&str) {
        Ok(strr) => {
            log::logger().log(
                &Record::builder()
                    .args(format_args!("{}", strr))
                    .level(log_level)
                    .target("Userspace")
                    .file(Some(file_name))
                    .line(Some(line_number))
                    .module_path(Some(&file_name))
                    .build(),
            );
        }

        Err(e) => {
            log::error!("{:?}", e);
        }
    }

    Ok(())
}