#include <check.h>
#include <string.h>
#include "ucore/htable.h"
#include "ucore/utils.h"

struct MyString {
    char str[32];
    struct UHNode node;
};

size_t hash_str(const char *str)
{
    size_t hash = 31;
    while (*str) {
        hash *= *str++;
    }

    return hash;
}

size_t bad_hash(const char *str)
{
    return str[0];
}

struct MyString *my_find(struct UHTable *table, const char *str, size_t hash)
{
    struct UHNode *it;

    UC_HTABLE_FOREACH_HASH(table, it, hash) {
        struct MyString *my_str = UC_CONTAINER_OF(it, struct MyString, node);
        if (strcmp(my_str->str, str) == 0) {
            return my_str;
        }
    }

    return NULL;
}



START_TEST (test_htable1)
{
    struct MyString str[5] = {
        {"One",  {0,NULL}},
        {"Two",  {0,NULL}},
        {"Three",{0,NULL}},
        {"Four", {0,NULL}},
        {"Five", {0,NULL}}
    };
    struct UHTable table;
    int i;

    uc_htable_init(&table, 3);

    for (i = 0; i < 5; i++) {
        uc_htable_insert(&table, &str[i].node, hash_str(str[i].str));
    }

    ck_assert_int_eq(uc_htable_count(&table), 5);

    fail_if(my_find(&table, "One",  hash_str("One"))   != &str[0]);
    fail_if(my_find(&table, "Two",  hash_str("Two"))   != &str[1]);
    fail_if(my_find(&table, "Three",hash_str("Three")) != &str[2]);
    fail_if(my_find(&table, "Four", hash_str("Four"))  != &str[3]);
    fail_if(my_find(&table, "Five", hash_str("Five"))  != &str[4]);
    fail_if(my_find(&table, "NotHere", hash_str("NotHere"))  != NULL);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_hash_collision)
{
 //same as test1 but with a bad hash to force equal hash
    struct MyString str[5] = {
        {"...",  {0,NULL}},
        {"",     {0,NULL}},
        {".",    {0,NULL}},
        {"..",   {0,NULL}},
        {"....", {0,NULL}}
    };
    struct UHTable table;
    int i;

    uc_htable_init(&table, 1);

    for (i = 0; i < 5; i++) {
        uc_htable_insert(&table, &str[i].node, bad_hash(str[i].str));
    }

    ck_assert_int_eq(uc_htable_count(&table), 5);

    fail_if(my_find(&table, "....", bad_hash("...."))  != &str[4]);
    fail_if(my_find(&table, ".",    bad_hash("."))     != &str[2]);
    fail_if(my_find(&table, "",     bad_hash(""))      != &str[1]);
    fail_if(my_find(&table, "..",   bad_hash(".."))    != &str[3]);
    fail_if(my_find(&table, "...",  bad_hash("..."))   != &str[0]);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_resize)
{
    struct MyString str[5] = {
        {"One",  {0,NULL}},
        {"Two",  {0,NULL}},
        {"Three",{0,NULL}},
        {"Four", {0,NULL}},
        {"Five", {0,NULL}}
    };
    struct UHTable table;
    int i;
    int rc;

    rc = uc_htable_init(&table, 3);
    ck_assert_int_eq(rc, 0);

    for (i = 0; i < 5; i++) {
        uc_htable_insert(&table, &str[i].node, hash_str(str[i].str));
    }
    ck_assert_int_eq(uc_htable_count(&table), 5);

    rc = uc_htable_resize(&table, 1024);
    ck_assert_int_eq(rc, 0);

    ck_assert_int_eq(uc_htable_count(&table), 5);

    fail_if(my_find(&table, "One",  hash_str("One"))   != &str[0]);
    fail_if(my_find(&table, "Two",  hash_str("Two"))   != &str[1]);
    fail_if(my_find(&table, "Three",hash_str("Three")) != &str[2]);
    fail_if(my_find(&table, "Four", hash_str("Four"))  != &str[3]);
    fail_if(my_find(&table, "Five", hash_str("Five"))  != &str[4]);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_fail_init_resize)
{
    int rc;
    struct UHTable table;
    rc = uc_htable_init(&table, 0);
    ck_assert_int_ne(rc, 0);

    rc = uc_htable_init(&table, 1);
    ck_assert_int_eq(rc, 0);

    rc = uc_htable_resize(&table, 0);
    ck_assert_int_ne(rc, 0);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_has_node)
{
    struct MyString str1 =  {"One",  {0,NULL}};
    struct MyString str2 =  {"Two",  {0,NULL}};

    struct UHTable table;
    int rc;

    rc = uc_htable_init(&table, 3);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    ck_assert_int_eq(uc_htable_count(&table), 1);

    rc = uc_htable_has_node(&table, &str1.node);
    ck_assert_int_ne(rc, 0);

    rc = uc_htable_has_node(&table, &str2.node);
    ck_assert_int_eq(rc, 0);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_remove)
{
    struct MyString str1 =  {"One",  {0,NULL}};
    struct MyString str2 =  {"One",  {0,NULL}};
    struct MyString str3 =  {"Other",  {0,NULL}};

    struct UHTable table;
    int rc;

    rc = uc_htable_init(&table, 1);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    uc_htable_insert(&table, &str2.node, hash_str(str2.str));
    uc_htable_insert(&table, &str3.node, hash_str(str3.str));
    ck_assert_int_eq(uc_htable_count(&table), 3);

    uc_htable_remove(&table, &str2.node);
    ck_assert_int_eq(uc_htable_count(&table), 2);

    //this one should still be here
    fail_if(my_find(&table, "One",  hash_str("One"))   != &str1);
    //
    //thisone should be gone
    rc = uc_htable_has_node(&table, &str2.node);
    ck_assert_int_eq(rc, 0);


    uc_htable_remove(&table, &str1.node);
    ck_assert_int_eq(uc_htable_count(&table), 1);

    //now this one should be gone
    rc = uc_htable_has_node(&table, &str1.node);
    ck_assert_int_eq(rc, 0);

    //double removal should be ok
    uc_htable_remove(&table, &str1.node);
    ck_assert_int_eq(uc_htable_count(&table), 1);

    //this one should still be here
    fail_if(my_find(&table, "Other",  hash_str("Other"))   != &str3);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_remove_foreach)
{
    struct MyString str1 =  {"One",  {0,NULL}};
    struct MyString str2 =  {"One",  {0,NULL}};
    struct MyString str3 =  {"Other",  {0,NULL}};

    struct UHTable table;
    struct UHNode *it;
    struct UHNode *next;
    int rc;
    int removed = 0;

    rc = uc_htable_init(&table, 1);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    uc_htable_insert(&table, &str2.node, hash_str(str2.str));
    uc_htable_insert(&table, &str3.node, hash_str(str3.str));
    ck_assert_int_eq(uc_htable_count(&table), 3);

    fail_if(my_find(&table, "One",  hash_str("One"))  == NULL);

    UC_HTABLE_FOREACH_HASH_SAFE(&table, it, next, hash_str("One")) {
        uc_htable_remove(&table, it);
        memset(it, 0xff, sizeof *it);
        removed++;

    }

    ck_assert_int_eq(removed, 2);

    fail_if(my_find(&table, "One",  hash_str("One")) != NULL);
    fail_if(my_find(&table, "Other",  hash_str("Other")) != &str3);
    ck_assert_int_eq(uc_htable_count(&table), 1);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_clear)
{
    struct MyString str1 =  {"One",  {0,NULL}};

    struct UHTable table;
    int rc;

    rc = uc_htable_init(&table, 100);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    ck_assert_int_eq(uc_htable_count(&table), 1);

    fail_if(my_find(&table, "One",  hash_str("One"))   != &str1);

    uc_htable_clear(&table);
    ck_assert_int_eq(uc_htable_count(&table), 0);
    fail_if(my_find(&table, "One",  hash_str("One"))   != NULL);

    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_foreach)
{
    struct MyString str1 =  {"One",  {0,NULL}};
    struct MyString str2 =  {"One",  {0,NULL}};
    struct MyString str3 =  {"Other",{0,NULL}};

    struct UHTable table;
    struct UHNode *it;
    int rc;
    int found1 = 0;
    int found2 = 0;
    int found3 = 0;

    rc = uc_htable_init(&table, 1000);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    uc_htable_insert(&table, &str2.node, hash_str(str2.str));
    uc_htable_insert(&table, &str3.node, hash_str(str3.str));
    ck_assert_int_eq(uc_htable_count(&table), 3);
    
    UC_HTABLE_FOREACH(&table, it) {
        struct MyString *my_str = UC_CONTAINER_OF(it, struct MyString, node);
        if (my_str == &str1) {
            found1++;
        }
        if (my_str == &str2) {
            found2++;
        }
        if (my_str == &str3) {
            found3++;
        }
    }

    ck_assert_int_eq(found1, 1);
    ck_assert_int_eq(found2, 1);
    ck_assert_int_eq(found3, 1);


    uc_htable_destroy(&table);

}
END_TEST

START_TEST (test_htable_foreach_safe)
{
    struct MyString str1 =  {"One",  {0,NULL}};
    struct MyString str2 =  {"One",  {0,NULL}};
    struct MyString str3 =  {"Other",{0,NULL}};

    struct UHTable table;
    struct UHNode *it;
    struct UHNode *next;
    int rc;

    rc = uc_htable_init(&table, 1000);
    ck_assert_int_eq(rc, 0);

    uc_htable_insert(&table, &str1.node, hash_str(str1.str));
    uc_htable_insert(&table, &str2.node, hash_str(str2.str));
    uc_htable_insert(&table, &str3.node, hash_str(str3.str));

    fail_if(my_find(&table, "Other",  hash_str("Other"))   != &str3);

    ck_assert_int_eq(uc_htable_count(&table), 3);
    
    UC_HTABLE_FOREACH_SAFE(&table, it, next) {
        uc_htable_remove(&table, it);
        memset(it, 0xff, sizeof *it);
    }

    fail_if(my_find(&table, "One",  hash_str("One"))   != NULL);
    fail_if(my_find(&table, "Other",  hash_str("Other"))   != NULL);

    ck_assert_int_eq(uc_htable_count(&table), 0);

    uc_htable_destroy(&table);

}
END_TEST

Suite *htable_suite(void)
{
    Suite *s = suite_create("htable");
    TCase *tc = tcase_create("htable tests");

    tcase_add_test(tc, test_htable1);
    tcase_add_test(tc, test_htable_hash_collision);
    tcase_add_test(tc, test_htable_resize);
    tcase_add_test(tc, test_htable_fail_init_resize);
    tcase_add_test(tc, test_htable_has_node);
    tcase_add_test(tc, test_htable_remove);
    tcase_add_test(tc, test_htable_remove_foreach);
    tcase_add_test(tc, test_htable_clear);
    tcase_add_test(tc, test_htable_foreach);
    tcase_add_test(tc, test_htable_foreach_safe);


    suite_add_tcase(s, tc);

    return s;
}