#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;

}