pub(crate) use abi::{
    error::Error,
    io::{
        DirectoryEntry, FileAttr, FileMode, MountOptions, OpenOptions, PollControl, RawFd,
        TerminalOptions, TerminalSize, UnmountOptions,
    },
    mem::MappingSource,
    net::SocketType,
    process::{Signal, SignalEntryData, SpawnOptions},
    system::SystemInfo,
};
use abi::{
    path::Path,
    process::{ExecveOptions, ProcessId},
};
use libk::{module, random, task::thread::Thread};
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(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(options)?;
        io.ioctx_mut().mount(options.target, fs_root)?;
        Ok(())
    })
}

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

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() {
            todo!();
        }
        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!()
}