// Copyright (c) 2025 shibedrill
// SPDX-License-Identifier: GPL-3.0-or-later

#![no_std]
#![no_main]
#![feature(allocator_api)]
#![feature(str_from_raw_parts)]
#![feature(abi_x86_interrupt)]

mod arch;
mod boot;
mod constants;
mod device;
mod interrupt;
#[macro_use]
mod log;
mod memory;
mod panic;
mod process;
#[macro_use]
mod util;

use boot::{BASE_REVISION, params, *};
use constants::*;
use limine::firmware_type::FirmwareType;
use log::*;
use memory::alloc::{format, string::*, vec};

use params::*;

#[allow(unused_imports)]
use lzma_rs::lzma_decompress;

use crate::arch::x86_64::interrupts::IDT;

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

    // Ensure IDT exists
    IDT.load();

    #[cfg(target_arch = "x86_64")]
    let serial: x86_64::instructions::port::Port<u8> = x86_64::instructions::port::Port::new(0x3f8);

    // Set up logging level from params
    // Nothing we can do here if this fails since no log subscribers are initialized yet
    if let Some(level) = PARAMS.get("-loglevel")
        && let Ok(parsed_level) = LogLevel::try_from(level.as_str())
    {
        LOGGER.set_level(parsed_level);
    }
    // Add subscribers to logger
    if let Some(device) = PARAMS.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") {
            // TODO: Set up device discovery
            #[cfg(target_arch = "x86_64")]
            LOGGER.add_subscriber(serial);
        }
        log_trace!("Configured kernel logging devices");
    }
    log_info!(
        "Kernel cmdline: {}",
        String::from_utf8_lossy(
            limine::file::File::string(EXECUTABLE_FILE_RESPONSE.file()).to_bytes()
        )
    );
    log_info!(
        "Kernel file path: {}",
        String::from_utf8_lossy(EXECUTABLE_FILE_RESPONSE.file().path().to_bytes())
    );
    log_info!("Booting gila version {}", kernel_version_string());
    log_info!("Enabled features: {}", FEATURE_FLAGS.to_string());

    match boot::FIRMWARE_TYPE_REQUEST.get_response() {
        Some(resp) => log_info!(
            "Firmware type: {}",
            match resp.firmware_type() {
                FirmwareType::SBI => "SBI",
                FirmwareType::UEFI_32 => "UEFI (32-bit)",
                FirmwareType::UEFI_64 => "UEFI (64-bit)",
                FirmwareType::X86_BIOS => "x86 BIOS",
                _ => "Unknown",
            }
        ),
        None => log_warning!("Firmware type: No response"),
    }

    log_info!("Trans rights!");

    device::init_statics();

    if let Some(framebuffer_response) = FRAMEBUFFER_REQUEST.get_response() {
        let fb = framebuffer_response.framebuffers().next().unwrap();
        log_info!("Framebuffer response received");
        log_trace!(
            "Framebuffer dimensions: {}x{}, {} bits per pixel",
            fb.width(),
            fb.height(),
            fb.bpp()
        );
    } else {
        log_info!("Framebuffer response absent, graphics disabled",);
    }

    let smp_response = MP_REQUEST.get_response();
    match smp_response {
        None => log_info!("Multiprocessing response not received"),
        Some(resp) => {
            log_info!("Multiprocessing response received");
            log_trace!("{} CPUs found", resp.cpus().len());
        }
    }

    boot::modules::log_modules();

    memory::log_memory();
    memory::log_address();

    arch::x86_64::paging::get_mappings();

    panic!("Bailing");

    #[allow(unreachable_code)]
    loop {
        for _i in 0..50000000u64 {
            crate::arch::asm::nop();
        }
        core::hint::black_box(());
        log_trace!("Heartbeat");
    }
}