#![allow(clippy::empty_loop)]

use alloc::format;

use crate::relib::network::socket::Socket;

use {
    crate::{
        arch::{drivers::graphics::GraphicsBuffer, init, sloop},
        driver_traits::graphics::Graphics,
        experiments::{
            info::master,
            systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
        },
        log::LOG_STATE,
        relib::math::rand::RAND_HANDLE,
        scheduler::{test_fn, Thread, ThreadList},
        vga_e,
    },
    alloc::{
        string::{String, ToString},
        vec,
    },
    lazy_static::lazy_static,
};

#[no_mangle]
#[allow(unconditional_recursion)]
pub extern "C" fn stack_overflow() -> u8 {
    stack_overflow();
    // meme number
    69 // NOTE: Any specific reason for this number aside from memes?
}

lazy_static! {
    pub static ref KEY_BUFFER: spin::Mutex<String> = spin::Mutex::new("".to_string());
    pub static ref THREAD_LIST: spin::Mutex<ThreadList> = spin::Mutex::new(vec![]);
    pub static ref TICK: spin::Mutex<u64> = spin::Mutex::new(0);
}

#[no_mangle]
pub fn kernel_main() -> ! {
    if false {
        LOG_STATE.lock().info = false;
        LOG_STATE.lock().trace = false;
        LOG_STATE.lock().debug = false;
    }

    init::init();

    {
        let mut a_thread = Thread::new();

        a_thread.new_task(test_fn);
        a_thread.new_task(test_fn);
        THREAD_LIST.lock().push(a_thread);
        GraphicsBuffer::draw();
        GraphicsBuffer::hide_cursor();
    }

    crate::wasm::evaluate();

    {
        info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
        info!(
            "Brand String: {:?}",
            master().unwrap().brand_string().unwrap()
        );
        if false {
            println!("$PINK$Hi$RED$ from$GREEN$ able!$RESET$");
            println!("$RED$hi$RESET$");
        }
    }
    {
        use crate::relib::network::socket::SimpleSock;
        use crate::utils::type_of;
        let mut xyz = SimpleSock::new();
        xyz.write(vec![0, 0, 1, 0]);
        xyz.close();

        println!("type of socket: {:?}", type_of(&xyz));
        println!("contents: {:?}", &xyz.read());

        println!("length: {:?}", xyz.read().len());
        drop(xyz);
    }

    {
        use pretty_hex::*;

        let v = vec![222, 173, 190, 239, 202, 254, 32, 24];
        assert_eq!(simple_hex(&v), format!("{}", v.hex_dump()));

        println!("{}", v.hex_dump());
    }

    //

    info!("新着情報");

    print!("$GREEN$able$RESET$@$LIGHTBLUE$stAble$ $RED$->$RESET$");
    vga_e::draw_q();
    // stack_overflow();

    sloop()
}

/// called by arch specific timers to tick up all kernel related functions
pub fn tick() {
    let mut data = TICK.lock();
    *data += 1;
    RAND_HANDLE.lock().seed_entropy_timer(*data);

    // println!("{}", *data);
    crate::kernel_state::KERNEL_STATE.lock().update_state();
}

pub fn key_entropy(key: u8) {
    RAND_HANDLE.lock().seed_entropy_keyboard(key);
}