#![no_std]
#![no_main]
#![feature(allocator_api)]
#![allow(unused_imports)]

mod arch;
mod boot;
mod log;
mod memory;
mod panic;
mod params;
mod process;
mod resources;

use crate::arch::current;
use crate::boot::*;
use crate::log::*;
use crate::memory::alloc::{self, format, string::String, vec};
use crate::params::*;

use acpi::{AcpiResult, AcpiTable};

#[unsafe(no_mangle)]
unsafe extern "C" fn main() -> ! {
    // Assert supported bootloader version
    assert!(BASE_REVISION.is_supported());

    // Local logger fn
    fn log(level: LogLevel, msg: &str) {
        LOGGER.lock().log(level, msg);
    }

    // Set up some stuff based on kernel params if we get any
    if let Some(kernel_file_response) = FILE_REQUEST.get_response() {
        let kernel_parameters = get_kernel_params(kernel_file_response.file().cmdline());

        // Set up logging level from params
        if let Some(level) = kernel_parameters.get("-loglevel") {
            if let Ok(parsed_level) = LogLevel::try_from(level.as_str()) {
                LOGGER.lock().level = parsed_level;
            }
        }
        // Add subscribers to logger
        if let Some(device) = kernel_parameters.get("-logdev") {
            let log_device_list: vec::Vec<&str> = device.split(',').collect();
            if log_device_list.contains(&"display") {
                // Append display console to log subs
            }
            if log_device_list.contains(&"serial") {
                // Append serial console to log subs
            }
            log(LogLevel::Info, "Boot: Configured kernel logging devices.")
        }
        log(
            LogLevel::Info,
            &format!(
                "Boot: Kernel cmdline: {}",
                String::from_utf8_lossy(kernel_file_response.file().cmdline())
            ),
        );
        log(
            LogLevel::Info,
            &format!(
                "Boot: Kernel file path: {}",
                String::from_utf8_lossy(kernel_file_response.file().path())
            ),
        );
    }
    log(
        LogLevel::Info,
        "Boot: Log devices configured. Booting `gila`.",
    );
    log(LogLevel::Info, "Boot: Trans Rights!");

    let _smp_response = SMP_REQUEST.get_response();
    match _smp_response {
        None => log(
            LogLevel::Error,
            "SMP: bootloader response not received. Multiprocessing is disabled.",
        ),
        Some(resp) => {
            log(
                LogLevel::Info,
                "SMP: bootloader response received. Multiprocessing enabled.",
            );
            log(
                LogLevel::Info,
                &format!("SMP: {} CPUs found.", resp.cpus().len()),
            );
        }
    }

    let _rsdp_response = RSDP_REQUEST.get_response();

    loop {
        unsafe {
            arch::current::asm::halt();
        }
    }
}