#include <string.h>

 #include <KeHashTable.h>

 using namespace Knight;

 struct KeHashNode

 {

 	KeHashNode *next;

 	uint32_t key_hash;

 	const void *key;

 	void *value;

 };

 namespace Knight

 {

 	class KeHashTable

 	{

 	public:

 		KeHashNode **buckets;

 		uint32_t num_buckets;

 		uint32_t shift;

 		uint32_t num_entries;

 		KeHashGenerator key_gen;

 		KeHashMarshal key_m;

 		KeHashMarshal val_m;

 		ke_allocator_t *node_alloc;

 		size_t key_offs;

 		size_t val_offs;

 		size_t node_size;

 		uint32_t grow_limit;

 		KeHashNode *free_list;

 		bool keep_free_list;

 	};

 }

 void *ke_DefHashMalloc(ke_allocator_t *alloc, size_t amt)

 {

 	return malloc(amt);

 }

 void ke_DefHashFree(ke_allocator_t *alloc, void *addr)

 {

 	free(addr);

 }

 ke_allocator_t s_DefHashAllocator = 

 {

 	ke_DefHashMalloc,

 	ke_DefHashFree,

 	NULL

 };

 KeHashTable *Knight::KE_CreateHashTable(

 	uint32_t bits,

 	KeHashGenerator key_gen,

 	const KeHashMarshal *key_marshal,

 	const KeHashMarshal *val_marshal,

 	ke_allocator_t *nodeAlloc,

 	bool keep_free_list)

 {

 	KeHashTable *table;

 	if (bits >= 27)

 	{

 		bits = 26;

 	}

 	else if (bits < 4)

 	{

 		bits = 4;

 	}

 	/* Validate marshals. */

 	if ((key_marshal->bytes != 0

 		 && key_marshal->ctor == NULL)

 		|| (val_marshal->bytes != 0

 			&& val_marshal->ctor == NULL))

 	{

 		return NULL;

 	}

 	table = new KeHashTable;

 	table->key_gen = key_gen;

 	table->key_m = *key_marshal;

 	table->val_m = *val_marshal;

 	table->num_entries = 0;

 	table->shift = 32 - bits;

 	table->node_alloc = nodeAlloc == NULL ? &s_DefHashAllocator : nodeAlloc;

 	table->num_buckets = (1 << bits);

 	table->grow_limit = (uint32_t)(0.9f * table->num_buckets);

 	table->keep_free_list = keep_free_list;

 	table->free_list = NULL;

 	table->buckets = (KeHashNode **)malloc(sizeof(KeHashNode *) * table->num_buckets);

 	memset(table->buckets, 0, sizeof(KeHashNode *) * table->num_buckets);

 	table->key_offs = sizeof(KeHashNode);

 	if (table->key_m.bytes != 0 && table->key_m.bytes % 8 != 0)

 	{

 		table->key_m.bytes += 8;

 		table->key_m.bytes -= (table->key_m.bytes % 8);

 	}

 	table->val_offs = table->key_offs + table->key_m.bytes;

 	table->node_size = table->val_offs + table->val_m.bytes;

 	return table;

 }

 #define KE_GET_BUCKET(tbl, hsh) (&(tbl)->buckets[((hsh) * 0x9E3779B9) >> (tbl)->shift])

 KeHashNode **ke_HashInternalFind(KeHashTable *table, uint32_t key_hash, const void *key)

 {

 	KeHashNode *node;

 	KeHashNode **bucket;

 	bucket = KE_GET_BUCKET(table, key_hash);

 	/* :TODO: move to the front once found? */

 	while ((node = *bucket) != NULL)

 	{

 		if (node->key_hash == key_hash

 			&& ((table->key_m.cmp != NULL && table->key_m.cmp(node->key, key))

 				 || node->key == key))

 		{

 			return bucket;

 		}

 		bucket = &node->next;

 	}

 	return bucket;

 }

 void ke_ResizeHashTable(KeHashTable *table, uint32_t new_shift)

 {

 	uint32_t entries;

 	KeHashNode *next;

 	KeHashNode *node;

 	KeHashNode **rbucket;

 	KeHashNode **old_buckets;

 	uint32_t old_num_buckets;

 	/* Save old data */

 	old_num_buckets = table->num_buckets;

 	old_buckets = table->buckets;

 	entries = table->num_entries;

 	/* Save new data */

 	table->num_buckets = (1 << new_shift);

 	table->shift = 32 - new_shift;

 	table->grow_limit = (uint32_t)(0.9f * table->num_buckets);

 	table->buckets = (KeHashNode **)malloc(sizeof(KeHashNode *) * table->num_buckets);

 	memset(table->buckets, 0, sizeof(KeHashNode *) * table->num_buckets);

 	/* For each old bucket... */

 	for (uint32_t i = 0;

 		 i < old_num_buckets && entries != 0;

 		 i++)

 	{

 		node = old_buckets[i];

 		/* Get each item in its list... */

 		while (node != NULL)

 		{

 			next = node->next;

 			/* Find the new replacement bucket it needs to go in. */

 			rbucket = KE_GET_BUCKET(table, node->key_hash);

 			/* Link this node to the next node in the new bucket. */

 			if (*rbucket == NULL)

 			{

 				node->next = NULL;

 			}

 			else

 			{

 				node->next = *rbucket;

 			}

 			/* Add us to the front of that bucket's list. */

 			*rbucket = node;

 			node = next;

 		}

 	}

 	free(old_buckets);

 }

 void Knight::KE_AddToHashTable(KeHashTable *table, const void *key, void *val)

 {

 	KeHashNode *node;

 	uint32_t key_hash;

 	KeHashNode **bucket;

 	key_hash = table->key_gen(key);

 	bucket = ke_HashInternalFind(table, key_hash, key);

 	if ((node = *bucket) != NULL)

 	{

 		/* Already in the table */

 		if ((table->val_m.cmp != NULL && table->val_m.cmp(node->value, val))

 			 || node->value == val)

 		{

 			return;

 		}

 		/* Destroy old value if it's set. */

 		if (node->value != NULL && table->val_m.dtor != NULL)

 		{

 			table->val_m.dtor(node->value);

 		}

 		/* Construct or set the new value. */

 		if (table->val_m.bytes != 0)

 		{

 			table->val_m.ctor(node->value, val);

 		}

 		else

 		{

 			node->value = val;

 		}

 		return;

 	}

 	/* If we're overloaded, we may need to resize. 

 	 * Right now, we do this if we hit a .9 entry:buckets ratio.

 	 */

 	if (table->num_entries >= table->grow_limit)

 	{

 		ke_ResizeHashTable(table, table->shift << 1);

 		bucket = ke_HashInternalFind(table, key_hash, key);

 	}

 	if (table->free_list != NULL)

 	{

 		node = table->free_list;

 		table->free_list = node->next;

 	}

 	else

 	{

 		node = (KeHashNode *)table->node_alloc->alloc(table->node_alloc, table->node_size);

 	}

 	if (table->key_m.bytes == 0)

 	{

 		node->key = key;

 	}

 	else

 	{

 		node->key = (char *)node + table->key_offs;

 		table->key_m.ctor((void *)node->key, key);

 	}

 	if (table->val_m.bytes == 0)

 	{

 		node->value = val;

 	}

 	else

 	{

 		node->value = (char *)node + table->val_offs;

 		table->val_m.ctor(node->value, val);

 	}

 	node->next = *bucket;

 	node->key_hash = key_hash;

 	*bucket = node;

 }

 inline void ke_CleanUpHashNode(KeHashTable *table, KeHashNode *node)

 {

 	/* Destroy old value if it's set. */

 	if (node->value != NULL && table->val_m.dtor != NULL)

 	{

 		table->val_m.dtor(node->value);

 	}

 	/* Destroy the key. */

 	if (table->key_m.dtor != NULL)

 	{

 		table->key_m.dtor(node->key);

 	}

 	/* Deallocate us as appropriate. */

 	if (table->keep_free_list)

 	{

 		node->next = table->free_list;

 		table->free_list = node;

 	}

 	else

 	{

 		table->node_alloc->dealloc(table->node_alloc, node);

 	}

 }

 void Knight::KE_RemoveFromHashTable(KeHashTable *table, const void *key)

 {

 	KeHashNode *node;

 	uint32_t key_hash;

 	KeHashNode **bucket;

 	key_hash = table->key_gen(key);

 	bucket = ke_HashInternalFind(table, key_hash, key);

 	if ((node = *bucket) == NULL)

 	{

 		return;

 	}

 	/* Link the bucket to its next (removing us). */

 	*bucket = node->next;

 	ke_CleanUpHashNode(table, node);

 }

 bool Knight::KE_FindInHashTable(KeHashTable *table, const void *key, void **value)

 {

 	KeHashNode *node;

 	uint32_t key_hash;

 	KeHashNode **bucket;

 	key_hash = table->key_gen(key);

 	bucket = ke_HashInternalFind(table, key_hash, key);

 	if ((node = *bucket) == NULL)

 	{

 		return false;

 	}

 	if (value != NULL)

 	{

 		*value = node->value;

 	}

 	return true;

 }

 void Knight::KE_DestroyHashTable(KeHashTable *table)

 {

 	KeHashNode *node, *next;

 	/* Turn off this caching! */

 	table->keep_free_list = false;

 	/* Find entries in buckets that need to be freed. */

 	for (uint32_t i = 0; i < table->num_buckets; i++)

 	{

 		node = table->buckets[i];

 		while (node != NULL)

 		{

 			next = node->next;

 			ke_CleanUpHashNode(table, node);

 			node = next;

 		}

 	}

 	/* Free the free list */

 	while (table->free_list != NULL)

 	{

 		next = table->free_list->next;

 		ke_CleanUpHashNode(table, table->free_list);

 		table->free_list = next;

 	}

 	/* Destroy everything now. */

 	free(table->buckets);

 	delete table;

 }

 void Knight::KE_ClearHashTable(KeHashTable *table)

 {

 	KeHashNode *node, *next;

 	/* Free every entry in the table. */

 	for (uint32_t i = 0; i < table->num_buckets; i++)

 	{

 		node = table->buckets[i];

 		while (node != NULL)

 		{

 			next = node->next;

 			ke_CleanUpHashNode(table, node);

 			node = next;

 		}

 	}

 }

 #if defined _MSC_VER && (defined _M_IX86 || defined _M_AMD64 || defined _M_X64)

 #pragma intrinsic(_rotl)

 #endif

 uint32_t Knight::KE_HashString(const void *str)

 {

 	uint32_t h;

 	const unsigned char *us;

 	h = 0;

 	for (us = (const unsigned char *)str; *us != 0; us++)

 	{

 #if defined _MSC_VER && (defined _M_IX86 || defined _M_AMD64 || defined _M_X64)

 		h = _rotl(h, 4) ^ *us;

 #else

 		h = ((h << 4) | (h >> 28)) ^ *us;

 #endif

 	}

 	return h;

 }

 bool Knight::KE_AreStringsEqual(const void* str1, const void* str2)

 {

     return (strcmp((const char*)str1, (const char*)str2) == 0) ? true : false;

 }