#ifndef CORE_HASHMAP_H
#define CORE_HASHMAP_H

#include "core/Types.h"

struct CoreHashMapT;
typedef struct CoreHashMapT CoreHashMap;

typedef size_t (*CoreHasher)(const void* key, size_t n);
typedef bool (*CoreEqual)(const void* keyA, const void* keyB, size_t n);
typedef void* (*CoreSearchValue)(const CoreHashMap* m, const void* key);

struct CoreHashMapT {
    void* keys;
    void* values;
    size_t keySize;
    size_t valueSize;
    size_t capacity;
    size_t entries;
    CoreHasher hasher;
    CoreEqual equal;
    CoreSearchValue search;
};

void coreInitHashMap(CoreHashMap* m, size_t keySize, size_t valueSize);
void coreInitHashMapF(CoreHashMap* m, size_t keySize, size_t valueSize,
                      CoreHasher hasher, CoreEqual equal);
void coreDestroyHashMap(CoreHashMap* m);
void coreRehashHashMap(CoreHashMap* m, size_t minCapacity);
void* corePutHashMapPair(CoreHashMap* m, const void* key, const void* value);
#define corePutTypedHashMapPair(m, kType, key, vType, ...)                     \
    corePutHashMapPair(m, &(kType){key}, &(vType){__VA_ARGS__})
void* coreSearchHashMapKey(const CoreHashMap* m, const void* key);
#define coreSearchTypedHashMapKey(m, kType, key, vType)                        \
    ((vType*)coreSearchHashMapKey(m, &(kType){key}))
void coreClearHashMap(CoreHashMap* m);
bool coreRemoveHashMapKey(CoreHashMap* m, const void* key);
#define coreRemoveTypedHashMapKey(m, kType, key)                               \
    coreRemoveHashMapKey(m, &(kType){key})

size_t coreHashString(const void* key, size_t n);
size_t coreHashKey(const void* key, size_t n);
bool coreCompareKeys(const void* keyA, const void* keyB, size_t n);

typedef struct {
    const void* key;
    void* value;
} CoreHashMapNode;

typedef struct {
    char* key;
    char* endKey;
    char* value;
    char* endValue;
    const CoreHashMap* map;
    CoreHashMapNode node;
} CoreHashMapIterator;

void coreInitHashMapIterator(CoreHashMapIterator* mi, const CoreHashMap* m);
bool coreHasNextHashMapNode(CoreHashMapIterator* mi);
CoreHashMapNode* coreNextHashMapNode(CoreHashMapIterator* mi);

#ifdef IMPORT_CORE
#define HashMap CoreHashMap
#define Hasher CoreHasher
#define Equal CoreEqual
#define SearchValue CoreSearchValue
#define initHashMap coreInitHashMap
#define initHashMapF coreInitHashMapF
#define destroyHashMap coreDestroyHashMap
#define rehashHashMap coreRehashHashMap
#define putHashMapPair corePutHashMapPair
#define putTypedHashMapPair corePutTypedHashMapPair
#define searchHashMapKey coreSearchHashMapKey
#define searchTypedHashMapKey coreSearchTypedHashMapKey
#define clearHashMap coreClearHashMap
#define removeHashMapKey coreRemoveHashMapKey
#define removeTypedHashMapKey coreRemoveTypedHashMapKey
#define hashString coreHashString
#define hashKey coreHashKey
#define compareKeys coreCompareKeys
#define HashMapNode CoreHashMapNode
#define HashMapIterator CoreHashMapIterator
#define initHashMapIterator coreInitHashMapIterator
#define hasNextHashMapNode coreHasNextHashMapNode
#define nextHashMapNode coreNextHashMapNode
#endif

#endif