#include "hal/obj.h"
#include "jove.h"
#include "limine.h"
#include "hal/memory.h"
#include "hal/obj.h"
#include "panic/panic.h"
#include "proc/init.h"
#include "lib/printf.h"

extern struct limine_memmap_response *_limine_memmap_resp;

PAGEALIGN
static jove_objdir_t s_region_objdir;
static jove_objdir_t s_hwmemory_objdir;

#define MEMMAP_MAX_ENTRIES 255

static const char *limine_mmap_entry_type_str[9] = {
    "USABLE",
    "RESERVED",
    "ACPI RECLAIMABLE",
    "ACPI NVS",
    "BAD",
    "LIMINE RECLAIMABLE",
    "KERNEL",
    "FRAMEBUFFER",
    "ACPI TABLES"
};

void
mem_setup_regions(void)
{
    {
        jove_owned_obj_t *region_objdir_obj = objdir_getlocal(_rootdir_obj, INIT_ROOTDIR_FREEMEMORY_I);
        obj_settype(region_objdir_obj, JOVE_OBJ_OBJDIR);
        obj_setvalue(region_objdir_obj, (uintptr_t)&s_region_objdir);
        obj_release(region_objdir_obj);
    }

    if(_limine_memmap_resp == NULL) {
        kpanic("Limine failed to provide memory map.\n");
    }

    kprintf("Memory map provided by Limine:\n");

    size_t region_i = 0;
    size_t hwmem_i = 0;

    for(size_t i = 0; i < _limine_memmap_resp->entry_count; i++) {
        struct limine_memmap_entry *entry = _limine_memmap_resp->entries[i];

        if(entry->type == LIMINE_MEMMAP_USABLE ||
           entry->type == LIMINE_MEMMAP_ACPI_RECLAIMABLE ||
           entry->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE)
        {
            if(region_i > OBJDIR_ENTRIES){
                kprintf("%s: Provided memory map exceeds kernel limits. Some memory may not be accessable.", __func__);
                break;
            }
 
            klogf("Free  %p : %p %s\n", entry->base, entry->length, limine_mmap_entry_type_str[entry->type]);
            if(entry->base == 0) continue;

            {
                jove_owned_obj_t *region_obj = obj_take(&s_region_objdir.entries[region_i++]);
                region_new(region_obj, entry->base, entry->length / 0x1000);
                obj_release(region_obj);
            }
        }else
        if(entry->type == LIMINE_MEMMAP_RESERVED ||
            entry->type == LIMINE_MEMMAP_ACPI_NVS ||
            entry->type == LIMINE_MEMMAP_ACPI_TABLES ||
            entry->type == LIMINE_MEMMAP_FRAMEBUFFER)
        {
            intmax_t hw_pages = entry->length >> 12;
            uintptr_t base = entry->base;
            klogf("HWmem %p : %p %s\n", entry->base, entry->length, limine_mmap_entry_type_str[entry->type]);
            while(hw_pages > 0) {
                if(hwmem_i >= OBJDIR_ENTRIES) {
                    kprintf("%s: Reserved memory region exceeds indexing limits!\n", __func__);
                    break;
                }

                size_t pages = hw_pages > 4095 ? 4095 : hw_pages;

                jove_owned_obj_t *hwmem_obj = obj_take(&s_hwmemory_objdir.entries[hwmem_i++]);
                obj_settype(hwmem_obj, JOVE_OBJ_SHMEMORY);
                obj_setvalue(hwmem_obj, entry->base | (entry->length >> 12));

                obj_release(hwmem_obj);
                hw_pages -= 4096;
                base += (4096ULL << 12);
            }
        }else{
            klogf("Kmem  %p : %p %s\n", entry->base, entry->length, limine_mmap_entry_type_str[entry->type]);
        }
    }
}