#pragma once

#include <mimalloc.h>

#include <cstring>

#include "hashmap.h"
#include "utils.h"

#define WAYC_HASHMAP_SEED 0
#define WAYC_HASHMAP_CAP 16

template <typename K, typename V>
struct hashentry_s {
  K key;
  V value;
};

template <typename K, typename V>
inline u64 wayc_hashentry_hash(const void* item, uint64_t seed0,
                               uint64_t seed1) {
  wayc_notnull(item);

  const hashentry_s<K, V>* entry = (const hashentry_s<K, V>*)item;
  return hashmap_murmur(&entry->key, sizeof(K), seed0, seed1);
}

template <typename K, typename V>
inline i32 wayc_hashentry_compare(const void* a, const void* b, void* udata) {
  (void)udata;

  wayc_notnull(a);
  wayc_notnull(b);

  const hashentry_s<K, V>* entry_a = (const hashentry_s<K, V>*)a;
  const hashentry_s<K, V>* entry_b = (const hashentry_s<K, V>*)b;
  return memcmp(&entry_a->key, &entry_b->key, sizeof(K));
}

template <typename K, typename V>
struct hashmap_s {
  struct hashmap* inner;
};

template <typename K, typename V>
inline void wayc_hashmap_init(hashmap_s<K, V>* map) {
  wayc_notnull(map);
  memset(map, 0, sizeof(*map));

  struct hashmap* inner;
  inner = hashmap_new_with_allocator(
      mi_malloc, mi_realloc, mi_free, sizeof(hashentry_s<K, V>),
      WAYC_HASHMAP_CAP, WAYC_HASHMAP_SEED, WAYC_HASHMAP_SEED,
      wayc_hashentry_hash<K, V>, wayc_hashentry_compare<K, V>, nullptr,
      nullptr);

  wayc_notnull(inner);

  map->inner = inner;
}

template <typename K, typename V>
inline void wayc_hashmap_deinit(hashmap_s<K, V>* map) {
  wayc_notnull(map);
  hashmap_free(map->inner);
}

template <typename K, typename V>
inline V* wayc_hashmap_insert(hashmap_s<K, V>* map, const K* key,
                              const V* value) {
  wayc_notnull(map);
  wayc_notnull(key);
  wayc_notnull(value);

  hashentry_s<K, V> entry{};
  entry.key = *key;
  entry.value = *value;
  hashentry_s<K, V>* stored =
      (hashentry_s<K, V>*)hashmap_set(map->inner, &entry);
  return &stored->value;
}

template <typename K, typename V>
inline V* wayc_hashmap_get(hashmap_s<K, V>* map, const K* key) {
  wayc_notnull(map);
  wayc_notnull(key);

  hashentry_s<K, V> entry{};
  entry.key = *key;
  auto* stored = (hashentry_s<K, V>*)hashmap_get(map->inner, &entry);
  if (!stored) return nullptr;

  return &stored->value;
}

template <typename K, typename V>
inline void wayc_hashmap_remove(hashmap_s<K, V>* map, const K* key) {
  wayc_notnull(map);
  wayc_notnull(key);

  hashentry_s<K, V> entry{};
  entry.key = *key;
  hashmap_delete(map->inner, &entry);
}

template <typename K, typename V>
inline usize wayc_hashmap_count(hashmap_s<K, V>* map) {
  wayc_notnull(map);
  return hashmap_count(map->inner);
}