use crate::syscall::{MIN_USER_VADDR, USER_ADDR_LIMIT};

crate::kernel_test!(
    fn elf_segment_in_kernel_space_rejected() {
        let segments = [lancer_core::elf::LoadSegment {
            vaddr: 0xFFFF_8000_0000_0000,
            memsz: 0x1000,
            filesz: 0x1000,
            file_offset: 0,
            writable: false,
            executable: true,
        }];

        let all_user_space = segments.iter().all(|seg| {
            seg.vaddr >= MIN_USER_VADDR
                && seg
                    .vaddr
                    .checked_add(seg.memsz)
                    .is_some_and(|end| end <= USER_ADDR_LIMIT)
        });

        assert!(!all_user_space, "segment in kernel-half should be rejected");
    }
);

crate::kernel_test!(
    fn elf_entry_not_in_executable_segment_rejected() {
        let segments = [lancer_core::elf::LoadSegment {
            vaddr: 0x40_0000,
            memsz: 0x1000,
            filesz: 0x1000,
            file_offset: 0,
            writable: true,
            executable: false,
        }];
        let entry = 0x40_0000;

        let entry_in_executable = segments
            .iter()
            .any(|seg| seg.executable && entry >= seg.vaddr && entry < seg.vaddr + seg.memsz);

        assert!(
            !entry_in_executable,
            "entry in non-executable segment should be rejected"
        );
    }
);

crate::kernel_test!(
    fn elf_overlapping_segments_rejected() {
        let segments = [
            lancer_core::elf::LoadSegment {
                vaddr: 0x40_0000,
                memsz: 0x2000,
                filesz: 0x2000,
                file_offset: 0,
                writable: false,
                executable: true,
            },
            lancer_core::elf::LoadSegment {
                vaddr: 0x40_1000,
                memsz: 0x1000,
                filesz: 0x1000,
                file_offset: 0x2000,
                writable: true,
                executable: false,
            },
        ];

        let has_overlap = (0..segments.len()).any(|i| {
            let a = segments[i];
            let a_base = a.vaddr & !0xFFF;
            let a_end = (a.vaddr + a.memsz + 0xFFF) & !0xFFF;
            ((i + 1)..segments.len()).any(|j| {
                let b = segments[j];
                let b_base = b.vaddr & !0xFFF;
                let b_end = (b.vaddr + b.memsz + 0xFFF) & !0xFFF;
                a_base < b_end && b_base < a_end
            })
        });

        assert!(
            has_overlap,
            "overlapping page-level segments should be detected"
        );
    }
);