#include "../Tests.h"
#include "core/LinkedList.h"
#include "core/Utility.h"

static void testAdd() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 5);
    CoreLinkedListNode* current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(5, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(1, list.length);
    coreDestroyLinkedList(&list);
}

static void testMultipleAdd() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 4);
    coreLinkedListAdd(&list, size_t, 3);
    coreLinkedListAdd(&list, size_t, 2);
    CoreLinkedListNode* current = list.first;
    CORE_TEST_SIZE(4, coreLinkedListGet(current, size_t));
    current = current->next;
    CORE_TEST_SIZE(3, coreLinkedListGet(current, size_t));
    current = current->next;
    CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
    CORE_TEST_SIZE(3, list.length);
    coreDestroyLinkedList(&list);
}

static void testClear() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 5);
    coreLinkedListAdd(&list, size_t, 4);
    coreClearLinkedList(&list);
    CORE_TEST_SIZE(0, list.length);
    CORE_TEST_NULL(list.first);
    CORE_TEST_NULL(list.last);
    coreDestroyLinkedList(&list);
}

static void testBigAdd(bool light) {
    size_t limit = light ? 10000 : 100000;
    CoreLinkedList list = CORE_LINKED_LIST;
    for(size_t i = 0; i < limit; i++) {
        coreLinkedListAdd(&list, size_t, i);
    }
    CoreLinkedListNode* current = list.first;
    for(size_t i = 0; i < list.length; i++) {
        CORE_TEST_SIZE(i, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    CORE_TEST_SIZE(limit, list.length);
    coreDestroyLinkedList(&list);
}

static void testToString1() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 1);
    coreLinkedListAdd(&list, size_t, 243);
    coreLinkedListAdd(&list, size_t, 423);
    char buffer[128];
    size_t n =
        coreToStringLinkedList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(13, n);
    CORE_TEST_STRING("[1, 243, 423]", buffer);
    coreDestroyLinkedList(&list);
}

static void testToString2() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 1);
    char buffer[128];
    size_t n =
        coreToStringLinkedList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(3, n);
    CORE_TEST_STRING("[1]", buffer);
    coreDestroyLinkedList(&list);
}

static void testToString3() {
    CoreLinkedList list = CORE_LINKED_LIST;
    char buffer[128];
    size_t n =
        coreToStringLinkedList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(2, n);
    CORE_TEST_STRING("[]", buffer);
    coreDestroyLinkedList(&list);
}

static void testRemove() {
    CoreLinkedList list = CORE_LINKED_LIST;
    CoreLinkedListNode* a = coreLinkedListAdd(&list, size_t, 4u);
    CoreLinkedListNode* b = coreLinkedListAdd(&list, size_t, 3u);
    CoreLinkedListNode* c = coreLinkedListAdd(&list, size_t, 2u);
    CoreLinkedListNode* d = coreLinkedListAdd(&list, size_t, 1u);
    CORE_TEST_NOT_NULL(a);
    CORE_TEST_NOT_NULL(b);
    CORE_TEST_NOT_NULL(c);
    CORE_TEST_NOT_NULL(d);

    coreLinkedListRemove(&list, b);
    CoreLinkedListNode* current = list.first;
    CORE_TEST_SIZE(4, coreLinkedListGet(current, size_t));
    current = current->next;
    CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
    current = current->next;
    CORE_TEST_SIZE(1, coreLinkedListGet(current, size_t));
    CORE_TEST_SIZE(3, list.length);

    coreLinkedListRemove(&list, a);
    current = list.first;
    CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
    current = current->next;
    CORE_TEST_SIZE(1, coreLinkedListGet(current, size_t));
    CORE_TEST_SIZE(2, list.length);

    coreLinkedListRemove(&list, d);
    current = list.first;
    CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
    CORE_TEST_SIZE(1, list.length);

    coreLinkedListRemove(&list, c);
    CORE_TEST_NULL(list.first);
    CORE_TEST_NULL(list.last);
    CORE_TEST_SIZE(0, list.length);

    coreDestroyLinkedList(&list);
}

static void testRemoveFirst() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 4u);
    coreLinkedListAdd(&list, size_t, 3u);
    coreLinkedListAdd(&list, size_t, 2u);
    coreLinkedListAdd(&list, size_t, 1u);

    coreLinkedListRemoveFirst(&list);
    CoreLinkedListNode* current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(3, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(1, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(3, list.length);

    coreLinkedListRemoveFirst(&list);
    current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(1, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(2, list.length);

    coreLinkedListRemoveFirst(&list);
    current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(1, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(1, list.length);

    coreLinkedListRemoveFirst(&list);
    CORE_TEST_NULL(list.first);
    CORE_TEST_NULL(list.last);
    CORE_TEST_SIZE(0, list.length);

    coreDestroyLinkedList(&list);
}

static void testRemoveLast() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 4u);
    coreLinkedListAdd(&list, size_t, 3u);
    coreLinkedListAdd(&list, size_t, 2u);
    coreLinkedListAdd(&list, size_t, 1u);

    coreLinkedListRemoveLast(&list);
    CoreLinkedListNode* current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(4, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(3, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(2, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(3, list.length);

    coreLinkedListRemoveLast(&list);
    current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(4, coreLinkedListGet(current, size_t));
        current = current->next;
    }
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(3, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(2, list.length);

    coreLinkedListRemoveLast(&list);
    current = list.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(4, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(1, list.length);

    coreLinkedListRemoveLast(&list);
    CORE_TEST_NULL(list.first);
    CORE_TEST_NULL(list.last);
    CORE_TEST_SIZE(0, list.length);

    coreDestroyLinkedList(&list);
}

static void testSwap() {
    CoreLinkedList list = CORE_LINKED_LIST;
    coreLinkedListAdd(&list, size_t, 5);
    CoreLinkedList swap = CORE_LINKED_LIST;
    coreSwapLinkedList(&list, &swap);

    CoreLinkedListNode* current = swap.first;
    if(CORE_TEST_NOT_NULL(current)) {
        CORE_TEST_SIZE(5, coreLinkedListGet(current, size_t));
    }
    CORE_TEST_SIZE(0, list.length);
    CORE_TEST_SIZE(1, swap.length);

    coreDestroyLinkedList(&swap);
    coreDestroyLinkedList(&list);
}

void coreTestLinkedList(bool light) {
    testAdd();
    testMultipleAdd();
    testClear();
    testBigAdd(light);
    testToString1();
    testToString2();
    testToString3();
    testRemove();
    testRemoveFirst();
    testRemoveLast();
    testSwap();
}