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

#include "array_typed.h"
#include "common.h"

AL_IGNORE_WARNING("-Wunused-function")

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

AL_IGNORE_WARNING_END

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

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

    AL_TEST_EQ(ints.count, 0, u32);
    AL_TEST_EQ(ints.alloc, 256, u32);
    AL_TEST_EQ(ints.data, NULL, ptr);
    AL_TEST_EQ(sizeof(ints.inline_data), 64 * sizeof(u32), size_t);

    al_array_free(u32, 64)(&ints);
    // Not a double-free.
    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

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

    al_array_reserve(u32, 64)(&ints, 64);
    AL_TEST_EQ(ints.alloc, 256, u32);
    AL_TEST_EQ(ints.data, NULL, ptr);

    al_array_reserve(u32, 64)(&ints, 128);
    AL_TEST_EQ(ints.alloc, 512, u32);
    AL_TEST_NEQ(ints.data, NULL, ptr);

    al_array_reserve(u32, 64)(&ints, 129);
    AL_TEST_EQ(ints.alloc, 1024, u32);
    AL_TEST_NEQ(ints.data, NULL, ptr);

    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

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

    u32 x = 5;
    al_array_push(u32, 64)(&ints, x);
    al_array_push(u32, 64)(&ints, (u32)4);

    AL_TEST_EQ(*al_array_at(u32, 64)(&ints, 0), 5, u32);
    AL_TEST_EQ(*al_array_at(u32, 64)(&ints, 1), 4, u32);
    AL_TEST_EQ(ints.count, 2, u32);
    AL_TEST_EQ(ints.alloc, 256, u32);

    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

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

    u32 x = 1, y = 2, z = 3;
    al_array_push(u32, 64)(&ints, x);
    al_array_push(u32, 64)(&ints, y);
    al_array_push(u32, 64)(&ints, z);

    AL_TEST_EQ(*al_array_last(u32, 64)(&ints), 3, u32);
    AL_TEST_EQ(ints.count, 3, u32);
    AL_TEST_EQ(ints.alloc, 256, u32);

    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

    array(u8) bytes;
    al_array_init(u8)(&bytes);

    for (u32 i = 0; i < MAX_ALLOC_32; i++) {
        al_array_push(u8)(&bytes, (u8)1);
    }
    AL_TEST_EQ(bytes.count, MAX_ALLOC_32, u32);
    AL_TEST_EQ(bytes.alloc, MAX_ALLOC_32, u32);

    AL_TEST_EQ(al_array_at(u8)(&bytes, MAX_ALLOC_32 - 1), al_array_last(u8)(&bytes), ptr);
    AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 2), 1, u8);
    AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 3), 1, u8);
    AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 4), 1, u8);

    al_array_free(u8)(&bytes);

    AL_TEST_END();
}

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

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

    u32 x = 4, y = 5;
    al_array_push(u32, 64)(&ints, x);
    al_array_push(u32, 64)(&ints, y);

    u32 rx, ry;

    al_array_pop(u32, 64)(&ints, &ry);
    AL_TEST_EQ(ints.count, 1, u32);

    al_array_pop(u32, 64)(&ints, &rx);
    AL_TEST_EQ(ints.count, 0, u32);

    AL_TEST_EQ(rx, x, u32);
    AL_TEST_EQ(ry, y, u32);

    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

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

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

    for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
        al_array_push(u32)(&ints, array_before[i]);
    }

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

    AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);

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

    al_array_free(u32)(&ints);

    AL_TEST_END();
}

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

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

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

    for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
        al_array_push(u32, 64)(&ints, array_before[i]);
    }

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

    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(ints.count, ARRAY_SIZE(array_after), u32);

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

    al_array_free(u32, 64)(&ints);

    AL_TEST_END();
}

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

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

    struct test_t x = { .d = 5 };
    struct test_t y = { .d = 2 };
    struct test_t z = { .d = 6 };

    al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 7 });
    al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 9 });
    al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 444 });

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

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

    AL_TEST_EQ(objects.count, 6, u32);

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

    AL_TEST_EQ(objects.count, 5, u32);

    AL_TEST_NEQ(al_array_at(test_t, 16)(&objects, 0)->d, x.d, u32);
    AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 0)->d, y.d, u32);
    AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 1)->d, z.d, u32);

    al_array_free(test_t, 16)(&objects);

    AL_TEST_END();
}

bool array_typed_tests_run(u32 skip_mask)
{
    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);
    if (skip_mask & AL_TESTS_RUN_LIMITS) {
        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();
}