#include <assert.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>
#include <string.h>

#include "resizable.h"

void
apfl_resizable_init(void **mem, size_t *len, size_t *cap)
{
    *mem = NULL;
    *len = 0;
    *cap = 0;
}

bool
apfl_resizable_resize(size_t elem_size, void **mem, size_t *len, size_t *cap, size_t newlen)
{
    // TODO: We're wasteful here by never actually shrinking the memory.
    if (newlen <= *len || newlen < *cap) {
        *len = newlen;
        return true;
    }

    assert(newlen >= *cap);

    if (!apfl_resizable_ensure_cap(elem_size, mem, cap, newlen)) {
        return false;
    }

    *len = newlen;
    return true;
}

bool
apfl_resizable_ensure_cap(size_t elem_size, void **mem, size_t *cap, size_t want_cap)
{
    if (want_cap <= *cap) {
        return true;
    }

    // TODO: We currently simply grow the memory to have space for exactly
    //       want_cap elements. It would probably be smarter to grow the memory
    //       a bit larger to reduce calls to realloc.
    void *newmem = realloc(*mem, want_cap * elem_size);
    if (newmem == NULL) {
        return false;
    }

    *mem = newmem;
    *cap = want_cap;
    return true;
}

bool
apfl_resizable_ensure_cap_for_more_elements(size_t elem_size, void **mem, size_t len, size_t *cap, size_t more_elements)
{
    return apfl_resizable_ensure_cap(elem_size, mem, cap, len + more_elements); // TODO: What if len + more_elements overflows?
}

bool
apfl_resizable_append(size_t elem_size, void **mem, size_t *len, size_t *cap, const void *other_mem, size_t other_len)
{
    if (!apfl_resizable_ensure_cap_for_more_elements(elem_size, mem, *len, cap, other_len)) {
        return false;
    }

    memcpy(*((char**)mem) + (elem_size * *len), other_mem, other_len * elem_size);
    *len += other_len;

    return true;
}