use crate::cap::pool::POOL;
use crate::cap::table::Rights;
use crate::proc::PROCESSES;
use crate::proc::context::CpuContext;

use lancer_core::object_tag::ObjectTag;

use super::{SyscallResult, try_syscall};

pub fn sys_untyped_retype(ctx: &mut CpuContext) {
    let pid = crate::arch::syscall::current_pid();
    let untyped_cap_addr = ctx.rdi;
    let obj_type = ctx.rsi;
    let size_bits = ctx.rdx;
    let dest_slot_base = ctx.r10;
    let count = ctx.r8;

    let tag = try_syscall!(ctx, ObjectTag::try_from(obj_type));
    let size_bits_u8 = try_syscall!(ctx, super::u8_from_reg(size_bits));
    let count_u32 = try_syscall!(ctx, super::u32_from_reg(count));

    let mut ptable = PROCESSES.lock();
    let (cnode_id, cnode_gen, depth, gv, gb) =
        try_syscall!(ctx, crate::cap::cnode::cnode_coords(pid, &ptable));

    let mut pool = POOL.lock_after(&ptable);

    let untyped_cap = try_syscall!(
        ctx,
        crate::cap::cnode::resolve_and_validate(
            &pool,
            cnode_id,
            cnode_gen,
            untyped_cap_addr,
            depth,
            gv,
            gb,
            ObjectTag::Untyped,
            Rights::REVOKE,
        )
    );

    let untyped_oid = untyped_cap.phys();
    let untyped_gen = untyped_cap.generation();

    let ptable_arg = match tag {
        ObjectTag::Process => Some(&mut *ptable),
        _ => None,
    };

    let result = crate::cap::retype::kernel_retype(
        &mut pool,
        ptable_arg,
        untyped_oid,
        untyped_gen,
        tag,
        size_bits_u8,
        cnode_id,
        cnode_gen,
        dest_slot_base,
        depth,
        gv,
        gb,
        count_u32,
    );

    ctx.rax = match result {
        Ok(()) => SyscallResult::ok().raw(),
        Err(e) => SyscallResult::error(e).raw(),
    };
}