#![allow(clippy::empty_loop)]

use {
    crate::{
        arch::{init, sloop},
        boot_conf,
        experiments::{
            info::master,
            systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
        },
        graphics::{VgaBuffer, SCREEN_BUFFER},
        relib::math::rand::RAND_HANDLE,
        relib::network::socket::Socket,
        relib::network::socket::{SimpleSock, SocketReturns},
        scheduler::{test_fn, Thread, ThreadList},
        vga_e::{self, num_to_vga16},
    },
    alloc::{
        format,
        string::{String, ToString},
        vec,
    },
    core::sync::atomic::{AtomicU64, Ordering::*},
    lazy_static::lazy_static,
    log::*,
    picorand::PicoRandGenerate,
    rkyv::{ser::serializers::AllocSerializer, Deserialize},
    shadeable::pixel_format::from_vga_16,
    y_compositor_protocol::Version,
};

#[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: AtomicU64 = AtomicU64::new(0);
}

#[no_mangle]
pub fn kernel_main() -> ! {
    let boot_conf = boot_conf::BootConfig::new();

    init::init();
    log::set_max_level(boot_conf.log_level());
    // info!("Initialized");

    graphics_pipe_startup();

    /*

        {
            let mut proc_1 = SimpleSock::new();
            proc_1.register_protocol("ProcSpawner".to_string());

            let version = 0;
            use rkyv::ser::Serializer;
            let mut serializer = AllocSerializer::<0>::default();
            serializer.serialize_value(&version).unwrap();

            let bytes = serializer.into_serializer().into_inner();
            proc_1.write(bytes.into_vec());
            unsafe {
                let the_bytes = proc_1.read(3).unwrap();
                let archived = rkyv::archived_root::<Version>(&the_bytes);
                let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
                // trace!("{:?}", deserialized);
            }
        }
    */

    let mut graphics = SCREEN_BUFFER.lock();
    graphics.force_redraw();
    graphics.clear();

    graphics.draw_filled_circle(100, 100, 5, 0x9900ff00);
    screen_writer_test();

    graphics.copy_to_buffer();

    if boot_conf.run_tests {
        // quick and dirty testing framework
        socket_test();
        graphics_pipe_test();
        socket_startup_rng();
        socket_test_rng();
    }

    if boot_conf.run_demos {
        graphics_api_demo();
    }

    if boot_conf.run_shader_tests {
        shader_tests();
    }

    // graphics.copy_to_buffer();

    // info!("buffer copied");

    sloop()
}

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

    RAND_HANDLE.lock().seed_entropy_timer(data);

    crate::kernel_state::KERNEL_STATE.lock().update_state();
    TICK.store(data, Relaxed)
}

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

pub fn test_threads() {
    let mut a_thread = Thread::new();

    a_thread.new_task(test_fn);
    a_thread.new_task(test_fn);
    THREAD_LIST.lock().push(a_thread);
}

pub fn cpu_socket_startup() {
    let mut cpu_info_socket = SimpleSock::new();
    cpu_info_socket.register_protocol("CPU_INFO".to_string());

    let x = master().unwrap();
    let xyz = x.brand_string().unwrap();
}

pub fn log_version_data() {
    info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
    info!(
        "Brand String: {:?}",
        master().unwrap().brand_string().unwrap()
    );
}

pub fn socket_test() {
    let mut xyz = SimpleSock::new();

    xyz.peek();

    xyz.write(vec![0, 1, 2, 3]);

    let x = "simple 🧦".to_string().into_bytes();
    xyz.write(x);

    info!("{:?}", &xyz.read(4).unwrap());

    match &xyz.peek() {
        SocketReturns::ReadOk(strr) => {
            let out = String::from_utf8_lossy(strr);

            info!("{}", out);
        }
        SocketReturns::ReadIndexOutOfBounds => todo!(),
        SocketReturns::WriteOk => todo!(),
    }
}

pub fn socket_test_rng() {
    let mut test_sock = SimpleSock::grab_socket("RNGProvider".to_string()).unwrap();
    info!(
        "Recieving {} from protocol {}",
        test_sock.read(1).unwrap()[0],
        test_sock.protocol().unwrap()
    );
}

pub fn socket_startup_rng() {
    use picorand::{WyRand, RNG};
    let mut random_socket = SimpleSock::new();

    random_socket.register_protocol("RNGProvider".to_string());
    let bruh = TICK.load(core::sync::atomic::Ordering::Relaxed);

    let mut rng = RNG::<WyRand, u8>::new(bruh);

    for _ in 0..512 {
        let x = rng.generate();
        random_socket.write(vec![x]);
    }
}

pub fn screen_writer_test() {
    let mut sock_print_id = SimpleSock::new();

    sock_print_id.register_protocol("Screen Printer".to_string());

    // sock_print_id.write(format!("a原 b画 cフ dァ eイ fル 集").into());
    sock_print_id.write(format!("λ³ Half Life 3 booting up  ㎣").into());
    // sock_print_id.write(format!("Happy birthday 🎉").into());
    // sock_print_id.write(format!("1....2....3....4....5....6....7....8....9").into());

    let mut prev = None;

    // let mut graphics = SCREEN_BUFFER.lock();
    // graphics.clear();
    // graphics.copy_to_buffer();

    for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
        vga_e::draw_char(prev, current, 0);

        prev = Some(current);
    }
}

pub fn vga_boot_screen() {
    let mut abcde = SCREEN_BUFFER.lock();

    for y in 0..480 {
        for x in 0..640 {
            let segment_x = x * 4 / 640;
            let segment_y = y * 4 / 480;
            let segment = segment_x + segment_y * 4;

            abcde.set_pixel(x, y, from_vga_16(num_to_vga16(segment as u8)));
        }
    }
}

pub fn graphics_pipe_test() {
    let mut graphics_pipe = SimpleSock::grab_socket("YCompositor".to_string()).unwrap();

    let version = Version {
        major: 13,
        minor: 123,
        patch: 0,
    };
    use rkyv::ser::Serializer;
    let mut serializer = AllocSerializer::<0>::default();
    serializer.serialize_value(&version).unwrap();
    // let bytes = serializer.into_serializer().into_inner();

    // info!("{:?}", bytes);
    let bytes = serializer.into_serializer().into_inner();
    graphics_pipe.write(bytes.into_vec());
    unsafe {
        let the_bytes = graphics_pipe.read(3).unwrap();
        let archived = rkyv::archived_root::<Version>(&the_bytes);
        let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
        trace!("{:?}", deserialized);
    }
}

pub fn graphics_pipe_startup() {
    let mut graphics_pipe = SimpleSock::new();

    graphics_pipe.register_protocol("YCompositor".to_string());
}

pub fn graphics_api_demo() {
    let mut abcde = SCREEN_BUFFER.lock();
    abcde.force_redraw();

    abcde.draw_filled_circle(100, 100, 300, 0x0000ff00);
    abcde.draw_unfilled_rect(100, 100, 400, 200, 0xff000000);
    abcde.draw_filled_rect(300, 300, 400, 400, 0xff000000);
    abcde.draw_line(100, 100, 400, 200, 0xff000000);
    abcde.copy_to_buffer();
}

pub fn shader_tests() {
    let mut graphics = SCREEN_BUFFER.lock();

    graphics.clear();
    graphics.force_redraw();
    graphics.draw_filled_rect(25, 25, 50, 50, 0xff000000);
    graphics.set_pixel(50, 50, 0xffffff00);
    graphics.shade();

    graphics.copy_to_buffer();

    // drop(graphics)
}