#include <al/test.h>
#include <al/array.h>
#include <al/random.h>

#include "array.h"

struct test_t {
    u32 i;
};

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

    array(u32) arr;
    al_array_init(arr);

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

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);

    al_array_reserve(arr, 64);

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

    al_array_reserve(arr, 128);

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

    al_array_reserve(arr, 129);

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

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);

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

    AL_TEST_EQ(al_array_at(arr, 0), 5, u32);

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);

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

    al_array_push(arr, x);
    al_array_push(arr, y);
    al_array_push(arr, z);

    AL_TEST_EQ(al_array_last(arr), 3, u32);

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);

    u32 x = 4, y = 5;

    al_array_push(arr, x);
    al_array_push(arr, y);

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

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);

    u32 x = 4, y = 5;

    al_array_push(arr, x);
    al_array_push(arr, y);

    u32 rx, ry;

    ry = al_array_pop(arr);

    AL_TEST_EQ(arr.size, 1, u32);

    rx = al_array_pop(arr);

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

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(arr);
    al_array_reserve(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(arr, array_before[i]);
    }

    al_array_remove_at(arr, 0);
    al_array_remove_at(arr, 3);
    al_array_remove_at(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(arr, i), array_after[i], u32);
    }

    al_array_free(arr);

    AL_TEST_END();
}

static bool array_test_remove_range(void)
{
    AL_TEST_START("array_remove_range");

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

    u32 array_before[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
    u32 array_after[] = { 1, 3, 4, 7, 8, 11 };

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

    al_array_remove_range(arr, 1, 2);
    al_array_remove_range(arr, 3, 5);
    AL_TEST_EQ(arr.size, 9, u32);
    al_array_remove_range(arr, 5, 7);
    AL_TEST_EQ(arr.size, 7, u32);
    al_array_remove_range(arr, 6, 7);

    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(arr, i), array_after[i], u32);
    }

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(u32) arr;
    al_array_init(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(arr, array_before[i]);
    }

    u32 x, y, z;

    al_array_pop_at(arr, 0, x);
    al_array_pop_at(arr, 3, y);
    al_array_pop_at(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(arr, i), array_after[i], u32);
    }

    al_array_free(arr);

    AL_TEST_END();
}

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

    array(struct test_t) arr;
    al_array_init(arr);

    struct test_t x = {
        .i = 5
    };

    struct test_t y = {
        .i = 5
    };

    struct test_t z = {
        .i = 5
    };

    al_array_insert(arr, 1, x);
    al_array_insert(arr, 0, y);
    al_array_insert(arr, 1, z);

    AL_TEST_EQ(al_array_at(arr, 3).i, x.i, u32);
    AL_TEST_EQ(al_array_at(arr, 0).i, y.i, u32);
    AL_TEST_EQ(al_array_at(arr, 1).i, z.i, u32);

    AL_TEST_EQ(arr.size, 4, u32);

    al_array_remove_at(arr, 3);

    AL_TEST_EQ(arr.size, 3, u32);

    AL_TEST_EQ(al_array_at(arr, 0).i, y.i, u32);
    AL_TEST_EQ(al_array_at(arr, 1).i, z.i, u32);

    al_array_free(arr);

    AL_TEST_END();
}

static bool array_test_foreach(void)
{
    AL_TEST_START("array_foreach");

    array(u32) arr;
    al_array_init(arr);

    al_array_push(arr, 0);
    al_array_push(arr, 1);
    al_array_push(arr, 2);
    al_array_push(arr, 3);
    al_array_push(arr, 4);
    al_array_push(arr, 5);

    u32 iter0;
    al_array_foreach(arr, i, iter0) {
        AL_TEST_EQ(iter0, i, u32);
    }

    u32 iter1;
    al_array_foreach_rev(arr, i, iter1) {
        AL_TEST_EQ(iter1, i, u32);
    }

    u32 *ptr0;
    al_array_foreach_ptr(arr, i, ptr0) {
        AL_TEST_EQ(*ptr0, i, u32);
    }

    u32 iter2;
    al_array_foreach_rev(arr, i, iter2) {
        AL_TEST_EQ(iter2, i, u32);
        al_array_remove_at(arr, i);
    }

    AL_TEST_EQ(arr.size, 0, u32);

    al_array_push(arr, 0);
    al_array_push(arr, 1);
    al_array_push(arr, 2);
    al_array_push(arr, 3);
    al_array_push(arr, 4);
    al_array_push(arr, 5);
    al_array_push(arr, 6);
    al_array_push(arr, 7);
    al_array_push(arr, 8);
    al_array_push(arr, 9);

    u32 iter3, count0 = 0;
    al_array_foreach(arr, i, iter3) {
        AL_TEST_EQ(iter3, count0, u32);
        count0++;
        al_array_remove_at_iter(arr, i);
    }

    al_array_push(arr, 0);
    al_array_push(arr, 1);
    al_array_push(arr, 2);
    al_array_push(arr, 3);
    al_array_push(arr, 4);
    al_array_push(arr, 5);
    al_array_push(arr, 6);
    al_array_push(arr, 7);
    al_array_push(arr, 8);
    al_array_push(arr, 9);

    u32 iter4;
    al_array_foreach(arr, i, iter4) {
        AL_TEST_EQ(iter4, i + i, u32);
        al_array_remove_at(arr, i);
    }

    al_array_free(arr);

    AL_TEST_END();
}

static s32 int32_compare(const void *a, const void *b)
{
    if (*(s32 *)a < *(s32 *)b) return 1;
    else if (*(s32 *)b < *(s32 *)a) return -1;
    return 0;
}

static bool array_test_sort(void)
{
    AL_TEST_START("array_sort");

    array(s32) arr;
    al_array_init(arr);

    s32 end = al_rand() % 2000;
    for (s32 i = 0; i < end; i++) {
        al_array_push(arr, al_rand());
    }

    al_array_sort(arr, s32, int32_compare);

    for (u32 i = 1; i < arr.size; i++) {
        AL_TEST_GTE(al_array_at(arr, i - 1), al_array_at(arr, i), s32);
    }

    AL_TEST_END();
}

bool array_tests_run(void)
{
    AL_TEST_START_GROUP("array");

    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_remove_range);
    AL_TEST_RUN(array_test_pop_at);
    AL_TEST_RUN(array_test_insert);
    AL_TEST_RUN(array_test_foreach);
    AL_TEST_RUN(array_test_sort);

    AL_TEST_END_GROUP();
}