#include "test/driver.h"
#include "lib/linked_list.h"
#include "test/test_case.h"
#include "lib/sxtdlib.h"

typedef struct
{
    linked_list_node_t lnode;
    int val;
} my_list_node;

static bool validate_list(linked_list_t *list)
{
    bool result = true;
    // list_head_test
    if (list->head != NULL)
    {
        result = result && (list->head->prev == NULL);
    }
    else
    {
        result = result && (list->tail == NULL);
    }

    if (list->tail != NULL)
    {
        result = result && (list->tail->next == NULL);
    }
    else
    {
        result = result && (list->head == NULL);
    }

    return result;
}


static bool assert_list(linked_list_t *list, int val[], int size)
{
    linked_list_node_t *node = lb_linked_list_first(list);
    int i = 0;

    if (!validate_list(list))
        return false;

    while (node != NULL && i < size)
    {
        my_list_node *enode = OBTAIN_STRUCT_ADDR(node, my_list_node, lnode);
        if (enode->val != val[i])
        {
            return false;
        }
        i++;
        node = lb_linked_list_next(node);
    }

    if (i != size)
    {
        return false;
    }

    node = lb_linked_list_last(list);
    while (node != NULL && i >= 0)
    {
        my_list_node *enode = OBTAIN_STRUCT_ADDR(node, my_list_node, lnode);
        if (enode->val != val[i - 1])
        {
            return false;
        }
        i--;
        node = lb_linked_list_prev(node);
    }

    return i == 0;
}

//void print_validate(linked_list_t *list)
//{
//    my_list_node* node = (my_list_node*) linked_list_first(list);
//    while(node != NULL)
//    {
//        hal_printf("%d", node->val);
//        node = (my_list_node*) linked_list_next((linked_list_node_t *) node);
//    }
//
//    hal_printf("======");
//    node = (my_list_node*) linked_list_last(list);
//    while(node != NULL)
//    {
//        hal_printf("%d", node->val);
//        node = (my_list_node*) linked_list_prev((linked_list_node_t *) node);
//    }
//
//    validate_list(list);
//    hal_printf("\n");
//    return;
//}

static void insert_val(linked_list_t *list, int index, int val)
{
    my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
    a->val = val;
    lb_linked_list_insert(list, index, &a->lnode);
}

static void push_back_val(linked_list_t *list, int val)
{
    my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
    a->val = val;
    lb_linked_list_push_back(list, &a->lnode);
}

static void push_front_val(linked_list_t *list, int val)
{
    my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
    a->val = val;
    lb_linked_list_push_front(list, &a->lnode);
}


static bool insert_test_beginning(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);
    insert_val(&list, 0, 0);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 2);
    insert_val(&list, 0, 3);

    // 3210==0123
    int val[4] = {3, 2, 1, 0};
    return assert_list(&list, val, 4);
}

static bool insert_test_middle(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 0);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 2);

    insert_val(&list, 1, 4);
    insert_val(&list, 1, 5);
    insert_val(&list, 2, 6);

    int val[] = {2, 5, 6, 4, 1, 0};
    return assert_list(&list, val, 6);
}

static bool insert_test_end(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    int val[] = {0, 1, 2, 3};
    return assert_list(&list, val, 4);
}

static bool insert_test_invalid(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 3);
    insert_val(&list, 0, 2);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 0);

    // large index
    insert_val(&list, 5, 9);
    insert_val(&list, 6, 9);
    insert_val(&list, 999, 9);

    // small index
    insert_val(&list, -1, 8);
    insert_val(&list, -2, 8);
    insert_val(&list, -999, 8);

    // NULL
    insert_val(NULL, 1, 4);
    lb_linked_list_insert_ref(NULL, list.head, list.tail);
    lb_linked_list_insert_ref(&list, list.head, NULL);

    int val[] = {0, 1, 2, 3};
    return assert_list(&list, val, 4);
}


static bool remove_test_beginning(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);
    insert_val(&list, 0, 0);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 2);
    insert_val(&list, 0, 3);

    lb_linked_list_remove(&list, 0);
    lb_linked_list_remove(&list, 0);

    // 10==01
    int val[] = {1, 0};
    return assert_list(&list, val, 2);
}

static bool remove_test_middle(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 0);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 2);

    insert_val(&list, 0, 3);
    insert_val(&list, 0, 4);
    insert_val(&list, 0, 5);

    lb_linked_list_remove(&list, 1);
    lb_linked_list_remove(&list, 2);

    // 5310=====0135
    int val[] = {5, 3, 1, 0};
    return assert_list(&list, val, 4);
}

static bool remove_test_end(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    lb_linked_list_remove(&list, 3);
    lb_linked_list_remove(&list, 2);

    int val[] = {0, 1};
    return assert_list(&list, val, 2);
}

static bool remove_test_all(void)
{
    bool result = true;
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    lb_linked_list_remove(&list, 0);
    lb_linked_list_remove(&list, 0);
    lb_linked_list_remove(&list, 0);
    lb_linked_list_remove(&list, 0);

    result = result && assert_list(&list, NULL, 0);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    lb_linked_list_remove(&list, 3);
    lb_linked_list_remove(&list, 2);
    lb_linked_list_remove(&list, 1);
    lb_linked_list_remove(&list, 0);

    result = result && assert_list(&list, NULL, 0);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    lb_linked_list_remove(&list, 1);
    lb_linked_list_remove(&list, 1);
    lb_linked_list_remove(&list, 1);
    lb_linked_list_remove(&list, 0);

    result = result && assert_list(&list, NULL, 0);

    return result;
}

static bool remove_test_invalid(void)
{
    linked_list_t list;
    lb_linked_list_init(&list);

    insert_val(&list, 0, 3);
    insert_val(&list, 0, 2);
    insert_val(&list, 0, 1);
    insert_val(&list, 0, 0);

    // large index
    lb_linked_list_remove(&list, 5);
    lb_linked_list_remove(&list, 6);
    lb_linked_list_remove(&list, 999);

    // small index
    lb_linked_list_remove(&list, -1);
    lb_linked_list_remove(&list, -2);
    lb_linked_list_remove(&list, -999);

    // NULL
    lb_linked_list_remove(NULL, 1);
    lb_linked_list_remove_ref(NULL, list.head);
    lb_linked_list_remove_ref(&list, NULL);

    // 0123=====3210
    int val[] = {0, 1, 2, 3};
    return assert_list(&list, val, 4);
}

static bool size_test(void)
{
    bool result = true;
    linked_list_t list;
    lb_linked_list_init(&list);
    linked_list_t list2;
    lb_linked_list_init(&list2);

    insert_val(&list, 0, 0);
    insert_val(&list, 1, 1);
    insert_val(&list, 2, 2);
    insert_val(&list, 3, 3);

    result = result && (lb_linked_list_size(&list) == 4 && lb_linked_list_size(&list2) == 0 &&
            lb_linked_list_size(NULL) == -1);
    int val[] = {0, 1, 2, 3};
    result = result && assert_list(&list, val, 4);
    return result;
}

static bool push_pop_front_test(void)
{
    bool result = true;
    linked_list_t list;
    lb_linked_list_init(&list);

    push_front_val(&list, 1);
    push_front_val(&list, 2);
    push_front_val(&list, 3);
    push_front_val(&list, 4);

    //4321==1234
    int val1[] = {4, 3, 2, 1};
    result = result && assert_list(&list, val1, 4);

    lb_linked_list_pop_front(&list);
    //321==123
    int val2[] = {3, 2, 1};
    result = result && assert_list(&list, val2, 3);

    lb_linked_list_pop_front(&list);
    lb_linked_list_pop_front(&list);
    lb_linked_list_pop_front(&list);

    result = result && assert_list(&list, NULL, 0);
    return result;
}

static bool push_pop_back_test(void)
{
    bool result = true;
    linked_list_t list;
    lb_linked_list_init(&list);

    push_back_val(&list, 1);
    push_back_val(&list, 2);
    push_back_val(&list, 3);
    push_back_val(&list, 4);

    //1234==4321
    int val1[] = {1, 2, 3, 4};
    result = result && assert_list(&list, val1, 4);

    lb_linked_list_pop_back(&list);
    //123==321
    int val2[] = {1, 2, 3};
    result = result && assert_list(&list, val2, 3);

    lb_linked_list_pop_back(&list);
    lb_linked_list_pop_back(&list);
    lb_linked_list_pop_back(&list);

    result = result && assert_list(&list, NULL, 0);
    return result;
}

static int32_t equals(void *a, void *b)
{
    return ((int64_t) (linked_list_node_t*)b) ==
           OBTAIN_STRUCT_ADDR((linked_list_node_t*)a, my_list_node, lnode)->val;
}

static bool search_test(void)
{
    bool result = true;
    linked_list_t list;
    lb_linked_list_init(&list);

    push_back_val(&list, 1);
    push_back_val(&list, 2);
    push_back_val(&list, 3);
    push_back_val(&list, 4);

    int val1[] = {1, 2, 3, 4};
    result = result && assert_list(&list, val1, 4);

    result = result && (lb_linked_list_search(&list, (void *) 4, equals) == 3);
    result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 3, equals) == 2);
    result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 2, equals) == 1);
    result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 1, equals) == 0);

    result = result && (lb_linked_list_search(&list, NULL, equals) == -1);
    result = result && (lb_linked_list_search(NULL, (linked_list_node_t *) 1, equals) == -1);

    linked_list_node_t *node = lb_linked_list_get(&list, 1);
    result = result && (lb_linked_list_search(&list, node, NULL) == 1);


    result = result && assert_list(&list, val1, 4);

    return result;
}


void KABI linked_list_test(void)
{
    test_begin("Linked list test");
    run_case("insert_test_beginning", insert_test_beginning());
    run_case("insert_test_middle", insert_test_middle());
    run_case("insert_test_end", insert_test_end());
    run_case("insert_test_invalid", insert_test_invalid());

    run_case("remove_test_beginning", remove_test_beginning());
    run_case("remove_test_middle", remove_test_middle());
    run_case("remove_test_end", remove_test_end());
    run_case("remove_test_invalid", remove_test_invalid());

    run_case("size_test", size_test());

    run_case("remove_test_all", remove_test_all());

    run_case("push_pop_front_test", push_pop_front_test());
    run_case("push_pop_back_test", push_pop_back_test());

    run_case("search_test", search_test());
    test_end();
}