/*
  C++ to libhashkit
*/

#include <libtest/common.h>

#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <libhashkit/hashkit.hpp>

#include "hash_results.h"

static test_return_t exists_test(void *obj)
{
  Hashkit hashk;
  (void)obj;
  (void)hashk;

  return TEST_SUCCESS;
}

static test_return_t new_test(void *obj)
{
  Hashkit *hashk= new Hashkit;
  (void)obj;

  (void)hashk;

  delete hashk;

  return TEST_SUCCESS;
}

static test_return_t copy_test(void *obj)
{
  Hashkit *hashk= new Hashkit;
  Hashkit *copy(hashk);
  (void)obj;

  (void)copy;

  delete hashk;

  return TEST_SUCCESS;
}

static test_return_t assign_test(void *obj)
{
  Hashkit hashk;
  Hashkit copy;
  (void)obj;

  copy= hashk;

  (void)copy;

  return TEST_SUCCESS;
}

static test_return_t digest_test(void *obj)
{
  Hashkit hashk;
  uint32_t value;
  (void)obj;

  value= hashk.digest("Foo", sizeof("Foo"));

  return TEST_SUCCESS;
}

static test_return_t set_function_test(void *)
{
  Hashkit hashk;
  hashkit_hash_algorithm_t algo_list[]= { 
    HASHKIT_HASH_DEFAULT,
    HASHKIT_HASH_MD5,
    HASHKIT_HASH_CRC,
    HASHKIT_HASH_FNV1_64,
    HASHKIT_HASH_FNV1A_64,
    HASHKIT_HASH_FNV1_32,
    HASHKIT_HASH_FNV1A_32,
    HASHKIT_HASH_MURMUR,
    HASHKIT_HASH_JENKINS,
    HASHKIT_HASH_MAX
  };


  for (hashkit_hash_algorithm_t *algo= algo_list; *algo != HASHKIT_HASH_MAX; algo++)
  {
    hashkit_return_t rc= hashk.set_function(*algo);

    test_compare(HASHKIT_SUCCESS, rc);

    uint32_t *list;
    switch (*algo)
    {
    case HASHKIT_HASH_DEFAULT:
      list= one_at_a_time_values;
      break;

    case HASHKIT_HASH_MD5:
      list= md5_values;
      break;

    case HASHKIT_HASH_CRC:
      list= crc_values;
      break;

    case HASHKIT_HASH_FNV1_64:
      list= fnv1_64_values;
      break;

    case HASHKIT_HASH_FNV1A_64:
      list= fnv1a_64_values;
      break;

    case HASHKIT_HASH_FNV1_32:
      list= fnv1_32_values;
      break;

    case HASHKIT_HASH_FNV1A_32:
      list= fnv1a_32_values;
      break;

    case HASHKIT_HASH_HSIEH:
#ifndef HAVE_HSIEH_HASH
      continue;
#endif
      list= hsieh_values;
      break;

    case HASHKIT_HASH_MURMUR:
#ifdef WORDS_BIGENDIAN
      continue;
#endif
#ifndef HAVE_MURMUR_HASH
      continue;
#endif
      list= murmur_values;
      break;

    case HASHKIT_HASH_JENKINS:
      list= jenkins_values;
      break;

    case HASHKIT_HASH_CUSTOM:
    case HASHKIT_HASH_MAX:
    default:
      list= NULL;
      test_fail("We ended up on a non-existent hash");
    }

    // Now we make sure we did set the hash correctly.
    uint32_t x;
    const char **ptr;
    for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
    {
      uint32_t hash_val;

      hash_val= hashk.digest(*ptr, strlen(*ptr));
      char buffer[1024];
      snprintf(buffer, sizeof(buffer), "%lu %lus %s", (unsigned long)list[x], (unsigned long)hash_val, libhashkit_string_hash(*algo));
      test_true_got(list[x] == hash_val, buffer);
    }
  }

  return TEST_SUCCESS;
}

static test_return_t set_distribution_function_test(void *obj)
{
  Hashkit hashk;
  hashkit_return_t rc;
  (void)obj;

  rc= hashk.set_distribution_function(HASHKIT_HASH_CUSTOM);
  test_true_got(rc == HASHKIT_FAILURE or rc == HASHKIT_INVALID_ARGUMENT, hashkit_strerror(NULL, rc));

  rc= hashk.set_distribution_function(HASHKIT_HASH_JENKINS);
  test_true(rc == HASHKIT_SUCCESS);

  return TEST_SUCCESS;
}

static test_return_t compare_function_test(void *obj)
{
  Hashkit a, b;
  (void)obj;

  b= a;
  
  test_true(a == b);

  b.set_function(HASHKIT_HASH_MURMUR);

  test_false(a == b);
  test_true(b == b);
  test_true(a == a);

  return TEST_SUCCESS;
}

test_st basic[] ={
  { "exists", 0, reinterpret_cast<test_callback_fn*>(exists_test) },
  { "new", 0, reinterpret_cast<test_callback_fn*>(new_test) },
  { "copy", 0, reinterpret_cast<test_callback_fn*>(copy_test) },
  { "assign", 0, reinterpret_cast<test_callback_fn*>(assign_test) },
  { "digest", 0, reinterpret_cast<test_callback_fn*>(digest_test) },
  { "set_function", 0, reinterpret_cast<test_callback_fn*>(set_function_test) },
  { "set_distribution_function", 0, reinterpret_cast<test_callback_fn*>(set_distribution_function_test) },
  { "compare", 0, reinterpret_cast<test_callback_fn*>(compare_function_test) },
  { 0, 0, 0}
};

collection_st collection[] ={
  {"basic", 0, 0, basic},
  {0, 0, 0, 0}
};

void get_world(Framework *world)
{
  world->collections= collection;
}