#include "memory.h"
#include <assert.h>

#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>

typedef struct dummyComp {
    unsigned int num;
}dummyComp;
DEFINE_COMPONENT_HEADERS(dummy, 0, dummyComp)

DEFINE_COMP_MEMPOOL_BUF(dummyComp, 16)

#define USER_N_COMPONENTS 1
BEGIN_DEFINE_COMP_MEMPOOL
ADD_COMP_MEMPOOL(dummy, dummyComp)
END_DEFINE_COMP_MEMPOOL


/**
 * Component Pool Test
 */

static int setup_mem_pool(void** state)
{
    (void)state;

    init_memory_system();
    return 0;
}

static int teardown_mem_pool(void** state)
{
    (void)state;

    free_memory_system();
    return 0;
}

static void test_simple_component_alloc(void **state)
{
    // Typical usage
    (void)state;

    unsigned int idx = 0;
    dummyComp* comp = new_component_dummy(&idx);
    assert_non_null(comp);
    dummyComp* check = get_component_dummy(idx);
    assert_ptr_equal(comp, check);
    free_component_dummy(idx);
    check = get_component_dummy(idx);
    assert_null(check);
}

static void test_component_OOB_get(void **state)
{
    // OOB indice will result in NULL for get function
    (void)state;

    dummyComp* comp = get_component_dummy(16);
    assert_null(comp);
    comp = get_component_dummy(65535);
    assert_null(comp);
}

static void test_component_reuse(void **state)
{
    // Component pool must reuse idx ASAP
    (void)state;

    unsigned int idx = 0;
    dummyComp* comp = new_component_dummy(&idx);
    assert_non_null(comp);

    free_component_dummy(idx);

    unsigned int new_idx = 0;
    new_component_dummy(&new_idx);
    assert_int_equal(new_idx, idx);
}

static void test_component_double_free(void **state)
{
    // A double free is okay and does not affect anything
    // Double freeing the same idx will not cause it to
    // be allocated twice
    (void)state;

    unsigned int idx = 0;
    dummyComp* comp = new_component_dummy(&idx);
    assert_non_null(comp);

    free_component_dummy(idx);
    dummyComp* check = get_component_dummy(idx);
    assert_null(check);

    free_component_dummy(idx);
    check = get_component_dummy(idx);
    assert_null(check);

    unsigned int new_idx = 0;
    new_component_dummy(&new_idx);
    new_component_dummy(&new_idx);
    assert_int_not_equal(new_idx, idx);
}

static void test_component_new_clear(void** state) {
    (void)state;
    unsigned int idx = 0;
    dummyComp* comp = new_component_dummy(&idx);
    assert_non_null(comp);
    assert_int_equal(comp->num, 0);

    comp->num = 16;
    dummyComp* check = get_component_dummy(idx);
    assert_int_equal(check->num, comp->num);

    free_component_dummy(idx);
    comp = new_component_dummy(&idx);
    assert_non_null(comp);
    assert_int_equal(comp->num, 0);
}

int main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(test_simple_component_alloc, setup_mem_pool, teardown_mem_pool),
        cmocka_unit_test_setup_teardown(test_component_reuse, setup_mem_pool, teardown_mem_pool),
        cmocka_unit_test_setup_teardown(test_component_OOB_get, setup_mem_pool, teardown_mem_pool),
        cmocka_unit_test_setup_teardown(test_component_new_clear, setup_mem_pool, teardown_mem_pool),
        cmocka_unit_test_setup_teardown(test_component_double_free, setup_mem_pool, teardown_mem_pool),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}