use crate::error::KernelError;
use crate::syscall;

crate::kernel_test!(
    fn validate_user_vaddr_rejects_null() {
        let result = syscall::validate_user_vaddr(0);
        assert!(
            result == Err(KernelError::InvalidAddress),
            "null address should be rejected"
        );
    }
);

crate::kernel_test!(
    fn validate_user_vaddr_rejects_kernel_half() {
        let result = syscall::validate_user_vaddr(0xFFFF_8000_0000_0000);
        assert!(
            result == Err(KernelError::InvalidAddress),
            "kernel-half address should be rejected"
        );

        let boundary = syscall::validate_user_vaddr(0x0000_8000_0000_0000);
        assert!(
            boundary == Err(KernelError::InvalidAddress),
            "USER_ADDR_LIMIT boundary should be rejected"
        );
    }
);

crate::kernel_test!(
    fn validate_user_vaddr_accepts_valid() {
        let result = syscall::validate_user_vaddr(0x0000_4000_0000_0000);
        assert!(result.is_ok(), "valid user address should be accepted");

        let low = syscall::validate_user_vaddr(0x1000);
        assert!(low.is_ok(), "MIN_USER_VADDR should be accepted");
    }
);

crate::kernel_test!(
    fn u8_from_reg_rejects_overflow() {
        let result = syscall::u8_from_reg(256);
        assert!(
            result == Err(KernelError::InvalidParameter),
            "256 should not fit in u8"
        );

        let valid = syscall::u8_from_reg(255);
        assert!(valid.is_ok(), "255 should fit in u8");
    }
);

crate::kernel_test!(
    fn user_addr_limit_boundary() {
        let limit = crate::syscall::USER_ADDR_LIMIT;

        assert!(
            crate::syscall::validate_user_vaddr(limit).is_err(),
            "USER_ADDR_LIMIT ({:#x}) itself must be rejected",
            limit
        );

        assert!(
            crate::syscall::validate_user_vaddr(limit - 1).is_ok(),
            "USER_ADDR_LIMIT - 1 ({:#x}) must be accepted",
            limit - 1
        );

        assert!(
            crate::syscall::validate_user_vaddr(0).is_err(),
            "address 0 must be rejected (null page)"
        );

        assert!(
            crate::syscall::validate_user_vaddr(0x1000).is_ok(),
            "MIN_USER_VADDR (0x1000) must be accepted"
        );
    }
);

crate::kernel_test!(
    fn user_virt_addr_rejects_kernel_address() {
        assert!(
            crate::syscall::UserVirtAddr::new(0xFFFF_8000_0000_0000).is_err(),
            "kernel address should be rejected by UserVirtAddr"
        );

        assert!(
            crate::syscall::UserVirtAddr::new(0).is_err(),
            "null address should be rejected by UserVirtAddr"
        );

        assert!(
            crate::syscall::UserVirtAddr::new(0x40_0000).is_ok(),
            "valid user address should pass UserVirtAddr"
        );
    }
);

crate::kernel_test!(
    fn user_virt_addr_rejects_just_below_minimum() {
        let below_min = crate::syscall::MIN_USER_VADDR - 1;
        assert!(
            crate::syscall::UserVirtAddr::new(below_min).is_err(),
            "address {:#x} (MIN_USER_VADDR - 1) must be rejected",
            below_min
        );

        assert!(
            crate::syscall::UserVirtAddr::new(1).is_err(),
            "address 0x1 must be rejected (below MIN_USER_VADDR)"
        );

        assert!(
            crate::syscall::UserVirtAddr::new(0xFFF).is_err(),
            "address 0xFFF must be rejected (last byte of null page)"
        );

        assert!(
            crate::syscall::UserVirtAddr::new(crate::syscall::MIN_USER_VADDR).is_ok(),
            "MIN_USER_VADDR itself must be accepted"
        );
    }
);