//! Kernel initialization and supervisor entry point.  
//!
//! This module sets up the global heap, initializes core subsystems (VGA, filesystem,
//! scheduler, and logging), and starts initial processes.
#![no_std]
#![no_main]
// #![warn(clippy::pedantic)]
#![allow(static_mut_refs, internal_features)]
#![feature(
    riscv_ext_intrinsics,
    str_from_raw_parts,
    arbitrary_self_types_pointers,
    derive_const,
    const_cmp,
    const_trait_impl,
    trait_alias,
    prelude_import,
    slice_index_methods
)]

use core::sync::atomic::AtomicBool;
use embedded_alloc::LlffHeap as Heap;

use crate::{
    drivers::{keyboard::KBD_DRIVER, mouse::MOUSE_DRIVER},
    io::init_log,
    pci::scan_virtio_devices,
    riscv::enable_supervisor_interrupt,
    scheduler::{SCHEDULER, idle},
    vga::Vga,
    virtio::input::init_plic_pci,
    virtual_fs::init_file_system,
};

mod prelude;
#[allow(unused_imports)]
#[prelude_import]
pub use prelude::*;

extern crate alloc;
mod boot;
mod critical_section;
mod cursor;
mod data_structures;
mod draw;
mod drivers;
mod fs;
mod interrupt;
mod io;
mod keymap;
mod panic_handler;
mod pci;
mod process;
mod riscv;
mod scheduler;
mod sync;
mod syscall;
mod time;
mod tty;
mod uart;
mod vga;
mod virtio;
mod virtual_console;
mod virtual_fs;

pub const HEAP_SIZE: usize = 1024 * 1024 * 128; // 128Mo RAM
#[global_allocator]
static HEAP: Heap = Heap::empty();

static HEAP_INITIALIZED: AtomicBool = AtomicBool::new(false);

// Usize is assumed to be an u64 in the whole kernel
const _: () = assert!(core::mem::size_of::<usize>() == core::mem::size_of::<u64>());
#[cfg(not(target_endian = "little"))]
compile_error! {"This kernel implementation assume endianness is little-endian. Some memory access like PCI could not work in big-endian."}

#[unsafe(no_mangle)]
pub extern "C" fn supervisor_mode_entry() {
    unsafe {
        embedded_alloc::init!(HEAP, HEAP_SIZE);
        HEAP_INITIALIZED.store(true, core::sync::atomic::Ordering::Relaxed);
        init_log().unwrap();
        Vga::init();
        init_file_system();
        SCHEDULER.lock().init();
    }

    unsafe {
        let (pci_keyboard, pci_mouse) = scan_virtio_devices();
        let (pci_keyboard, pci_mouse) = (pci_keyboard.unwrap(), pci_mouse.unwrap());

        KBD_DRIVER.init(
            pci_keyboard.common_cfg,
            pci_keyboard.notify_cfg,
            pci_keyboard.isr_cfg,
            pci_keyboard.notify_multiplier,
        );

        MOUSE_DRIVER.init(
            pci_mouse.common_cfg,
            pci_mouse.notify_cfg,
            pci_mouse.isr_cfg,
            pci_mouse.notify_multiplier,
        );

        init_plic_pci(pci_keyboard.irq);
        init_plic_pci(pci_mouse.irq);
    }

    SCHEDULER
        .lock()
        .create_process_from_file("/usr/bin/agetty", 0, core::ptr::null());
    enable_supervisor_interrupt();

    idle(0, core::ptr::null());
}