//! Memory Phase

const common = @import("common");

const kagami = @import("mirai").kagami;
const pmm = @import("mirai").pmm;
const print = @import("mirai").boot.sequence.print;
const stack = @import("mirai").memory.stack;
const strings = @import("mirai").boot.strings;
const tss = @import("mirai").boot.tss;
const types = @import("mirai").boot.types;

const math = @import("utils").math;

const layout = common.constants.memory.layout;
const messages = strings.sequence.messages;
const status = strings.sequence.status;
const sizes = common.constants.memory.sizes;

const BootInfo = types.sequence.info.BootInfo;

pub fn execute(boot_info: *const BootInfo) bool {
    print.phase(status.SYSTEM_MEMORY);

    const bitmap_location = findBitmapLocation(boot_info);
    if (bitmap_location == 0) {
        print.log(messages.NO_BITMAP, .{});
        return false;
    }

    pmm.init.setup.initializeFromMemoryMap(boot_info.MemoryMap, boot_info.MemoryMapCount, bitmap_location);

    const statistics = pmm.state.getStatistics();
    const total_megabytes = (statistics.TotalPages * sizes.PAGE_SIZE) / sizes.MEGABYTE;
    const free_megabytes = (statistics.FreePages * sizes.PAGE_SIZE) / sizes.MEGABYTE;

    print.log(messages.FOUND_PAGES, .{ statistics.TotalPages, total_megabytes });
    print.log(messages.AVAILABLE, .{ statistics.FreePages, free_megabytes });

    print.phase(status.KAGAMI);
    kagami.state.initialize(boot_info.PML4Physical);
    print.log(messages.PML4, .{boot_info.PML4Physical});

    print.phase(status.KERNEL_MEMORY);
    const boot_stack = stack.allocate.allocate() catch {
        print.log(messages.NO_STACK, .{});
        return false;
    };
    tss.state.setCurrentRSP0(0, boot_stack.Top);
    print.log(messages.STACK_INFO, .{ boot_stack.Base, boot_stack.Top });

    return true;
}

fn findBitmapLocation(boot_info: *const BootInfo) u64 {
    const bitmap_size = pmm.constants.limits.BITMAP_SIZE_BYTES;
    const required_pages = math.integer.divideCeil(bitmap_size, sizes.PAGE_SIZE);

    var index: u64 = 0;
    while (index < boot_info.MemoryMapCount) : (index += 1) {
        const region = boot_info.MemoryMap[index];

        if (!region.isUsable()) continue;

        if (region.BaseAddress < layout.KERNEL_PHYSICAL_BASE) continue;

        if (region.BaseAddress >= boot_info.KernelPhysicalBase and
            region.BaseAddress < boot_info.KernelPhysicalEnd)
        {
            continue;
        }

        const region_pages = region.pageCount();
        if (region_pages >= required_pages) {
            return region.BaseAddress;
        }
    }

    return 0;
}