use core::mem::MaybeUninit;

pub(crate) use abi::{
    error::Error,
    io::{
        AccessMode, DirectoryEntry, FileAttr, FileMode, MountOptions, OpenOptions, PipeOptions,
        PollControl, RawFd, TerminalOptions, TerminalSize, TimerOptions, UnmountOptions,
    },
    mem::{MappingFlags, MappingSource},
    net::SocketType,
    process::{Signal, SignalEntryData, SpawnOptions, WaitFlags},
    system::SystemInfo,
};
use abi::{
    path::Path,
    process::{ExecveOptions, ProcessId},
    time::{ClockType, SystemTime},
};
use libk::{
    module, random,
    task::thread::Thread,
    time::{monotonic_time, real_time},
};
use libk_mm::phys;

use crate::fs;

use super::run_with_io;

pub(super) mod sys_debug;
pub(super) mod sys_io;
pub(super) mod sys_net;
pub(super) mod sys_process;

pub(super) use sys_debug::*;
pub(super) use sys_io::*;
pub(super) use sys_net::*;
pub(super) use sys_process::*;

// Misc
pub(crate) fn get_random(buffer: &mut [u8]) {
    random::read_unsecure(buffer);
}

pub(crate) fn mount(options: &MountOptions<'_>) -> Result<(), Error> {
    let thread = Thread::current();
    let process = thread.process();

    run_with_io(&process, |mut io| {
        let fs_root = fs::create_filesystem(io.ioctx_mut(), options)?;
        io.ioctx_mut().mount(options.target, fs_root)?;
        Ok(())
    })
}

pub(crate) fn unmount(_options: &UnmountOptions) -> Result<(), Error> {
    todo!()
}

pub(crate) fn get_clock(ty: ClockType, value: &mut MaybeUninit<SystemTime>) -> Result<(), Error> {
    let time = match ty {
        ClockType::RealTime => real_time(),
        ClockType::Monotonic => monotonic_time(),
    };
    value.write(time);
    Ok(())
}

pub(crate) fn get_system_info(element: &mut SystemInfo) -> Result<(), Error> {
    match element {
        SystemInfo::MemoryStats(stats) => {
            *stats = phys::stats();
            Ok(())
        }
    }
}

pub(crate) fn load_module(path: &str) -> Result<(), Error> {
    let thread = Thread::current();
    let process = thread.process();

    let file = run_with_io(&process, |mut io| {
        let path: &Path = path.as_ref();
        if !path.is_absolute() {
            return Err(Error::InvalidArgument);
        }
        io.ioctx_mut().open_executable(path)
    })?;

    module::load_and_execute(file)
}

// Handled outside
pub(crate) fn exit_signal(_frame: &SignalEntryData) -> ! {
    unreachable!()
}

pub(crate) fn fork() -> Result<ProcessId, Error> {
    unreachable!()
}

pub(crate) fn execve(_options: &ExecveOptions<'_>) -> Result<(), Error> {
    unreachable!()
}