#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct SNode TNode;

typedef struct SNode {
    void* key;
    void* value;

    TNode* next;
} TNode;

typedef struct SHashMap {
    TNode** nodes;
    uint32_t (*hash)(void*);
    char (*cmpr)(void*, void*);
    size_t nodes_count;
    size_t nodes_size;
} THashMap;


THashMap* HashMap_create(size_t init_size, uint32_t (*hash)(void*), char (*cmpr)(void*, void*)) {
    static int use_count = 0;
    ++use_count;

    THashMap* hash_map;
    hash_map = malloc(sizeof(*hash_map));
    hash_map->hash = hash;
    hash_map->cmpr = cmpr;
    hash_map->nodes = malloc(sizeof(*(hash_map->nodes)) * init_size);
    for (size_t i = 0; i < init_size; ++i) {
        hash_map->nodes[i] = NULL;
    }
    hash_map->nodes_count = 0;
    hash_map->nodes_size = init_size;
    return hash_map;
}

void HashMap_add(THashMap* hash_map, void* key, void* value) {
    uint32_t idx = hash_map->hash(key) % hash_map->nodes_size;

    TNode* new_node;
    new_node = malloc(sizeof(*new_node));
    new_node->key = key;
    new_node->value = value;

    new_node->next = hash_map->nodes[idx];
    hash_map->nodes[idx] = new_node;
}

TNode* HashMap_find(THashMap* hash_map, void* key) {
    uint32_t idx = hash_map->hash(key) % hash_map->nodes_size;
    TNode* current_node = hash_map->nodes[idx];

    while (current_node) {
        if (hash_map->cmpr(key, current_node->key)) {
            return current_node;
        }
        current_node = current_node->next;
    }
    return NULL;
}

void* HashMap_get(THashMap* hash_map, void* key) {
    TNode* node = HashMap_find(hash_map, key);
    return (node ? node->value : NULL);
}

void HashMap_remove(THashMap* hash_map, void* key) {
    uint32_t idx = hash_map->hash(key) % hash_map->nodes_size;
    TNode* current_node = hash_map->nodes[idx];
    TNode* prev_node = NULL;

    if (!hash_map->nodes[idx])
        return;

    if (hash_map->cmpr(key, hash_map->nodes[idx]->key)) {
        TNode* node_to_delete = hash_map->nodes[idx];
        hash_map->nodes[idx] = node_to_delete->next;
        free(node_to_delete);
        return;
    }

    while (current_node) {
        if (hash_map->cmpr(key, current_node->key)) {
            prev_node->next = current_node->next;
            free(current_node);
            return;
        }

        prev_node = current_node;
        current_node = current_node->next;
    }
}


void HashMap_delete(THashMap* hash_map) {
    for (size_t i = 0; i < hash_map->nodes_size; ++i) {
        TNode* current_node = hash_map->nodes[i];
        while (current_node) {
            TNode* next_node = current_node->next;
            free(current_node);
            current_node = next_node;
        }
    }
    free(hash_map->nodes);
    free(hash_map);
}

uint32_t hash_int(void* key) {
    int* int_key = (int*) key;
    return (*int_key) * 127167 + 1951;
}

char cmpr_int(void* key1, void* key2) {
    return *((int*) key1) == *((int*) key2);
}

int main() {
    THashMap* hash_map = HashMap_create(100, &hash_int, &cmpr_int);

    int key1 = 5; char value1[] = "SOsite PidOr1";
    HashMap_add(hash_map, &key1, value1);
    int key2 = 105; char value2[] = "I am cute string";
    HashMap_add(hash_map, &key2, value2);

    int key3 = 105;
    printf("key = %d, value = %s\n", key3, (char*) HashMap_get(hash_map, &key3));
    HashMap_remove(hash_map, &key3);
    if (!HashMap_get(hash_map, &key3)) {
        printf("Key %d is not found\n", key3);
    }

    HashMap_delete(hash_map);
    return 0;
}