#include <al/test.h>
#include <al/array_typed.h>

#include "array_typed.h"

struct test_t {
    u32 i;
};

AL_ARRAY_INLINE_STORAGE_DEFINE(u32, u32, 64)
AL_ARRAY_DEFINE(u32, u32)
AL_ARRAY_INLINE_STORAGE_DEFINE(test_t, struct test_t, 16)

static bool array_test_init(void)
{
    AL_TEST_START("array_init");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    AL_TEST_EQ((void *)arr.data, NULL, ptr);
    AL_TEST_EQ(arr.alloc, 64, u32);
    AL_TEST_EQ(arr.size, 0, u32);
    AL_TEST_EQ(sizeof(arr.inline_data), 64 * sizeof(u32), size_t);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_reserve(void)
{
    AL_TEST_START("array_reserve");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    al_array_reserve(u32, 64)(&arr, 64);

    AL_TEST_EQ((void *)arr.data, NULL, ptr);
    AL_TEST_EQ(arr.alloc, 64, u32);

    al_array_reserve(u32, 64)(&arr, 128);

    AL_TEST_NEQ((void *)arr.data, NULL, ptr);
    AL_TEST_EQ(arr.alloc, 256, u32);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_at(void)
{
    AL_TEST_START("array_at");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    u32 x = 5;
    al_array_push(u32, 64)(&arr, &x);

    AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 0), 5, u32);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_last(void)
{
    AL_TEST_START("array_last");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    u32 x = 1, y = 2, z = 3;

    al_array_push(u32, 64)(&arr, &x);
    al_array_push(u32, 64)(&arr, &y);
    al_array_push(u32, 64)(&arr, &z);

    AL_TEST_EQ(*al_array_last(u32, 64)(&arr), 3, u32);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_push(void)
{
    AL_TEST_START("array_push");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    u32 x = 4, y = 5;

    al_array_push(u32, 64)(&arr, &x);
    al_array_push(u32, 64)(&arr, &y);

    AL_TEST_EQ(arr.size, 2, u32);
    AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 0), x, u32);
    AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 1), y, u32);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_pop(void)
{
    AL_TEST_START("array_pop");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    u32 x = 4, y = 5;

    al_array_push(u32, 64)(&arr, &x);
    al_array_push(u32, 64)(&arr, &y);

    u32 rx, ry;

    al_array_pop(u32, 64)(&arr, &ry);

    AL_TEST_EQ(arr.size, 1, u32);

    al_array_pop(u32, 64)(&arr, &rx);

    AL_TEST_EQ(arr.size, 0, u32);
    AL_TEST_EQ(rx, x, u32);
    AL_TEST_EQ(ry, y, u32);

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_remove_at(void)
{
    AL_TEST_START("array_remove_at");

    array(u32) arr;
    al_array_init(u32)(&arr);
    al_array_reserve(u32)(&arr, 12);

    u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
    u32 array_after[] = { 2, 3, 4 };

    for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
        al_array_push(u32)(&arr, &array_before[i]);
    }

    al_array_remove_at(u32)(&arr, 0);
    al_array_remove_at(u32)(&arr, 3);
    al_array_remove_at(u32)(&arr, 3);

    AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);

    for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
        AL_TEST_EQ(*al_array_at(u32)(&arr, i), array_after[i], u32);
    }

    al_array_free(u32)(&arr);

    AL_TEST_END();
}

static bool array_test_pop_at(void)
{
    AL_TEST_START("array_pop_at");

    array(u32, 64) arr;
    al_array_init(u32, 64)(&arr);

    u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
    u32 array_after[] = { 2, 3, 4 };

    for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
        al_array_push(u32, 64)(&arr, &array_before[i]);
    }

    u32 x, y, z;

    al_array_pop_at(u32, 64)(&arr, 0, &x);
    al_array_pop_at(u32, 64)(&arr, 3, &y);
    al_array_pop_at(u32, 64)(&arr, 3, &z);

    AL_TEST_EQ(x, array_before[0], u32);
    AL_TEST_EQ(y, array_before[4], u32);
    AL_TEST_EQ(z, array_before[5], u32);

    AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);

    for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
        AL_TEST_EQ(*al_array_at(u32, 64)(&arr, i), array_after[i], u32);
    }

    al_array_free(u32, 64)(&arr);

    AL_TEST_END();
}

static bool array_test_insert(void)
{
    AL_TEST_START("array_insert");

    array(test_t, 16) arr;
    al_array_init(test_t, 16)(&arr);

    struct test_t x = {
        .i = 5
    };

    struct test_t y = {
        .i = 5
    };

    struct test_t z = {
        .i = 5
    };

    al_array_insert(test_t, 16)(&arr, 1, &x);
    al_array_insert(test_t, 16)(&arr, 0, &y);
    al_array_insert(test_t, 16)(&arr, 1, &z);

    AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 3)->i, x.i, u32);
    AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 0)->i, y.i, u32);
    AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 1)->i, z.i, u32);

    AL_TEST_EQ(arr.size, 4, u32);

    al_array_remove_at(test_t, 16)(&arr, 3);

    AL_TEST_EQ(arr.size, 3, u32);

    AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 0)->i, y.i, u32);
    AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 1)->i, z.i, u32);

    al_array_free(test_t, 16)(&arr);

    AL_TEST_END();
}

bool array_typed_tests_run(void)
{
    AL_TEST_START_GROUP("array_typed");

    AL_TEST_RUN(array_test_init);
    AL_TEST_RUN(array_test_reserve);
    AL_TEST_RUN(array_test_at);
    AL_TEST_RUN(array_test_last);
    AL_TEST_RUN(array_test_push);
    AL_TEST_RUN(array_test_pop);
    AL_TEST_RUN(array_test_remove_at);
    AL_TEST_RUN(array_test_pop_at);
    AL_TEST_RUN(array_test_insert);

    AL_TEST_END_GROUP();
}