#include <criterion/criterion.h>

#include "tupperware/list.h"

TestSuite(list, .timeout = 15);

struct int_list {
    int val;
    struct list_node list;
};

Test(list, init_null) {
    list_init(NULL);
}

Test(list, init) {
    struct list l = { (void *)0x42 };
    list_init(&l);

    cr_assert_null(l.head);
}

static void int_list_dtor(struct list_node *list, void *cookie) {
    size_t *count = cookie;

    struct int_list *l = CONTAINER_OF(struct int_list, list, list);
    cr_assert_eq(l->val, ++*count);
}

Test(list, clear_null) {
    size_t count = 0;

    list_clear(NULL, int_list_dtor, &count);
    cr_assert_eq(count, 0);

    struct list l = { NULL };
    list_clear(&l, int_list_dtor, &count);


    cr_assert_eq(count, 0);
}

Test(list, clear_one) {
    struct int_list list = { 1, { &list.list, &list.list } };
    struct list l = { &list.list };

    size_t count = 0;
    list_clear(&l, int_list_dtor, &count);

    cr_assert_eq(count, 1);
    cr_assert_null(l.head);
}

static void init_list_arr(struct int_list *list_arr, size_t n, int offset) {
    for (size_t i = 0; i < n; ++i) {
        list_arr[i].val = i + 1 + offset;
        list_arr[i].list.next = &list_arr[(i + 1) % n].list;
        list_arr[(i + 1) % n].list.prev = &list_arr[i].list;
    }
}

static void assert_list(struct int_list *list_arr, size_t n, int offset) {
    for (size_t i = 0; i < n; ++i) {
        cr_assert_eq(list_arr[i]. val, i + 1 + offset);
        cr_assert_eq(list_arr[i].list.next, &list_arr[(i + 1) % n].list);
        cr_assert_eq(list_arr[(i + 1) % n].list.prev, &list_arr[i % n].list);
    }
}

#define ARR_SIZE(Arr) (sizeof(Arr) / sizeof(*Arr))

Test(list, clear_multiples) {
    struct int_list arr[10];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list l = { &arr[0].list };

    size_t count = 0;
    list_clear(&l, int_list_dtor, &count);

    cr_assert_eq(count, ARR_SIZE(arr));
    cr_assert_null(l.head);
}

Test(list, node_insert_prev_null) {
    list_node_insert_prev(NULL, NULL);

    struct list_node l = { NULL, NULL };
    list_node_insert_prev(&l, NULL);
    list_node_insert_prev(NULL, &l);
}

Test(list, node_insert_prev_one) {
    struct int_list arr[] = {
        { 1, { NULL, NULL, }, },
        { 2, { NULL, NULL, }, },
    };
    init_list_arr(arr + 1, ARR_SIZE(arr) - 1, 1);

    list_node_insert_prev(&arr[1].list, &arr[0].list);

    assert_list(arr, ARR_SIZE(arr), 0);
}

Test(list, node_insert_prev) {
    struct int_list arr[] = {
        { 1, { NULL, NULL, }, },
        { 2, { NULL, NULL, }, },
        { 3, { NULL, NULL, }, },
    };
    init_list_arr(arr + 1, ARR_SIZE(arr) - 1, 1);

    list_node_insert_prev(&arr[1].list, &arr[0].list);

    assert_list(arr, ARR_SIZE(arr), 0);
}

Test(list, node_insert_next_null) {
    list_node_insert_next(NULL, NULL);

    struct list_node l;
    list_node_insert_next(&l, NULL);
    list_node_insert_next(NULL, &l);
}

Test(list, node_insert_next_one) {
    struct int_list arr[] = {
        { 1, { NULL, NULL, }, },
        { 2, { NULL, NULL, }, },
    };
    init_list_arr(arr, ARR_SIZE(arr) - 1, 0);

    list_node_insert_next(
            &arr[ARR_SIZE(arr) - 2].list, &arr[ARR_SIZE(arr) - 1].list);

    assert_list(arr, ARR_SIZE(arr), 0);
}

Test(list, node_insert_next) {
    struct int_list arr[] = {
        { 1, { NULL, NULL, }, },
        { 2, { NULL, NULL, }, },
        { 3, { NULL, NULL, }, },
    };
    init_list_arr(arr, ARR_SIZE(arr) - 1, 0);

    list_node_insert_next(
            &arr[ARR_SIZE(arr) - 2].list, &arr[ARR_SIZE(arr) - 1].list);

    assert_list(arr, ARR_SIZE(arr), 0);
}

Test(list, node_detach_null) {
    cr_assert_null(list_node_detach(NULL));
}

Test(list, node_detach_one) {
    struct int_list l = { 0, { &l.list, &l.list } };

    struct list_node *n = list_node_detach(&l.list);

    cr_assert_eq(n, &l.list);
    cr_assert_eq(n->next, n);
    cr_assert_eq(n->prev, n);
}

Test(list, node_detach) {
    struct int_list arr[3];
    init_list_arr(arr, ARR_SIZE(arr), 0);

    struct list_node *n = list_node_detach(&arr[0].list);

    cr_assert_eq(n, &arr[0].list);
    cr_assert_eq(n->next, n);
    cr_assert_eq(n->prev, n);

    assert_list(arr + 1, ARR_SIZE(arr) - 1, 1);
}

Test(list, node_detach_back) {
    struct int_list arr[3];
    init_list_arr(arr, ARR_SIZE(arr), 0);

    struct list_node *n = list_node_detach(&arr[2].list);

    cr_assert_eq(n, &arr[2].list);
    cr_assert_eq(n->next, n);
    cr_assert_eq(n->prev, n);

    assert_list(arr, ARR_SIZE(arr) - 1, 0);
}

Test(list, node_safe_detach_null) {
    cr_assert_null(list_node_safe_detach(NULL));
}

Test(list, node_safe_detach_null_pointed) {
    struct list_node *n = NULL;
    cr_assert_null(list_node_safe_detach(&n));
}

Test(list, node_safe_detach_one) {
    struct int_list l = { 0, { &l.list, &l.list } };
    struct list_node *n = &l.list;

    cr_assert_eq(list_node_safe_detach(&n), &l.list);
    cr_assert_null(n);
}

Test(list, node_safe_detach) {
    struct int_list arr[3];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list_node *n = &arr[0].list;

    cr_assert_eq(list_node_safe_detach(&n), &arr[0].list);
    cr_assert_eq(n, &arr[1].list);

    assert_list(arr + 1, ARR_SIZE(arr) - 1, 1);
}

Test(list, pop_front_null) {
    cr_assert_null(list_pop_front(NULL));

    struct list l = { NULL };
    cr_assert_null(list_pop_front(&l));
}

Test(list, pop_front_one) {
    struct int_list list = { 1, { &list.list, &list.list } };
    struct list l = { &list.list };

    cr_assert_eq(list_pop_front(&l), &list.list);
    cr_assert_null(l.head);
}

Test(list, pop_front) {
    struct int_list arr[5];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list l = { &arr[0].list };

    cr_assert_eq(list_pop_front(&l), &arr[0].list);
    assert_list(arr + 1, ARR_SIZE(arr) - 1, 1);
}

Test(list, pop_back_null) {
    cr_assert_null(list_pop_front(NULL));

    struct list l = { NULL };
    cr_assert_null(list_pop_front(&l));
}

Test(list, pop_back_one) {
    struct int_list list = { 1, { &list.list, &list.list } };
    struct list l = { &list.list };

    cr_assert_eq(list_pop_back(&l), &list.list);
    cr_assert_null(l.head);
}

Test(list, pop_back) {
    struct int_list arr[5];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list l = { &arr[0].list };

    cr_assert_eq(list_pop_back(&l), &arr[ARR_SIZE(arr) - 1].list);
    assert_list(arr, ARR_SIZE(arr) - 1, 0);
}

Test(list, empty_null) {
    cr_assert(list_empty(NULL));
}

Test(list, empty_none) {
    cr_assert(list_empty(&(struct list){ NULL }));
}

Test(list, empty_one) {
    struct int_list l = { 0, { &l.list, &l.list } };

    cr_assert_not(list_empty(&(struct list){ &l.list }));
}

Test(list, length_null) {
    cr_assert_eq(list_length(NULL), 0);
}

Test(list, length_one) {
    struct int_list l = { 0, { &l.list, &l.list } };

    cr_assert_eq(list_length(&(struct list){ &l.list }), 1);
}

Test(list, length) {
    struct int_list arr[3];
    init_list_arr(arr, ARR_SIZE(arr), 0);

    cr_assert_eq(list_length(&(struct list) { &arr[0].list }), ARR_SIZE(arr));
}

Test(list, node_concat_null) {
    list_node_concat(NULL, NULL);

    struct int_list l = { 0, {&l.list, &l.list, } };
    list_node_concat(&l.list, NULL);
    list_node_concat(NULL, &l.list);
}

Test(list, node_concat_one) {
    const size_t n = 1;
    struct int_list arr[n * 2];
    init_list_arr(arr, n * 2 - n, 0);
    init_list_arr(arr + n, n * 2 - n, n);

    list_node_concat(&arr[0].list, &arr[n].list);

    assert_list(arr, n * 2, 0);
}

Test(list, node_concat) {
    const size_t n = 3;
    struct int_list arr[n * 2];
    init_list_arr(arr, n * 2 - n, 0);
    init_list_arr(arr + n, n * 2 - n, n);

    list_node_concat(&arr[0].list, &arr[n].list);

    assert_list(arr, n * 2, 0);
}

static int int_list_cmp(const struct list_node *lhs,
        const struct list_node *rhs, void *cookie) {
    struct int_list *l = CONTAINER_OF(struct int_list, list, lhs);
    struct int_list *r = CONTAINER_OF(struct int_list, list, rhs);

    size_t *count = cookie;
    ++*count;

    if (l->val < r->val)
        return -1;
    return (l->val > r->val);
}

Test(list, insert_sorted_null) {
    list_insert_sorted(NULL, NULL, int_list_cmp, NULL);

    struct list l = { (void *)0x42 };
    list_insert_sorted(&l, NULL, int_list_cmp, NULL);
    list_insert_sorted(NULL, l.head, int_list_cmp, NULL);
}

Test(list, insert_sorted_empty) {
    struct int_list list = { 0, {NULL, NULL } };
    struct list l = { NULL };

    list_insert_sorted(&l, &list.list, int_list_cmp, NULL);

    cr_assert_eq(l.head, &list.list);
    cr_assert_eq(list.list.next, &list.list);
    cr_assert_eq(list.list.prev, &list.list);
}

Test(list, insert_sorted_one_before) {
    struct int_list arr[5] = {
        { 1, { NULL, NULL } },
    };
    init_list_arr(arr + 1, ARR_SIZE(arr) - 1, 1);
    struct list l = { &arr[1].list };

    size_t count = 0;
    list_insert_sorted(&l, &arr[0].list, int_list_cmp, &count);

    assert_list(arr, ARR_SIZE(arr), 0);
    cr_assert_eq(count, 1);
    cr_assert_eq(l.head, &arr[0].list);
}

Test(list, insert_sorted_one_after) {
    struct int_list arr[5];
    init_list_arr(arr, ARR_SIZE(arr) - 1, 0);
    arr[ARR_SIZE(arr) - 1].val = ARR_SIZE(arr);

    struct list l = { &arr[0].list };

    size_t count = 0;
    list_insert_sorted(&l, &arr[ARR_SIZE(arr) - 1].list, int_list_cmp, &count);

    assert_list(arr, ARR_SIZE(arr), 0);
    cr_assert_eq(count, ARR_SIZE(arr) - 1);
}

Test(list, sort_null) {
    size_t count = 0;
    list_sort(NULL, int_list_cmp, &count);

    cr_assert_eq(count, 0);
}


Test(list, sort_one) {
    struct int_list list = { 0, { &list.list, &list.list } };
    struct list l = { &list.list };

    size_t count = 0;
    list_sort(&l, int_list_cmp, &count);

    cr_assert_eq(count, 0);
}

Test(list, sort_sorted) {
    struct int_list arr[5];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list l = { &arr[0].list };

    size_t count = 0;
    list_sort(&l, int_list_cmp, &count);

    cr_assert_eq(l.head, &arr[0].list);
    assert_list(arr, ARR_SIZE(arr), 0);
    cr_assert_eq(count, ARR_SIZE(arr) * (ARR_SIZE(arr) - 1) / 2);
}

Test(list, sort_inverted) {
    struct int_list arr[5] = {
        { 1, { &arr[4].list, &arr[1].list } },
        { 2, { &arr[0].list, &arr[2].list } },
        { 3, { &arr[1].list, &arr[3].list } },
        { 4, { &arr[2].list, &arr[4].list } },
        { 5, { &arr[3].list, &arr[0].list } },
    };
    struct list l = { &arr[ARR_SIZE(arr) - 1].list };

    size_t count = 0;
    list_sort(&l, int_list_cmp, &count);

    cr_assert_eq(l.head, &arr[0].list);
    assert_list(arr, ARR_SIZE(arr), 0);
}

Test(list, merge_sorted_null) {
    list_merge_sorted(NULL, NULL, int_list_cmp, NULL);

    struct list l = { (void *)0x42 };
    list_merge_sorted(&l, NULL, int_list_cmp, NULL);
    list_merge_sorted(NULL, &l, int_list_cmp, NULL);
}

Test(list, merge_sorted) {
    struct int_list arr[5] = {
        { 1, { &arr[2].list, &arr[4].list } },
        { 2, { &arr[3].list, &arr[3].list } },
        { 3, { &arr[4].list, &arr[0].list } },
        { 4, { &arr[1].list, &arr[1].list } },
        { 5, { &arr[0].list, &arr[2].list } },
    };

    struct list odd = { &arr[0].list };
    struct list even = { &arr[1].list };

    size_t count = 0;
    list_merge_sorted(&odd, &even, int_list_cmp, &count);

    assert_list(arr, ARR_SIZE(arr), 0);
    cr_assert_eq(odd.head, &arr[0].list);
    cr_assert_null(even.head);
}

Test(list, merge_sorted_alternate) {
    struct int_list arr[5] = {
        { 1, { &arr[2].list, &arr[4].list } },
        { 2, { &arr[3].list, &arr[3].list } },
        { 3, { &arr[4].list, &arr[0].list } },
        { 4, { &arr[1].list, &arr[1].list } },
        { 5, { &arr[0].list, &arr[2].list } },
    };

    struct list odd = { &arr[0].list };
    struct list even = { &arr[1].list };

    size_t count = 0;
    list_merge_sorted(&even, &odd, int_list_cmp, &count);

    assert_list(arr, ARR_SIZE(arr), 0);
    cr_assert_eq(even.head, &arr[0].list);
    cr_assert_null(odd.head);
}

static void int_list_map(struct list_node *n, void *cookie) {
    size_t *count = cookie;

    struct int_list *node = CONTAINER_OF(struct int_list, list, n);
    node->val = ++*count;
}

Test(list, map_null) {
    size_t count = 0;
    list_map(NULL, int_list_map, &count);
    cr_assert_eq(count, 0);

    struct list l = { NULL };
    list_map(&l, int_list_map, &count);
    cr_assert_eq(count, 0);
}

Test(list, map) {
    struct int_list arr[5] = {
        { 0, { &arr[1].list, &arr[4].list } },
        { 0, { &arr[2].list, &arr[0].list } },
        { 0, { &arr[3].list, &arr[1].list } },
        { 0, { &arr[4].list, &arr[2].list } },
        { 0, { &arr[0].list, &arr[3].list } },
    };
    struct list l = { &arr[0].list };

    size_t count = 0;
    list_map(&l, int_list_map, &count);

    cr_assert_eq(count, ARR_SIZE(arr));
    assert_list(arr, ARR_SIZE(arr), 0);
}

static bool int_list_is_even(struct list_node *n, void *cookie) {
    size_t *count = cookie;
    ++*count;

    struct int_list *node = CONTAINER_OF(struct int_list, list, n);
    return node->val % 2 == 0;
}

Test(list, filter_null) {
    size_t count = 0;
    list_filter(NULL, NULL, int_list_is_even, &count);
    cr_assert_eq(count, 0);

    struct list l = { (void *)0x42 };
    list_filter(&l, NULL, int_list_is_even, &count);
    cr_assert_eq(count, 0);
    list_filter(NULL, &l, int_list_is_even, &count);
    cr_assert_eq(count, 0);
    l.head = NULL;
    list_filter(&l, &l, int_list_is_even, &count);
    cr_assert_eq(count, 0);
}

Test(list, filter) {
    struct int_list arr[5];
    init_list_arr(arr, ARR_SIZE(arr), 0);
    struct list l = { &arr[0].list };
    struct list res = { NULL };

    size_t count = 0;
    list_filter(&res, &l, int_list_is_even, &count);

    cr_assert_eq(count, ARR_SIZE(arr));

    size_t count_even = 0;
    LIST_FOREACH_ENTRY(const struct int_list, list, res, n) {
        cr_assert_eq(n->val, ++count_even * 2);
    }
    size_t count_odd = 0;
    LIST_FOREACH_ENTRY(const struct int_list, list, l, n) {
        cr_assert_eq(n->val, ++count_odd * 2 - 1);
    }
    cr_assert_eq(count_even + count_odd, ARR_SIZE(arr));
}