#define pr_fmt(fmt) "[alloc]: " fmt
//#define DEBUG
#include "alloc.h"
#include "allocArea.h"
#include "assert.h"
#include "errno.h"
#include "irq.h"
#include "kernel.h"
#include "klibc.h"
#include "list.h"
#include "math.h"
#include "mem.h"
#include "paging.h"

#define IS_SELF_CONTAINED(desc) ((vaddr_t)((desc)->page) == (vaddr_t)(desc))
static struct slabDesc *slub;
static int allocInitialized = FALSE;

static int allocSlab(struct slabDesc **desc, size_t sizeEl, size_t sizeSlab,
                     int self_containing, int neverEmpty);
static int allocSlabEntry(struct slabEntry **desc, size_t sizeEl, size_t sizeSlab,
                          int selfContained);
static int formatPage(struct slabEntry *desc, size_t size, size_t sizeSlab, int selfContained);
static int freeFromSlab(void *ptr, struct slabEntry *slab);
static struct slabDesc *allocGetSlab(size_t size);

static struct {
    size_t elementSize;
    size_t slabSize;
    unsigned char isSelf;
    unsigned char neverEmpty;
} initSlab[] = {{4, PAGE_SIZE, 0, 0},
                {8, PAGE_SIZE, 0, 0},
                {16, PAGE_SIZE, 0, 0},
                {32, PAGE_SIZE, 0, 0},
                {64, PAGE_SIZE, 0, 0},
                {128, PAGE_SIZE, 0, 0},
                {256, 2 * PAGE_SIZE, 0, 0},
                {1024, 2 * PAGE_SIZE, 0, 0},
                {2048, 3 * PAGE_SIZE, 0, 0},
                {4096, 4 * PAGE_SIZE, 0, 0},
                {0, 0, 0, 0}};

int allocSetup(size_t sizeOfArea, vaddr_t *areaAddr, vaddr_t *descAddr, vaddr_t *entryAddr)
{
    list_init(slub);

    assert(allocBookSlab(sizeof(struct slabDesc), PAGE_SIZE, TRUE, FALSE) == 0);
    *descAddr = (vaddr_t)allocGetSlab(sizeof(struct slabDesc));
    assert(allocBookSlab(sizeof(struct slabEntry), PAGE_SIZE, TRUE, FALSE) == 0);
    *entryAddr = (vaddr_t)allocGetSlab(sizeof(struct slabEntry));
    printf("allocSetup for sizeOfArea %d\n", sizeOfArea);
    assert(allocBookSlab(sizeOfArea, PAGE_SIZE, TRUE, TRUE) == 0);
    *areaAddr        = (vaddr_t)allocGetSlab(sizeOfArea);
    allocInitialized = TRUE;

    return 0;
}

int allocPopulate()
{
    for (uint i = 0; initSlab[i].elementSize != 0; i++) {
        int ret;

        if ((ret = allocBookSlab(initSlab[i].elementSize, initSlab[i].slabSize,
                                 initSlab[i].isSelf, initSlab[i].neverEmpty))) {
            if (ret == -EEXIST)
                continue;
            pr_err("Fail to allocBookSlab %d for %d \n", ret, (1U << i));

            return ret;
        }
    }

    return 0;
}

int allocBookSlab(size_t sizeEl, size_t sizeSlab, int selfContained, int neverEmpty)
{
    struct slabDesc *slab    = NULL;
    struct slabDesc *newSlab = NULL;
    int slabIdx;
    int ret;
    int flags;

    pr_devel("%s for element of size %d is self %d\n", __func__, sizeEl, selfContained);

    disable_IRQs(flags);
    list_foreach(slub, slab, slabIdx)
    {
        if (slab->size == sizeEl) {
            restore_IRQs(flags);
            return -EEXIST;
        }
        if (slab->size > sizeEl) {
            break;
        }
    }

    if ((ret = allocSlab(&newSlab, sizeEl, sizeSlab, selfContained, neverEmpty))) {
        pr_devel("Failed to alloc Slab\n");
        restore_IRQs(flags);
        return ret;
    }

    if (list_foreach_early_break(slub, slab, slabIdx)) {
        list_insert_before(slub, slab, newSlab);
    } else {
        list_add_tail(slub, newSlab);
    }

    restore_IRQs(flags);

    return 0;
}

static int allocSlab(struct slabDesc **desc, size_t size, size_t sizeSlab, int selfContained,
                     int neverEmpty)
{
    uint nbPage, i;
    vaddr_t alloc;

    pr_devel("%s for size %d is self %d\n", __func__, size, selfContained);

    sizeSlab = MAX(sizeSlab, PAGE_SIZE);
    if (size > sizeSlab) {
        pr_devel("size of element %d are bigger than slab size %d\n", size, sizeSlab);
        return -ENOENT;
    }

    nbPage = DIV_ROUND_UP(sizeSlab, PAGE_SIZE);
    if (allocInitialized) {
        alloc = areaAlloc(nbPage, AREA_PHY_MAP);
        if (alloc == (paddr_t)NULL)
            return -ENOMEM;
    } else {
        alloc = (vaddr_t)allocPhyPage(nbPage);
        if (alloc == (paddr_t)NULL)
            return -ENOMEM;

        for (i = 0; i < nbPage; i++) {
            if (pageMap(alloc + i * PAGE_SIZE, alloc + i * PAGE_SIZE, PAGING_MEM_WRITE))
                goto free_page;
        }
    }

    if (selfContained) {
        *desc                  = (struct slabDesc *)alloc;
        ((*desc)->slab).freeEl = (char *)(*desc) + sizeof(struct slabDesc);
    } else {
        *desc = malloc(sizeof(struct slabDesc));
        if (*desc == NULL)
            return -ENOMEM;
        (*desc)->slab.freeEl = (void *)alloc;
    }

    struct slabEntry *slab = &(*desc)->slab;
    list_singleton(slab, slab);
    slab->page          = (vaddr_t)alloc;
    slab->full          = 0;
    slab->size          = sizeSlab;
    (*desc)->neverEmpty = neverEmpty;
    (*desc)->size       = size;

    return formatPage(&(*desc)->slab, size, sizeSlab, selfContained);

free_page:
    for (uint j = 0; j < i; j++) {
        pageUnmap((vaddr_t)alloc + i * PAGE_SIZE);
    }

    return -ENOMEM;
}

static int allocSlabEntry(struct slabEntry **desc, size_t size, size_t sizeSlab,
                          int selfContained)
{
    uint nbPage;

    pr_devel("%s for size %d is self %d\n", __func__, size, selfContained);

    sizeSlab = MAX(sizeSlab, PAGE_SIZE);
    if (size > sizeSlab) {
        pr_devel("size of element %d are bigger than slab size %d\n", size, sizeSlab);
        return -ENOENT;
    }

    nbPage        = DIV_ROUND_UP(sizeSlab, PAGE_SIZE);
    vaddr_t alloc = areaAlloc(nbPage, AREA_PHY_MAP);
    if (alloc == (paddr_t)NULL)
        return -ENOMEM;

    if (selfContained) {
        *desc           = (struct slabEntry *)alloc;
        (*desc)->freeEl = (char *)(*desc) + sizeof(struct slabEntry);
    } else {
        *desc = malloc(sizeof(struct slabEntry));
        if (*desc == NULL)
            return -ENOMEM;
        (*desc)->freeEl = (void *)alloc;
    }

    list_singleton(*desc, *desc);
    (*desc)->page = (vaddr_t)alloc;
    (*desc)->full = 0;
    (*desc)->size = sizeSlab;

    return formatPage((*desc), size, sizeSlab, selfContained);
}

static int formatPage(struct slabEntry *desc, size_t size, size_t sizeSlab, int selfContained)
{
    char *cur  = desc->freeEl;
    ulong nbEl = sizeSlab / size - 1;

    if (selfContained)
        nbEl = (sizeSlab - sizeof(struct slabDesc)) / size - 1;

    for (ulong i = 0; i < nbEl; i++) {
        *((vaddr_t *)cur) = (vaddr_t)cur + size;
        cur += size;
    }

    *((vaddr_t *)cur) = (vaddr_t)NULL;

    return 0;
}

static void *allocFromSlab(struct slabEntry *slab)
{
    vaddr_t *next = slab->freeEl;

    if (*next == (vaddr_t)NULL) {
        pr_devel("Slab @%d is now full\n", slab);
        slab->full = 1;
    }
    slab->freeEl = (void *)(*next);

    return (void *)next;
}

static struct slabDesc *allocGetSlab(size_t size)
{
    struct slabDesc *slab = NULL;
    uint slubIdx;

    list_foreach(slub, slab, slubIdx)
    {
        if (size <= slab->size)
            return slab;
    }

    return NULL;
}

void *malloc(size_t size)
{
    struct slabEntry *slabEntry;
    struct slabDesc *slab = NULL;
    void *ret;
    int flags;
    int slabIdx;

    disable_IRQs(flags);

    if (size >= PAGE_SIZE) {
        vaddr_t area = areaAlloc(DIV_ROUND_UP(size, PAGE_SIZE), AREA_PHY_MAP);

        return (void *)area;
    }
    if ((slab = allocGetSlab(size)) == NULL) {
        pr_devel("No slab found for %d\n", size);
        return NULL;
    }

    struct slabEntry *slabList = &slab->slab;
    list_foreach(&slab->slab, slabEntry, slabIdx)
    {
        if (!slabEntry->full) {
            // pr_devel("found place in slab idx %d for size %d\n", slabIdx, slab->size);
            ret = allocFromSlab(slabEntry);
            if (slabEntry->full && slab->neverEmpty) {

                pr_devel("Prealloc place for slab for object size %d\n", slab->size);
                assert(IS_SELF_CONTAINED(slabEntry));
                size_t slabSize         = slabEntry->size;
                int nbPages             = DIV_ROUND_UP(slabSize, PAGE_SIZE);
                struct slabEntry *entry = (struct slabEntry *)areaBook(nbPages, AREA_PHY_MAP);
                if (entry == NULL) {
                    restore_IRQs(flags);

                    return NULL;
                }

                (entry)->freeEl = (char *)(entry) + sizeof(struct slabEntry);
                list_singleton(entry, entry);
                entry->page = (vaddr_t)entry;
                entry->full = 0;
                entry->size = slabSize;

                formatPage(entry, slab->size, slabSize, 1);
                list_add_tail(slabList, entry);
                areaAdd((vaddr_t)entry, (vaddr_t)entry + nbPages * PAGE_SIZE, FALSE);
            }

            restore_IRQs(flags);
            return ret;
        }
    }

    // No room found
    struct slabEntry *newSlabEntry;
    size_t slabSize = MAX(PAGE_SIZE, size);
    int retSlab;

    if ((retSlab = allocSlabEntry(&newSlabEntry, slab->size, slabSize,
                                  IS_SELF_CONTAINED(&slab->slab)))) {
        pr_devel("Fail to allocSlabEntry %d\n", retSlab);
        restore_IRQs(flags);
        return NULL;
    }

    pr_devel("Allocate new slab for object of size %d\n", slab->size);
    list_add_tail(slabList, newSlabEntry);
    ret = allocFromSlab(newSlabEntry);

    restore_IRQs(flags);

    return ret;
}

void *zalloc(size_t size)
{
    void *alloc = malloc(size);

    if (alloc != NULL)
        memset(alloc, 0, size);

    return alloc;
}

static int freeFromSlab(void *ptr, struct slabEntry *slab)
{
    struct slabEntry *slabEntry;
    int slabIdx;

    list_foreach(slab, slabEntry, slabIdx)
    {
        if ((slabEntry->page <= (vaddr_t)ptr) &&
            ((vaddr_t)ptr < (slabEntry->page + slabEntry->size))) {

            *((vaddr_t *)ptr) = (vaddr_t)slabEntry->freeEl;
            slabEntry->freeEl = ptr;
            slabEntry->full   = 0;
            return 1;
        }
    }

    return 0;
}

int freeSlabAllocated(void *ptr)
{
    struct slabDesc *slab;
    int slabIdx;
    int flags;

    disable_IRQs(flags);

    list_foreach(slub, slab, slabIdx)
    {
        struct slabEntry *slabEntry;
        int entryIdx;
        list_foreach(&slab->slab, slabEntry, entryIdx)
        {
            if (freeFromSlab(ptr, slabEntry)) {
                restore_IRQs(flags);
                return 0;
            }
        }
    }
    restore_IRQs(flags);

    return -1;
}

void free(void *ptr)
{
    if (!ptr)
        return;
    if (!freeSlabAllocated(ptr))
        return;
    if (areaFree((vaddr_t)ptr))
        pr_err("free: cannot found origin\n");
}