/* SPDX-License-Identifier: BSD-3-Clause */
/*
 * Copyright © 2010, Zed A. Shaw.
 * Copyright © 2020 rsiddharth <s@ricketyspace.net>
 */

#include "minunit.h"
#include <hashmap.h>
#include <assert.h>
#include <bstrlib.h>

Hashmap *map = NULL;
Hashmap *map_alt = NULL;
static int traverse_called = 0;
static int traverse_duplicates = 0;
struct tagbstring test0 = bsStatic("test data 0");
struct tagbstring test1 = bsStatic("test data 1");
struct tagbstring test2 = bsStatic("test data 2");
struct tagbstring test3 = bsStatic("xest data 3");
struct tagbstring expect0 = bsStatic("THE VALUE 0");
struct tagbstring expect1 = bsStatic("THE VALUE 1");
struct tagbstring expect2 = bsStatic("THE VALUE 2");
struct tagbstring expect3 = bsStatic("THE VALUE 3");

static int traverse_good_cb(HashmapNode *node)
{
    debug("KEY: %s", bdata((bstring) node->key));
    traverse_called++;
    return 0;
}

static int traverse_fail_cb(HashmapNode *node)
{
    debug("KEY %s", bdata((bstring) node->key));
    traverse_called++;

    if (traverse_called == 2) {
        return 1;
    } else {
        return 0;
    }
}

static int traverse_duplicates_cb(HashmapNode *node)
{
    if ((bstring) node->data == &expect1) {
        ++traverse_duplicates;
    }

    return 0;
}

int non_empty_buckets(Hashmap *map)
{
    int i = 0, non_empty = 0;

    for (i = 0; i < DArray_count(map->buckets); i++) {
        DArray *bucket = DArray_get(map->buckets, i);
        if (bucket) {
            non_empty += 1;
        }
    }

    return non_empty;
}

char *test_create()
{
    map = Hashmap_create(NULL, NULL);
    mu_assert(map != NULL, "Failed to create map.");

    map_alt = Hashmap_create(NULL, (Hashmap_hash) fnv_hash);
    mu_assert(map != NULL, "Failde to create map_alt.");

    return NULL;
}

char *test_destroy()
{
    Hashmap_destroy(map);
    Hashmap_destroy(map_alt);
    return NULL;
}

char *test_get_test()
{
    int rc = Hashmap_set(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set &test1");
    bstring result = Hashmap_get(map, &test1);
    mu_assert(result == &expect1, "Wron value for test1.");

    rc = Hashmap_set(map, &test2, &expect2);
    mu_assert(rc == 0, "Failed to test test2");
    result = Hashmap_get(map, &test2);
    mu_assert(result == &expect2, "Wrong value for test2.");

    rc = Hashmap_set(map, &test3, &expect3);
    mu_assert(rc == 0, "Failed to set test3");
    result = Hashmap_get(map, &test3);
    mu_assert(result == &expect3, "Wrong value for test3");

    return NULL;
}

char *test_traverse()
{
    int rc = Hashmap_traverse(map, traverse_good_cb);
    mu_assert(rc == 0, "Failed to traverse");
    mu_assert(traverse_called == 3, "Wrong count traverse");

    traverse_called = 0;
    rc = Hashmap_traverse(map, traverse_fail_cb);
    mu_assert(rc == 1, "Failed to traverse.");
    mu_assert(traverse_called == 2, "Wrong count traverse for fail.");

    return NULL;
}

char *test_keys()
{
    DArray *keys = Hashmap_keys(map);
    mu_assert(keys != NULL, "Unable to get hashmap's keys");
    mu_assert(DArray_count(keys) == 3, "Expected three keys");

    for (int i = 0; i < DArray_count(keys); i++) {
        char *k = bdata((bstring) DArray_get(keys, i));

        debug("KEY: %s", k);
    }

    // clean up.
    DArray_destroy(keys);

    return NULL;
}

char *test_delete()
{
    bstring deleted = (bstring) Hashmap_delete(map, &test1);
    mu_assert(deleted != NULL, "Got NULL on delete");
    mu_assert(deleted == &expect1, "Should get test1");
    bstring result = Hashmap_get(map, &test1);
    mu_assert(result == NULL, "Should delete");

    deleted = (bstring) Hashmap_delete(map, &test2);
    mu_assert(deleted != NULL, "Got NULL on delete");
    mu_assert(deleted == &expect2, "Should get test2");
    result = Hashmap_get(map, &test2);
    mu_assert(result == NULL, "Should delete");

    deleted = (bstring) Hashmap_delete(map, &test3);
    mu_assert(deleted != NULL, "Got NULL on delete.");
    mu_assert(deleted == &expect3, "Should get test3");
    result = Hashmap_get(map, &test3);
    mu_assert(result == NULL, "Should delete.");

    return NULL;
}

char *test_bucket_destruction()
{
    int rc = 0, non_empty = 0;
    bstring deleted  = NULL;

    // Insert some elements.
    rc = Hashmap_set(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set &test1 0");
    rc = Hashmap_set(map, &test2, &expect2);
    mu_assert(rc == 0, "Failed to test test2");

    // Non-empty buckets test.
    non_empty = non_empty_buckets(map);
    mu_assert(non_empty == 2, "Expected two non-empty buckets");

    // Remove test1
    deleted = Hashmap_delete(map, &test1);
    mu_assert(deleted != NULL, "Error deleting test1");

    // Non-empty buckets test.
    non_empty = non_empty_buckets(map);
    mu_assert(non_empty == 1, "Expected one non-empty buckets");

    // Remove test2
    deleted = Hashmap_delete(map, &test2);
    mu_assert(deleted != NULL, "Error deleting test2");

    // Non-empty buckets test.
    non_empty = non_empty_buckets(map);
    mu_assert(non_empty == 0, "Expected one non-empty buckets");

    return NULL;
}

char *test_set_duplicates()
{
    int rc = 0;

    // Insert test1 two times.
    rc = Hashmap_set(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set &test1 0");
    rc = Hashmap_set(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set &test1 1");

    // Insert test2 one time.
    rc = Hashmap_set(map, &test2, &expect2);
    mu_assert(rc == 0, "Failed to test test2");

    // Insert test3 one time.
    rc = Hashmap_set(map, &test3, &expect3);
    mu_assert(rc == 0, "Failed to set test3");

    // Test there are two test1 nodes.
    traverse_duplicates = 0;
    rc = Hashmap_traverse(map, traverse_duplicates_cb);
    mu_assert(traverse_duplicates == 2,
              "traverse_duplicates must be 2");

    // Cleanup
    bstring deleted  = NULL;
    deleted = Hashmap_delete(map, &test1);
    mu_assert(deleted != NULL, "Error deleting test1 0");
    deleted  = Hashmap_delete(map, &test1);
    mu_assert(deleted != NULL, "Error deleting test1 1");
    deleted  = Hashmap_delete(map, &test2);
    mu_assert(deleted != NULL, "Error deleting test2");
    deleted  = Hashmap_delete(map, &test3);
    mu_assert(deleted != NULL, "Error deleting test3");

    return NULL;
}

char *test_set_fucked()
{
    int rc = 0;

    // Insert test1 three times.
    rc = Hashmap_set_fucked(map, &test1, &expect1);
    mu_assert(rc == 1, "Failed to set fuck &test1 0");
    rc = Hashmap_set_fucked(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set fuck &test1 1");
    rc = Hashmap_set_fucked(map, &test1, &expect1);
    mu_assert(rc == 0, "Failed to set fuck &test1 2");

    // Insert test2 one time.
    rc = Hashmap_set_fucked(map, &test2, &expect2);
    mu_assert(rc == 1, "Failed to test test2");

    // Insert test3 one time.
    rc = Hashmap_set_fucked(map, &test3, &expect3);
    mu_assert(rc == 1, "Failed to set test3");

    // Test there are two test1 nodes.
    traverse_duplicates = 0;
    rc = Hashmap_traverse(map, traverse_duplicates_cb);
    mu_assert(traverse_duplicates == 1,
              "traverse_duplicates must be 1");

    // Cleanup
    bstring deleted  = NULL;
    deleted = Hashmap_delete(map, &test1);
    mu_assert(deleted != NULL, "Error deleting test1");
    deleted  = Hashmap_delete(map, &test1);
    mu_assert(deleted == NULL, "Error test1 must be already deleted");
    deleted  = Hashmap_delete(map, &test2);
    mu_assert(deleted != NULL, "Error deleting test2");
    deleted  = Hashmap_delete(map, &test3);
    mu_assert(deleted != NULL, "Error deleting test3");

    return NULL;
}

char *test_fnv_hash()
{
    uint32_t hash[3];

    hash[0] = fnv_hash(&test0);
    mu_assert(hash[0] > 0, "hash not set correctly for key test0");

    hash[1] = fnv_hash(&test1);
    mu_assert(hash[1] > 0, "hash not set correctly for key test1");

    hash[2] = fnv_hash(&test2);
    mu_assert(hash[2] > 0, "hash not set correctly for key test2");

    // Check all three hashes are different.
    mu_assert(hash[0] != hash[1], "hash for test0 = hash for test1");
    mu_assert(hash[0] != hash[2], "hash for test0 = hash for test2");
    mu_assert(hash[1] != hash[2], "hash for test1 = hash for test2");

    return NULL;
}

char *all_tests()
{
    mu_suite_start();

    mu_run_test(test_create);
    mu_run_test(test_get_test);
    mu_run_test(test_traverse);
    mu_run_test(test_keys);
    mu_run_test(test_delete);
    mu_run_test(test_bucket_destruction);
    mu_run_test(test_set_duplicates);
    mu_run_test(test_set_fucked);
    mu_run_test(test_fnv_hash);
    mu_run_test(test_destroy);

    return NULL;
}

RUN_TESTS(all_tests);