#include "stringmap.h"
#include "utils/stringmap.h"
#include <stdint.h>
#include <stdlib.h>

StringMap* stringmap_new(void)
{
	StringMap* map = malloc(sizeof(StringMap));
	stringmap_create(map);
	return map;
}

void stringmap_delete(StringMap* map) { free(map); }

size_t* stringmap_get(const StringMap* map, const char* key, size_t key_length)
{
	size_t key_hash = string_hash_djb2((const unsigned char*)key, key_length);
	for (size_t i = 0; i < map->size; ++i)
		if (map->entries[i].key_hash == key_hash && !map->entries[i].deleted)
			return &map->entries[i].value;
	return NULL;
}

bool stringmap_has(const StringMap* map, const char* key, size_t key_length)
{
	size_t key_hash = string_hash_djb2((const unsigned char*)key, key_length);
	for (size_t i = 0; i < map->size; ++i)
		if (map->entries[i].key_hash == key_hash && !map->entries[i].deleted)
			return true;
	return false;
}

void stringmap_set(
	StringMap* map, const char* key, size_t key_length, size_t value
)
{
	size_t key_hash = string_hash_djb2((const unsigned char*)key, key_length);
	for (size_t i = 0; i < map->size; ++i) {
		if (map->entries[i].key_hash == key_hash && !map->entries[i].deleted) {
			map->entries[i].value = value;
			return;
		}
	}
	if (map->entries == NULL) {
		map->capacity = 8;
		map->entries = malloc(sizeof(StringMapEntry) * map->capacity);
	} else if (map->size == map->capacity) {
		map->capacity *= 2;
		map->entries
			= realloc(map->entries, sizeof(StringMapEntry) * map->capacity);
	}
	map->entries[map->size] = (StringMapEntry) {
		.deleted = false,
		.key_hash = key_hash,
		.value = value,
	};
	map->size++;
}

void stringmap_reserve(StringMap* map, size_t minimum_size)
{
	if (map->capacity >= minimum_size)
		return;
	map->capacity = utils_nearest_bigger_power_of_2_u64(minimum_size);
	map->entries
		= realloc(map->entries, sizeof(StringMapEntry) * map->capacity);
}

void stringmap_remove(StringMap* map, const char* key, size_t key_length)
{
	size_t key_hash = string_hash_djb2((const unsigned char*)key, key_length);
	for (size_t i = 0; i < map->size; ++i) {
		if (map->entries[i].key_hash == key_hash && !map->entries[i].deleted) {
			map->entries[i].deleted = true;
		}
	}
}

void stringmap_clean(StringMap* map)
{
	size_t shift_amount = 0;
	for (size_t i = 0; i < map->size; ++i) {
		map->entries[i - shift_amount] = map->entries[i];
		if (map->entries[i].deleted)
			shift_amount++;
	}
}

void stringmap_shrink(StringMap* map)
{
	size_t new_size = utils_nearest_bigger_power_of_2_u64(map->size);
	if (new_size >= map->capacity)
		return;
	map->capacity = new_size;
	map->entries
		= realloc(map->entries, sizeof(StringMapEntry) * map->capacity);
}

void stringmap_clean_and_shrink(StringMap* map)
{
	stringmap_clean(map);
	stringmap_shrink(map);
}

void stringmap_create(StringMap* map)
{
	*map = (StringMap) {
		.entries = NULL,
		.size = 0,
		.capacity = 0,
	};
}

void stringmap_destroy(StringMap* map)
{
	if (map->entries)
		free(map->entries);
}