/*
 * Copyright (c) 2025 Ian Marco Moffett and the Osmora Team.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of Hyra nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/cdefs.h>
#include <sys/errno.h>
#include <vm/kalloc.h>
#include <lib/ptrbox.h>

static void *
ptrbox_heapalloc(struct ptrbox *pbox, size_t len)
{
    struct ptrbox_aldes *aldes;
    void *mem;

    if (pbox == NULL || len == 0) {
        return NULL;
    }

    mem = kalloc(len);
    if (mem == NULL) {
        return NULL;
    }

    /* Allocate a descriptor */
    aldes = kalloc(sizeof(*aldes));
    if (aldes == NULL) {
        kfree(mem);
        return NULL;
    }

    /* Initialize our descriptor */
    aldes->type = PTRBOX_HEAP;
    aldes->base = mem;
    aldes->length = len;

    /* Push it to the pointer box */
    TAILQ_INSERT_TAIL(&pbox->allist, aldes, link);
    ++pbox->alcnt;
    return mem;
}

void *
ptrbox_alloc(struct ptrbox *pbox, size_t len, ptrbox_altype_t type)
{
    if (pbox == NULL || len == 0) {
        return NULL;
    }

    switch (type) {
    case PTRBOX_HEAP:
        return ptrbox_heapalloc(pbox, len);
    default:
        return NULL;
    }

    return NULL;
}

void
ptrbox_free(struct ptrbox *pbox)
{
    struct ptrbox_aldes *desc;

    if (pbox == NULL) {
        return;
    }

    TAILQ_FOREACH(desc, &pbox->allist, link) {
        if (__unlikely(desc == NULL)) {
            continue;
        }

        if (desc->base == NULL) {
            kfree(desc);
            continue;
        }

        switch (desc->type) {
        case PTRBOX_HEAP:
            kfree(desc->base);
            break;
        }

        kfree(desc);
    }
}

int
ptrbox_init(struct ptrbox *pbox)
{
    if (pbox == NULL) {
        return -EINVAL;
    }

    TAILQ_INIT(&pbox->allist);
    pbox->alcnt = 0;
    return 0;
}