#include <stdalign.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>

#include "arraylist.h"

// INIT

static void test_init_valid_parameters(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_zero_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(0, sizeof(int));
    assert_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_zero_elem_size(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, 0);
    assert_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_large_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(SIZE_MAX, sizeof(int));
    assert_null(arr);
    arraylist_destroy(&arr);
}

// DESTROY
 
static void test_destroy_valid_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    arraylist_destroy(&arr);
    assert_null(arr);
}

static void test_destroy_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;
    ArrayListErr err = arraylist_destroy(&arr);

    assert_null(arr);
    assert_int_equal(err, ARRLIST_NULL_ARG);
}

static void test_destroy_double(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    ArrayListErr err = arraylist_destroy(&arr);
    assert_int_equal(err, ARRLIST_OK);
    assert_null(arr);

    err = arraylist_destroy(&arr);
    assert_int_equal(err, ARRLIST_NULL_ARG);
    assert_null(arr);
}

// State
static void test_capacity_after_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_int_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_is_empty_after_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_true(arraylist_is_empty(arr));

    arraylist_destroy(&arr);
}

static void test_is_empty_after_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    
    assert_false(arraylist_is_empty(arr));

    arraylist_destroy(&arr);
}

static void test_size_after_many_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_size(arr), 1);

    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_size(arr), 2);

    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_size(arr), 3);

    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_size(arr), 4);

    arraylist_destroy(&arr);
}

static void test_capacity_growth_on_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(2, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_capacity(arr), 2);

    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_capacity(arr), 2);

    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_capacity(arr), 4);

    arraylist_destroy(&arr);
}

static void test_capacity_shrink_on_pop(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(8, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_int_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_pop_back(arr, &n), ARRLIST_OK);
    assert_int_equal(arraylist_capacity(arr), 4);

    arraylist_destroy(&arr);
}

int main(void) {
    const struct CMUnitTest init[] = {
        cmocka_unit_test(test_init_valid_parameters),
        cmocka_unit_test(test_init_zero_capacity),
        cmocka_unit_test(test_init_zero_elem_size),
        cmocka_unit_test(test_init_large_capacity),
    };

    const struct CMUnitTest destroy[] = {
        cmocka_unit_test(test_destroy_valid_array),
        cmocka_unit_test(test_destroy_null_array),
        cmocka_unit_test(test_destroy_double),
    };

    const struct CMUnitTest state[] = {
        cmocka_unit_test(test_capacity_after_init),
        cmocka_unit_test(test_is_empty_after_init),
        cmocka_unit_test(test_is_empty_after_push),
        cmocka_unit_test(test_size_after_many_push),
        cmocka_unit_test(test_capacity_growth_on_push),
        cmocka_unit_test(test_capacity_shrink_on_pop),
    };

    int rc = 0;

    rc += cmocka_run_group_tests(init, NULL, NULL);
    rc += cmocka_run_group_tests(destroy, NULL, NULL);
    rc += cmocka_run_group_tests(state, NULL, NULL);

    return rc;
}