#ifndef _INCLUDE_KNIGHT_KE_HASHTABLE_H_

#define _INCLUDE_KNIGHT_KE_HASHTABLE_H_

#include <stddef.h>

#include <stdint.h>

#include <KnightAllocator.h>

namespace Knight

{

	class KeHashTable;

	/**

	 * @brief Must generate a hash function given a key.

	 *

	 * @param key				Pointer to the key.

	 * @return					Hash value.

	 */

	typedef uint32_t (*KeHashGenerator)(const void *key);

	/**

	 * @brief Must compare two values.

	 *

	 * @param val1				First value.

	 * @param val2				Second value.

	 * @return					True if equal, false if not.

	 */

	typedef bool (*KeHashComparator)(const void *val1, const void *val2);

	/**

	 * @brief Must call the destructor of the given data, and free if necessary.

	 *

	 * @param val				Pointer to data.

	 */

	typedef void (*KeHashDestructor)(const void *val);

	/**

	 * @brief Must transfer the contents of an object from the source to the destination.

	 *

	 * @param dest				Destination address.

	 * @param source			Source address.

	 */

	typedef void (*KeHashCopyCtor)(void *dest, const void *source);

	/**

	 * @brief Contains information about how to process keys and values in a hash table.

	 */

	struct KeHashMarshal

	{

		size_t bytes;				/**< Bytes of storage needed (0 to use pointers). */

		KeHashComparator cmp;		/**< Comparator (if NULL, void * comparison used) */

		KeHashDestructor dtor;		/**< Optional function for performing dtor cleanup. */

		KeHashCopyCtor ctor;		/**< If bytes != 0, must be a valid function 

										 (ignored otherwise). */

	};

	/**

	 * @brief Creates a new hash table structure.

	 *

	 * @param bits				Dictates starting number of buckets as a power of two.

	 *							Pass 0 for the default (which is 4).

	 * @param key_gen			Key generation function.

	 * @param key_marshal		Structure detailing how to marshal keys.

	 * @param vak_marshal		Structure detailing how to marshal values.

	 * @param nodeAlloc			Node allocator (can be NULL for malloc/free).

	 * @param keep_free_list	True to keep a free list of nodes, false otherwise.

	 * @return					New hash table container.

	 */

	extern KeHashTable *KE_CreateHashTable(

		uint32_t bits,

		KeHashGenerator key_gen,

		const KeHashMarshal *key_marshal,

		const KeHashMarshal *val_marshal,

		ke_allocator_t *nodeAlloc,

		bool keep_free_list

		);

	/**

	 * @brief Destroys a hash table.

	 *

	 * @param table				Hash table.

	 */

	extern void KE_DestroyHashTable(KeHashTable *table);

	/**

	 * @brief Adds a key/value to the hash table.  If the pair already exists, the old value 

	 * is overwritten (calling any destructors as necessary).

	 *

	 * @param table				Hash table.

	 * @param key				Key pointer.

	 * @param val				Value pointer.

	 */

	extern void KE_AddToHashTable(KeHashTable *table, const void *key, void *val);

	/**

	 * @brief Removes a key entry from the hash table.

	 *

	 * @param table				Hash table.

	 * @param key				Key pointer.

	 */

	extern void KE_RemoveFromHashTable(KeHashTable *table, const void *key);

	/**

	 * @brief Finds an entry in the hash table.

	 *

	 * @param table				Hash table.

	 * @param key				Key pointer.

	 * @param value				Pointer to store the value (optional).

	 * @return					On success, true is returned and value is filled if given.

	 *							On failure, false is failed and outputs are undefined.

	 */

	extern bool KE_FindInHashTable(KeHashTable *table, const void *key, void **value);

	/**

	 * @brief Clears all entries in the hash table (caching free entries when possible).

	 *

	 * @param table				Hash table.

	 */

	extern void KE_ClearHashTable(KeHashTable *table);

	/**

	 * @brief Generic function for hashing strings.

	 *

	 * @param str				Key string.

	 * @return					Hash value.

	 */

	extern uint32_t KE_HashString(const void *str);

    /**

     * @brief Generic case-sensitive comparison of strings.

     *

     * @param str1              First string.

     * @param str2              Second string.

     * @return                  True if equal, false otherwise.

     */

    extern bool KE_AreStringsEqual(const void* str1, const void* str2);

}

#endif //_INCLUDE_KNIGHT_KE_HASHTABLE_H_