#pragma once
#include "dqn.h"

/*
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//    $$$$$$\   $$$$$$\  $$\   $$\ $$$$$$$$\  $$$$$$\  $$$$$$\ $$\   $$\ $$$$$$$$\ $$$$$$$\   $$$$$$\
//   $$  __$$\ $$  __$$\ $$$\  $$ |\__$$  __|$$  __$$\ \_$$  _|$$$\  $$ |$$  _____|$$  __$$\ $$  __$$\
//   $$ /  \__|$$ /  $$ |$$$$\ $$ |   $$ |   $$ /  $$ |  $$ |  $$$$\ $$ |$$ |      $$ |  $$ |$$ /  \__|
//   $$ |      $$ |  $$ |$$ $$\$$ |   $$ |   $$$$$$$$ |  $$ |  $$ $$\$$ |$$$$$\    $$$$$$$  |\$$$$$$\
//   $$ |      $$ |  $$ |$$ \$$$$ |   $$ |   $$  __$$ |  $$ |  $$ \$$$$ |$$  __|   $$  __$$<  \____$$\
//   $$ |  $$\ $$ |  $$ |$$ |\$$$ |   $$ |   $$ |  $$ |  $$ |  $$ |\$$$ |$$ |      $$ |  $$ |$$\   $$ |
//   \$$$$$$  | $$$$$$  |$$ | \$$ |   $$ |   $$ |  $$ |$$$$$$\ $$ | \$$ |$$$$$$$$\ $$ |  $$ |\$$$$$$  |
//    \______/  \______/ \__|  \__|   \__|   \__|  \__|\______|\__|  \__|\________|\__|  \__| \______/
//
//   dqn_containers.cpp
//
////////////////////////////////////////////////////////////////////////////////////////////////////
*/

// NOTE: [$CARR] DN_CArray ////////////////////////////////////////////////////////////////////////
template <typename T> DN_ArrayEraseResult DN_CArray_EraseRange(T* data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase)
{
    DN_ArrayEraseResult result = {};
    if (!data || !size || *size == 0 || count == 0)
        return result;

    DN_ASSERTF(count != -1, "There's a bug with negative element erases, see the DN_VArray section in dn_docs.cpp");

    // NOTE: Caculate the end index of the erase range
    DN_ISize abs_count = DN_ABS(count);
    DN_USize end_index = 0;
    if (count < 0) {
        end_index = begin_index - (abs_count - 1);
        if (end_index > begin_index)
            end_index = 0;
    } else {
        end_index = begin_index + (abs_count - 1);
        if (end_index < begin_index)
            end_index = (*size) - 1;
    }

    // NOTE: Ensure begin_index < one_past_end_index
    if (end_index < begin_index) {
        DN_USize tmp = begin_index;
        begin_index   = end_index;
        end_index     = tmp;
    }

    // NOTE: Ensure indexes are within valid bounds
    begin_index = DN_MIN(begin_index, *size);
    end_index   = DN_MIN(end_index,   *size - 1);

    // NOTE: Erase the items in the range [begin_index, one_past_end_index)
    DN_USize one_past_end_index = end_index + 1;
    DN_USize erase_count        = one_past_end_index - begin_index;
    if (erase_count) {
        T *end  = data + *size;
        T *dest = data + begin_index;
        if (erase == DN_ArrayErase_Stable) {
            T *src = dest + erase_count;
            DN_MEMMOVE(dest, src, (end - src) * sizeof(T));
        } else {
            T *src = end - erase_count;
            DN_MEMCPY(dest, src, (end - src) * sizeof(T));
        }
        *size -= erase_count;
    }

    result.items_erased = erase_count;
    result.it_index     = begin_index;
    return result;
}

template <typename T> T *DN_CArray_MakeArray(T* data, DN_USize *size, DN_USize max, DN_USize count, DN_ZeroMem zero_mem)
{
    if (!data || !size || count == 0)
        return nullptr;

    if (!DN_CHECKF((*size + count) <= max, "Array is out of space (user requested +%zu items, array has %zu/%zu items)", count, *size, max))
        return nullptr;

    // TODO: Use placement new? Why doesn't this work?
    T *result  = data + *size;
    *size     += count;
    if (zero_mem == DN_ZeroMem_Yes)
        DN_MEMSET(result, 0, sizeof(*result) * count);
    return result;
}

template <typename T> T *DN_CArray_InsertArray(T *data, DN_USize *size, DN_USize max, DN_USize index, T const *items, DN_USize count)
{
    T *result = nullptr;
    if (!data || !size || !items || count <= 0 || ((*size + count) > max))
        return result;

    DN_USize clamped_index = DN_MIN(index, *size);
    if (clamped_index != *size) {
        char const *src           = DN_CAST(char *)(data + clamped_index);
        char const *dest          = DN_CAST(char *)(data + (clamped_index + count));
        char const *end           = DN_CAST(char *)(data + (*size));
        DN_USize   bytes_to_move = end - src;
        DN_MEMMOVE(DN_CAST(void *) dest, src, bytes_to_move);
    }

    result = data + clamped_index;
    DN_MEMCPY(result, items, sizeof(T) * count);
    *size += count;
    return result;
}

template <typename T> T DN_CArray_PopFront(T* data, DN_USize *size, DN_USize count)
{
    T result = {};
    if (!data || !size || *size <= 0)
        return result;

    result              = data[0];
    DN_USize pop_count = DN_MIN(count, *size);
    DN_MEMMOVE(data, data + pop_count, (*size - pop_count) * sizeof(T));
    *size              -= pop_count;
    return result;
}

template <typename T> T DN_CArray_PopBack(T* data, DN_USize *size, DN_USize count)
{
    T result = {};
    if (!data || !size || *size <= 0)
        return result;

    DN_USize pop_count = DN_MIN(count, *size);
    result              = data[(*size - 1)];
    *size              -= pop_count;
    return result;
}

template <typename T> DN_ArrayFindResult<T> DN_CArray_Find(T *data, DN_USize size, T const &value)
{
    DN_ArrayFindResult<T> result = {};
    if (!data || size <= 0)
        return result;

    for (DN_USize index = 0; !result.data && index < size; index++) {
        T *item = data + index;
        if (*item == value) {
            result.data = item;
            result.index = index;
        }
    }

    return result;
}

#if !defined(DN_NO_VARRAY)
// NOTE: [$VARR] DN_VArray ////////////////////////////////////////////////////////////////////////
template <typename T> DN_VArray<T> DN_VArray_InitByteSize(DN_USize byte_size)
{
    DN_VArray<T> result = {};
    result.data = DN_CAST(T *)DN_OS_MemReserve(byte_size, DN_OSMemCommit_No, DN_OSMemPage_ReadWrite);
    if (result.data)
        result.max = byte_size / sizeof(T);
    return result;
}

template <typename T> DN_VArray<T> DN_VArray_Init(DN_USize max)
{
    DN_VArray<T> result = DN_VArray_InitByteSize<T>(max * sizeof(T));
    DN_ASSERT(result.max >= max);
    return result;
}

template <typename T> DN_VArray<T> DN_VArray_InitSlice(DN_Slice<T> slice, DN_USize max)
{
    DN_USize     real_max = DN_MAX(slice.size, max);
    DN_VArray<T> result   = DN_VArray_Init<T>(real_max);
    if (DN_VArray_IsValid(&result))
        DN_VArray_AddArray(&result, slice.data, slice.size);
    return result;
}

template <typename T, DN_USize N> DN_VArray<T> DN_VArray_InitCArray(T const (&items)[N], DN_USize max)
{
    DN_USize     real_max = DN_MAX(N, max);
    DN_VArray<T> result   = DN_VArray_InitSlice(DN_Slice_Init(items, N), real_max);
    return result;
}

template <typename T> void DN_VArray_Deinit(DN_VArray<T> *array)
{
    DN_OS_MemRelease(array->data, array->max * sizeof(T));
    *array = {};
}

template <typename T> bool DN_VArray_IsValid(DN_VArray<T> const *array)
{
    bool result = array->data && array->size <= array->max;
    return result;
}

template <typename T> DN_Slice<T> DN_VArray_Slice(DN_VArray<T> const *array)
{
    DN_Slice<T> result = {};
    if (array)
        result = DN_Slice_Init<T>(array->data, array->size);
    return result;
}

template <typename T> T *DN_VArray_AddArray(DN_VArray<T> *array, T const *items, DN_USize count)
{
    T *result = DN_VArray_MakeArray(array, count, DN_ZeroMem_No);
    if (result)
        DN_MEMCPY(result, items, count * sizeof(T));
    return result;
}

template <typename T, DN_USize N> T *DN_VArray_AddCArray(DN_VArray<T> *array, T const (&items)[N])
{
    T *result = DN_VArray_AddArray(array, items, N);
    return result;
}

template <typename T> T *DN_VArray_Add(DN_VArray<T> *array, T const &item)
{
    T *result = DN_VArray_AddArray(array, &item, 1);
    return result;
}

template <typename T> T *DN_VArray_MakeArray(DN_VArray<T> *array, DN_USize count, DN_ZeroMem zero_mem)
{
    if (!DN_VArray_IsValid(array))
        return nullptr;

    if (!DN_CHECKF((array->size + count) < array->max, "Array is out of space (user requested +%zu items, array has %zu/%zu items)", count, array->size, array->max))
        return nullptr;

    if (!DN_VArray_Reserve(array, count))
        return nullptr;

    // TODO: Use placement new
    T *result    = array->data + array->size;
    array->size += count;
    if (zero_mem == DN_ZeroMem_Yes)
        DN_MEMSET(result, 0, count * sizeof(T));
    return result;
}

template <typename T> T *DN_VArray_Make(DN_VArray<T> *array, DN_ZeroMem zero_mem)
{
    T *result = DN_VArray_MakeArray(array, 1, zero_mem);
    return result;
}

template <typename T> T *DN_VArray_InsertArray(DN_VArray<T> *array, DN_USize index, T const *items, DN_USize count)
{
    T *result = nullptr;
    if (!DN_VArray_IsValid(array))
        return result;
    if (DN_VArray_Reserve(array, array->size + count))
        result = DN_CArray_InsertArray(array->data, &array->size, array->max, index, items, count);
    return result;
}

template <typename T, DN_USize N> T *DN_VArray_InsertCArray(DN_VArray<T> *array, DN_USize index, T const (&items)[N])
{
    T *result = DN_VArray_InsertArray(array, index, items, N);
    return result;
}

template <typename T> T *DN_VArray_Insert(DN_VArray<T> *array, DN_USize index, T const &item)
{
    T *result = DN_VArray_InsertArray(array, index, &item, 1);
    return result;
}

template <typename T> T *DN_VArray_PopFront(DN_VArray<T> *array, DN_USize count)
{
    T *result = DN_CArray_PopFront(array->data, &array->size, count);
    return result;
}

template <typename T> T *DN_VArray_PopBack(DN_VArray<T> *array, DN_USize count)
{
    T *result = DN_CArray_PopBack(array->data, &array->size, count);
    return result;
}

template <typename T> DN_ArrayEraseResult DN_VArray_EraseRange(DN_VArray<T> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase)
{
    DN_ArrayEraseResult result = {};
    if (!DN_VArray_IsValid(array))
        return result;
    result = DN_CArray_EraseRange<T>(array->data, &array->size, begin_index, count, erase);
    return result;
}

template <typename T> void DN_VArray_Clear(DN_VArray<T> *array, DN_ZeroMem zero_mem)
{
    if (array) {
        if (zero_mem == DN_ZeroMem_Yes)
            DN_MEMSET(array->data, 0, array->size * sizeof(T));
        array->size = 0;
    }
}

template <typename T> bool DN_VArray_Reserve(DN_VArray<T> *array, DN_USize count)
{
    if (!DN_VArray_IsValid(array) || count == 0)
        return false;

    DN_USize real_commit    = (array->size + count) * sizeof(T);
    DN_USize aligned_commit = DN_AlignUpPowerOfTwo(real_commit, g_dn_core->os_page_size);
    if (array->commit >= aligned_commit)
        return true;
    bool result   = DN_OS_MemCommit(array->data, aligned_commit, DN_OSMemPage_ReadWrite);
    array->commit = aligned_commit;
    return result;
}
#endif // !defined(DN_NO_VARRAY)

#if !defined(DN_NO_SARRAY)
// NOTE: [$SARR] DN_SArray ////////////////////////////////////////////////////////////////////////
template <typename T> DN_SArray<T> DN_SArray_Init(DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem)
{
    DN_SArray<T> result = {};
    if (!arena || !size)
        return result;
    result.data = DN_Arena_NewArray(arena, T, size, zero_mem);
    if (result.data)
        result.max = size;
    return result;
}

template <typename T> DN_SArray<T> DN_SArray_InitSlice(DN_Arena *arena, DN_Slice<T> slice, DN_USize size, DN_ZeroMem zero_mem)
{
    DN_USize     max    = DN_MAX(slice.size, size);
    DN_SArray<T> result = DN_SArray_Init<T>(arena, max, DN_ZeroMem_No);
    if (DN_SArray_IsValid(&result)) {
        DN_SArray_AddArray(&result, slice.data, slice.size);
        if (zero_mem == DN_ZeroMem_Yes)
            DN_MEMSET(result.data + result.size, 0, (result.max - result.size) * sizeof(T));
    }
    return result;
}

template <typename T, size_t N> DN_SArray<T> DN_SArray_InitCArray(DN_Arena *arena, T const (&array)[N], DN_USize size, DN_ZeroMem zero_mem)
{
    DN_SArray<T> result = DN_SArray_InitSlice(arena, DN_Slice_Init(DN_CAST(T *)array, N), size, zero_mem);
    return result;
}

template <typename T> DN_SArray<T> DN_SArray_InitBuffer(T *buffer, DN_USize size)
{
    DN_SArray<T> result = {};
    result.data          = buffer;
    result.max           = size;
    return result;
}

template <typename T> bool DN_SArray_IsValid(DN_SArray<T> const *array)
{
    bool result = array && array->data && array->size <= array->max;
    return result;
}

template <typename T> DN_Slice<T> DN_SArray_Slice(DN_SArray<T> const *array)
{
    DN_Slice<T> result = {};
    if (array)
        result = DN_Slice_Init<T>(DN_CAST(T *)array->data, array->size);
    return result;
}

template <typename T> T *DN_SArray_MakeArray(DN_SArray<T> *array, DN_USize count, DN_ZeroMem zero_mem)
{
    if (!DN_SArray_IsValid(array))
        return nullptr;
    T *result = DN_CArray_MakeArray(array->data, &array->size, array->max, count, zero_mem);
    return result;
}

template <typename T> T *DN_SArray_Make(DN_SArray<T> *array, DN_ZeroMem zero_mem)
{
    T *result = DN_SArray_MakeArray(array, 1, zero_mem);
    return result;
}

template <typename T> T *DN_SArray_AddArray(DN_SArray<T> *array, T const *items, DN_USize count)
{
    T *result = DN_SArray_MakeArray(array, count, DN_ZeroMem_No);
    if (result)
        DN_MEMCPY(result, items, count * sizeof(T));
    return result;
}

template <typename T, DN_USize N> T *DN_SArray_AddCArray(DN_SArray<T> *array, T const (&items)[N])
{
    T *result = DN_SArray_AddArray(array, items, N);
    return result;
}

template <typename T> T *DN_SArray_Add(DN_SArray<T> *array, T const &item)
{
    T *result = DN_SArray_AddArray(array, &item, 1);
    return result;
}

template <typename T> T *DN_SArray_InsertArray(DN_SArray<T> *array, DN_USize index, T const *items, DN_USize count)
{
    T *result = nullptr;
    if (!DN_SArray_IsValid(array))
        return result;
    result = DN_CArray_InsertArray(array->data, &array->size, array->max, index, items, count);
    return result;
}

template <typename T, DN_USize N> T *DN_SArray_InsertCArray(DN_SArray<T> *array, DN_USize index, T const (&items)[N])
{
    T *result = DN_SArray_InsertArray(array, index, items, N);
    return result;
}

template <typename T> T *DN_SArray_Insert(DN_SArray<T> *array, DN_USize index, T const &item)
{
    T *result = DN_SArray_InsertArray(array, index, &item, 1);
    return result;
}

template <typename T> T DN_SArray_PopFront(DN_SArray<T> *array, DN_USize count)
{
    T result = DN_CArray_PopFront(array->data, &array->size, count);
    return result;
}

template <typename T> T DN_SArray_PopBack(DN_SArray<T> *array, DN_USize count)
{
    T result = DN_CArray_PopBack(array->data, &array->size, count);
    return result;
}

template <typename T> DN_ArrayEraseResult DN_SArray_EraseRange(DN_SArray<T> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase)
{
    DN_ArrayEraseResult result = {};
    if (!DN_SArray_IsValid(array) || array->size == 0 || count == 0)
        return result;
    result = DN_CArray_EraseRange(array->data, &array->size, begin_index, count, erase);
    return result;
}

template <typename T> void DN_SArray_Clear(DN_SArray<T> *array)
{
    if (array)
        array->size = 0;
}
#endif // !defined(DN_NO_SARRAY)

#if !defined(DN_NO_FARRAY)
// NOTE: [$FARR] DN_FArray ////////////////////////////////////////////////////////////////////////
template <typename T, DN_USize N> DN_FArray<T, N> DN_FArray_Init(T const *array, DN_USize count)
{
    DN_FArray<T, N> result = {};
    bool added              = DN_FArray_AddArray(&result, array, count);
    DN_ASSERT(added);
    return result;
}

template <typename T, DN_USize N> DN_FArray<T, N> DN_FArray_InitSlice(DN_Slice<T> slice)
{
    DN_FArray<T, N> result = DN_FArray_Init(slice.data, slice.size);
    return result;
}

template <typename T, DN_USize N, DN_USize K> DN_FArray<T, N> DN_FArray_InitCArray(T const (&items)[K])
{
    DN_FArray<T, N> result = DN_FArray_Init<T, N>(items, K);
    return result;
}

template <typename T, DN_USize N> bool DN_FArray_IsValid(DN_FArray<T, N> const *array)
{
    bool result = array && array->size <= DN_ARRAY_UCOUNT(array->data);
    return result;
}

template <typename T, DN_USize N> DN_Slice<T> DN_FArray_Slice(DN_FArray<T, N> const *array)
{
    DN_Slice<T> result = {};
    if (array)
        result = DN_Slice_Init<T>(DN_CAST(T *)array->data, array->size);
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_AddArray(DN_FArray<T, N> *array, T const *items, DN_USize count)
{
    T *result = DN_FArray_MakeArray(array, count, DN_ZeroMem_No);
    if (result)
        DN_MEMCPY(result, items, count * sizeof(T));
    return result;
}

template <typename T, DN_USize N, DN_USize K> T *DN_FArray_AddCArray(DN_FArray<T, N> *array, T const (&items)[K])
{
    T *result = DN_FArray_MakeArray(array, K, DN_ZeroMem_No);
    if (result)
        DN_MEMCPY(result, items, K * sizeof(T));
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_Add(DN_FArray<T, N> *array, T const &item)
{
    T *result = DN_FArray_AddArray(array, &item, 1);
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_MakeArray(DN_FArray<T, N> *array, DN_USize count, DN_ZeroMem zero_mem)
{
    if (!DN_FArray_IsValid(array))
        return nullptr;
    T *result = DN_CArray_MakeArray(array->data, &array->size, N, count, zero_mem);
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_Make(DN_FArray<T, N> *array, DN_ZeroMem zero_mem)
{
    T *result = DN_FArray_MakeArray(array, 1, zero_mem);
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_InsertArray(DN_FArray<T, N> *array, DN_USize index, T const *items, DN_USize count)
{
    T *result = nullptr;
    if (!DN_FArray_IsValid(array))
        return result;
    result = DN_CArray_InsertArray(array->data, &array->size, N, index, items, count);
    return result;
}

template <typename T, DN_USize N, DN_USize K> T *DN_FArray_InsertCArray(DN_FArray<T, N> *array, DN_USize index, T const (&items)[K])
{
    T *result = DN_FArray_InsertArray(array, index, items, K);
    return result;
}

template <typename T, DN_USize N> T *DN_FArray_Insert(DN_FArray<T, N> *array, DN_USize index, T const &item)
{
    T *result = DN_FArray_InsertArray(array, index, &item, 1);
    return result;
}

template <typename T, DN_USize N> T DN_FArray_PopFront(DN_FArray<T, N> *array, DN_USize count)
{
    T result = DN_CArray_PopFront(array->data, &array->size, count);
    return result;
}

template <typename T, DN_USize N> T DN_FArray_PopBack(DN_FArray<T, N> *array, DN_USize count)
{
    T result = DN_CArray_PopBack(array->data, &array->size, count);
    return result;
}

template <typename T, DN_USize N> DN_ArrayFindResult<T> DN_FArray_Find(DN_FArray<T, N> *array, T const &find)
{
    DN_ArrayFindResult<T> result = DN_CArray_Find<T>(array->data, array->size, find);
    return result;
}

template <typename T, DN_USize N> DN_ArrayEraseResult DN_FArray_EraseRange(DN_FArray<T, N> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase)
{
    DN_ArrayEraseResult result = {};
    if (!DN_FArray_IsValid(array) || array->size == 0 || count == 0)
        return result;
    result = DN_CArray_EraseRange(array->data, &array->size, begin_index, count, erase);
    return result;
}

template <typename T, DN_USize N> void DN_FArray_Clear(DN_FArray<T, N> *array)
{
    if (array)
        array->size = 0;
}
#endif // !defined(DN_NO_FARRAY)

#if !defined(DN_NO_SLICE)
template <typename T> DN_Slice<T> DN_Slice_Init(T* const data, DN_USize size)
{
    DN_Slice<T> result = {};
    if (data) {
        result.data = data;
        result.size = size;
    }
    return result;
}

template <typename T, DN_USize N> DN_Slice<T> DN_Slice_InitCArray(DN_Arena *arena, T const (&array)[N])
{
    DN_Slice<T> result = DN_Slice_Alloc<T>(arena, N, DN_ZeroMem_No);
    if (result.data)
        DN_MEMCPY(result.data, array, sizeof(T) * N);
    return result;
}

template <typename T> DN_Slice<T> DN_Slice_CopyPtr(DN_Arena *arena, T *const data, DN_USize size)
{
    T           *copy   = DN_Arena_NewArrayCopy(arena, T, data, size);
    DN_Slice<T> result = DN_Slice_Init(copy, copy ? size : 0);
    return result;
}

template <typename T> DN_Slice<T> DN_Slice_Copy(DN_Arena *arena, DN_Slice<T> slice)
{
    DN_Slice<T> result = DN_Slice_CopyPtr(arena, slice.data, slice.size);
    return result;
}

template <typename T> DN_Slice<T> DN_Slice_Alloc(DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem)
{
    DN_Slice<T> result = {};
    if (!arena || size == 0)
        return result;
    result.data = DN_Arena_NewArray(arena, T, size, zero_mem);
    if (result.data)
        result.size = size;
    return result;
}

#endif // !defined(DN_NO_SLICE)

#if !defined(DN_NO_DSMAP)
// NOTE: [$DMAP] DN_DSMap /////////////////////////////////////////////////////////////////////////
DN_U32 const DN_DS_MAP_DEFAULT_HASH_SEED = 0x8a1ced49;
DN_U32 const DN_DS_MAP_SENTINEL_SLOT     = 0;

template <typename T> DN_DSMap<T> DN_DSMap_Init(DN_Arena *arena, DN_U32 size, DN_DSMapFlags flags)
{
    DN_DSMap<T> result = {};
    if (!DN_CHECKF(DN_IsPowerOfTwo(size), "Power-of-two size required, given size was '%u'", size))
        return result;
    if (size <= 0)
        return result;
    if (!DN_CHECK(arena))
        return result;
    result.arena        = arena;
    result.pool         = DN_Pool_Init(arena, DN_POOL_DEFAULT_ALIGN);
    result.hash_to_slot = DN_Arena_NewArray(result.arena, DN_U32,         size, DN_ZeroMem_Yes);
    result.slots        = DN_Arena_NewArray(result.arena, DN_DSMapSlot<T>, size, DN_ZeroMem_Yes);
    result.occupied     = 1; // For sentinel
    result.size         = size;
    result.initial_size = size;
    result.flags        = flags;
    DN_ASSERTF(result.hash_to_slot && result.slots, "We pre-allocated a block of memory sufficient in size for the 2 arrays. Maybe the pointers needed extra space because of natural alignment?");
    return result;
}

template <typename T>
void DN_DSMap_Deinit(DN_DSMap<T> *map, DN_ZeroMem zero_mem)
{
    if (!map)
        return;
    // TODO(doyle): Use zero_mem
    (void)zero_mem;
    DN_Arena_Deinit(map->arena);
    *map = {};
}

template <typename T>
bool DN_DSMap_IsValid(DN_DSMap<T> const *map)
{
    bool result = map &&
                  map->arena &&
                  map->hash_to_slot &&                  // Hash to slot mapping array must be allocated
                  map->slots &&                         // Slots array must be allocated
                  (map->size & (map->size - 1)) == 0 && // Must be power of two size
                  map->occupied >= 1;                   // DN_DS_MAP_SENTINEL_SLOT takes up one slot
    return result;
}

template <typename T>
DN_U32 DN_DSMap_Hash(DN_DSMap<T> const *map, DN_DSMapKey key)
{
    DN_U32 result = 0;
    if (!map)
        return result;

    if (key.type == DN_DSMapKeyType_U64NoHash) {
        result = DN_CAST(DN_U32)key.u64;
        return result;
    }

    if (key.type == DN_DSMapKeyType_BufferAsU64NoHash) {
        result = key.hash;
        return result;
    }

    DN_U32 seed = map->hash_seed ? map->hash_seed : DN_DS_MAP_DEFAULT_HASH_SEED;
    if (map->hash_function) {
        map->hash_function(key, seed);
    } else {
        // NOTE: Courtesy of Demetri Spanos (which this hash table was inspired
        // from), the following is a hashing function snippet provided for
        // reliable, quick and simple quality hashing functions for hash table
        // use.
        // Source: https://github.com/demetri/scribbles/blob/c475464756c104c91bab83ed4e14badefef12ab5/hashing/ub_aware_hash_functions.c

        char const *key_ptr = nullptr;
        DN_U32 len        = 0;
        DN_U32 h          = seed;
        switch (key.type) {
            case DN_DSMapKeyType_BufferAsU64NoHash: /*FALLTHRU*/
            case DN_DSMapKeyType_U64NoHash: DN_INVALID_CODE_PATH; /*FALLTHRU*/
            case DN_DSMapKeyType_Invalid: break;

            case DN_DSMapKeyType_Buffer:
                key_ptr = DN_CAST(char const *)key.buffer_data;
                len     = key.buffer_size;
                break;

            case DN_DSMapKeyType_U64:
                key_ptr = DN_CAST(char const *)&key.u64;
                len     = sizeof(key.u64);
                break;
        }

        // Murmur3 32-bit without UB unaligned accesses
        // DN_U32 mur3_32_no_UB(const void *key, int len, DN_U32 h)

        // main body, work on 32-bit blocks at a time
        for (DN_U32 i = 0; i < len / 4; i++) {
            DN_U32 k;
            memcpy(&k, &key_ptr[i * 4], sizeof(k));

            k *= 0xcc9e2d51;
            k = ((k << 15) | (k >> 17)) * 0x1b873593;
            h = (((h ^ k) << 13) | ((h ^ k) >> 19)) * 5 + 0xe6546b64;
        }

        // load/mix up to 3 remaining tail bytes into a tail block
        DN_U32 t    = 0;
        uint8_t *tail = ((uint8_t *)key_ptr) + 4 * (len / 4);
        switch (len & 3) {
            case 3: t ^= tail[2] << 16;
            case 2: t ^= tail[1] << 8;
            case 1: {
                t ^= tail[0] << 0;
                h ^= ((0xcc9e2d51 * t << 15) | (0xcc9e2d51 * t >> 17)) * 0x1b873593;
            }
        }

        // finalization mix, including key length
        h      = ((h ^ len) ^ ((h ^ len) >> 16)) * 0x85ebca6b;
        h      = (h ^ (h >> 13)) * 0xc2b2ae35;
        result = h ^ (h >> 16);
    }
    return result;
}

template <typename T>
DN_U32 DN_DSMap_HashToSlotIndex(DN_DSMap<T> const *map, DN_DSMapKey key)
{
    DN_ASSERT(key.type != DN_DSMapKeyType_Invalid);
    DN_U32 result = DN_DS_MAP_SENTINEL_SLOT;
    if (!DN_DSMap_IsValid(map))
        return result;

    result = key.hash & (map->size - 1);
    for (;;) {
        if (result == DN_DS_MAP_SENTINEL_SLOT) // Sentinel is reserved
            result++;

        if (map->hash_to_slot[result] == DN_DS_MAP_SENTINEL_SLOT) // Slot is vacant, can use
            return result;

        DN_DSMapSlot<T> *slot = map->slots + map->hash_to_slot[result];
        if (slot->key.type == DN_DSMapKeyType_Invalid || (slot->key.hash == key.hash && slot->key == key))
            return result;

        result = (result + 1) & (map->size - 1);
    }
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_Find(DN_DSMap<T> const *map, DN_DSMapKey key)
{
    DN_DSMapResult<T> result = {};
    if (DN_DSMap_IsValid(map)) {
        DN_U32 index = DN_DSMap_HashToSlotIndex(map, key);
        if (index != DN_DS_MAP_SENTINEL_SLOT && map->hash_to_slot[index] == DN_DS_MAP_SENTINEL_SLOT) {
            result.slot = map->slots; // NOTE: Set to sentinel value
        } else {
            result.slot  = map->slots + map->hash_to_slot[index];
            result.found = true;
        }
        result.value = &result.slot->value;
    }
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_Make(DN_DSMap<T> *map, DN_DSMapKey key)
{
    DN_DSMapResult<T> result = {};
    if (!DN_DSMap_IsValid(map))
        return result;

    DN_U32 index = DN_DSMap_HashToSlotIndex(map, key);
    if (map->hash_to_slot[index] == DN_DS_MAP_SENTINEL_SLOT) {
        // NOTE: Create the slot
        if (index != DN_DS_MAP_SENTINEL_SLOT)
            map->hash_to_slot[index] = map->occupied++;

        // NOTE: Check if resize is required
        bool map_is_75pct_full = (map->occupied * 4) > (map->size * 3);
        if (map_is_75pct_full) {
            if (!DN_DSMap_Resize(map, map->size * 2))
                return result;
            result = DN_DSMap_Make(map, key);
        } else {
            result.slot      = map->slots + map->hash_to_slot[index];
            result.slot->key = key; // NOTE: Assign key to new slot
            if ((key.type == DN_DSMapKeyType_Buffer ||
                 key.type == DN_DSMapKeyType_BufferAsU64NoHash) &&
                !key.no_copy_buffer) {
                result.slot->key.buffer_data = DN_Pool_NewArrayCopy(&map->pool, char, key.buffer_data, key.buffer_size);
            }
        }
    } else {
        result.slot  = map->slots + map->hash_to_slot[index];
        result.found = true;
    }

    result.value = &result.slot->value;
    DN_ASSERT(result.slot->key.type != DN_DSMapKeyType_Invalid);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_Set(DN_DSMap<T> *map, DN_DSMapKey key, T const &value)
{
    DN_DSMapResult<T> result = {};
    if (!DN_DSMap_IsValid(map))
        return result;

    result             = DN_DSMap_Make(map, key);
    result.slot->value = value;
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_FindKeyU64(DN_DSMap<T> const *map, DN_U64 key)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyU64(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Find(map, map_key);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_MakeKeyU64(DN_DSMap<T> *map, DN_U64 key)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyU64(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Make(map, map_key);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_SetKeyU64(DN_DSMap<T> *map, DN_U64 key, T const &value)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyU64(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Set(map, map_key, value);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_FindKeyStr8(DN_DSMap<T> const *map, DN_Str8 key)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyStr8(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Find(map, map_key);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_MakeKeyStr8(DN_DSMap<T> *map, DN_Str8 key)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyStr8(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Make(map, map_key);
    return result;
}

template <typename T>
DN_DSMapResult<T> DN_DSMap_SetKeyStr8(DN_DSMap<T> *map, DN_Str8 key, T const &value)
{
    DN_DSMapKey map_key      = DN_DSMap_KeyStr8(map, key);
    DN_DSMapResult<T> result = DN_DSMap_Set(map, map_key);
    return result;
}

template <typename T>
bool DN_DSMap_Resize(DN_DSMap<T> *map, DN_U32 size)
{
    if (!DN_DSMap_IsValid(map) || size < map->occupied || size < map->initial_size)
        return false;

    DN_Arena *prev_arena = map->arena;
    DN_Arena  new_arena  = {};
    new_arena.flags       = prev_arena->flags;
    new_arena.label       = prev_arena->label;
    new_arena.prev        = prev_arena->prev;
    new_arena.next        = prev_arena->next;

    DN_DSMap<T> new_map = DN_DSMap_Init<T>(&new_arena, size, map->flags);
    if (!DN_DSMap_IsValid(&new_map))
        return false;

    new_map.initial_size = map->initial_size;
    for (DN_U32 old_index = 1 /*Sentinel*/; old_index < map->occupied; old_index++) {
        DN_DSMapSlot<T> *old_slot = map->slots + old_index;
        DN_DSMapKey      old_key  = old_slot->key;
        if (old_key.type == DN_DSMapKeyType_Invalid)
            continue;
        DN_DSMap_Set(&new_map, old_key, old_slot->value);
    }

    if ((map->flags & DN_DSMapFlags_DontFreeArenaOnResize) == 0)
        DN_DSMap_Deinit(map, DN_ZeroMem_No);
    *map            = new_map;    // Update the map inplace
    map->arena      = prev_arena; // Restore the previous arena pointer, it's been de-init-ed
    *map->arena     = new_arena;  // Re-init the old arena with the new data
    map->pool.arena = map->arena;
    return true;
}

template <typename T>
bool DN_DSMap_Erase(DN_DSMap<T> *map, DN_DSMapKey key)
{
    if (!DN_DSMap_IsValid(map))
        return false;

    DN_U32 index = DN_DSMap_HashToSlotIndex(map, key);
    if (index == 0)
        return true;

    DN_U32 slot_index = map->hash_to_slot[index];
    if (slot_index == DN_DS_MAP_SENTINEL_SLOT)
        return false;

    // NOTE: Mark the slot as unoccupied
    map->hash_to_slot[index] = DN_DS_MAP_SENTINEL_SLOT;

    DN_DSMapSlot<T> *slot = map->slots + slot_index;
    if (!slot->key.no_copy_buffer)
        DN_Pool_Dealloc(&map->pool, DN_CAST(void *)slot->key.buffer_data);
    *slot = {}; // TODO: Optional?

    if (map->occupied > 1 /*Sentinel*/) {
        // NOTE: Repair the hash chain, e.g. rehash all the items after the removed
        // element and reposition them if necessary.
        for (DN_U32 probe_index = index;;) {
            probe_index = (probe_index + 1) & (map->size - 1);
            if (map->hash_to_slot[probe_index] == DN_DS_MAP_SENTINEL_SLOT)
                break;

            DN_DSMapSlot<T> *probe = map->slots + map->hash_to_slot[probe_index];
            DN_U32 new_index      = probe->key.hash & (map->size - 1);
            if (index <= probe_index) {
                if (index < new_index && new_index <= probe_index)
                    continue;
            } else {
                if (index < new_index || new_index <= probe_index)
                    continue;
            }

            map->hash_to_slot[index]       = map->hash_to_slot[probe_index];
            map->hash_to_slot[probe_index] = DN_DS_MAP_SENTINEL_SLOT;
            index                          = probe_index;
        }

        // NOTE: We have erased a slot from the hash table, this leaves a gap
        // in our contiguous array. After repairing the chain, the hash mapping
        // is correct.
        // We will now fill in the vacant spot that we erased using the last 
        // element in the slot list.
        if (map->occupied >= 3 /*Ignoring sentinel, at least 2 other elements to unstable erase*/) {
            DN_U32 last_index = map->occupied - 1;
            if (last_index != slot_index) {
                // NOTE: Copy in last slot to the erase slot
                DN_DSMapSlot<T> *last_slot = map->slots + last_index;
                map->slots[slot_index]      = *last_slot;

                // NOTE: Update the hash-to-slot mapping for the value that was copied in
                DN_U32 hash_to_slot_index             = DN_DSMap_HashToSlotIndex(map, last_slot->key);
                map->hash_to_slot[hash_to_slot_index] = slot_index;
                *last_slot = {}; // TODO: Optional?
            }
        }
    }

    map->occupied--;
    bool map_is_below_25pct_full = (map->occupied * 4) < (map->size * 1);
    if (map_is_below_25pct_full && (map->size / 2) >= map->initial_size)
        DN_DSMap_Resize(map, map->size / 2);

    return true;
}

template <typename T> bool DN_DSMap_EraseKeyU64(DN_DSMap<T> *map, DN_U64 key)
{
    DN_DSMapKey map_key = DN_DSMap_KeyU64(map, key);
    bool         result  = DN_DSMap_Erase(map, map_key);
    return result;
}

template <typename T> bool DN_DSMap_EraseKeyStr8(DN_DSMap<T> *map, DN_Str8 key)
{
    DN_DSMapKey map_key = DN_DSMap_KeyStr8(map, key);
    bool         result  = DN_DSMap_Erase(map, map_key);
    return result;
}

template <typename T>
DN_DSMapKey DN_DSMap_KeyBuffer(DN_DSMap<T> const *map, void const *data, DN_USize size)
{
    DN_ASSERT(size > 0 && size <= UINT32_MAX);
    DN_DSMapKey result = {};
    result.type        = DN_DSMapKeyType_Buffer;
    result.buffer_data = data;
    result.buffer_size = DN_CAST(DN_U32) size;
    result.hash        = DN_DSMap_Hash(map, result);
    return result;
}

template <typename T>
DN_DSMapKey DN_DSMap_KeyBufferAsU64NoHash(DN_DSMap<T> const *map, void const *data, DN_U32 size)
{
    DN_DSMapKey result = {};
    result.type        = DN_DSMapKeyType_BufferAsU64NoHash;
    result.buffer_data = data;
    result.buffer_size = DN_CAST(DN_U32) size;
    DN_ASSERT(size >= sizeof(result.hash));
    DN_MEMCPY(&result.hash, data, sizeof(result.hash));
    return result;
}

template <typename T> DN_DSMapKey DN_DSMap_KeyU64(DN_DSMap<T> const *map, DN_U64 u64)
{
    DN_DSMapKey result = {};
    result.type        = DN_DSMapKeyType_U64;
    result.u64         = u64;
    result.hash        = DN_DSMap_Hash(map, result);
    return result;
}

template <typename T> DN_DSMapKey DN_DSMap_KeyStr8(DN_DSMap<T> const *map, DN_Str8 string)
{
    DN_DSMapKey result = DN_DSMap_KeyBuffer(map, string.data, string.size);
    return result;
}
#endif // !defined(DN_NO_DSMAP)

#if !defined(DN_NO_LIST)
// NOTE: [$LIST] DN_List //////////////////////////////////////////////////////////////////////////
template <typename T> DN_List<T> DN_List_Init(DN_USize chunk_size)
{
    DN_List<T> result = {};
    result.chunk_size  = chunk_size;
    return result;
}

template <typename T, size_t N> DN_List<T> DN_List_InitCArray(DN_Arena *arena, DN_USize chunk_size, T const (&array)[N])
{
    DN_List<T> result = DN_List_Init<T>(arena, chunk_size);
    DN_FOR_UINDEX (index, N)
        DN_List_Add(&result, array[index]);
    return result;
}

template <typename T> DN_List<T> DN_List_InitSliceCopy(DN_Arena *arena, DN_USize chunk_size, DN_Slice<T> slice)
{
    DN_List<T> result = DN_List_Init<T>(arena, chunk_size);
    DN_FOR_UINDEX (index, slice.size)
        DN_List_Add(&result, slice.data[index]);
    return result;
}

template <typename T> DN_API bool DN_List_AttachTail_(DN_List<T> *list, DN_ListChunk<T> *tail)
{
    if (!tail)
        return false;

    if (list->tail) {
        list->tail->next = tail;
        tail->prev       = list->tail;
    }

    list->tail = tail;

    if (!list->head)
        list->head = list->tail;
    return true;
}

template <typename T> DN_API DN_ListChunk<T> *DN_List_AllocArena_(DN_List<T> *list, DN_Arena *arena, DN_USize count)
{
    auto           *result = DN_Arena_New(arena, DN_ListChunk<T>, DN_ZeroMem_Yes);
    DN_ArenaTempMem tmem   = DN_Arena_TempMemBegin(arena);
    if (!result)
        return nullptr;

    DN_USize items = DN_MAX(list->chunk_size, count);
    result->data   = DN_Arena_NewArray(arena, T, items, DN_ZeroMem_Yes);
    result->size   = items;
    if (!result->data) {
        DN_Arena_TempMemEnd(tmem);
        result = nullptr;
    }

    DN_List_AttachTail_(list, result);
    return result;
}

template <typename T> DN_API DN_ListChunk<T> *DN_List_AllocPool_(DN_List<T> *list, DN_Pool *pool, DN_USize count)
{
    auto *result = DN_Pool_New(pool, DN_ListChunk<T>);
    if (!result)
        return nullptr;

    DN_USize items = DN_MAX(list->chunk_size, count);
    result->data   = DN_Pool_NewArray(pool, T, items);
    result->size   = items;
    if (!result->data) {
        DN_Pool_Dealloc(result);
        result = nullptr;
    }

    DN_List_AttachTail_(list, result);
    return result;
}

template <typename T> DN_API T *DN_List_MakeArena(DN_List<T> *list, DN_Arena *arena, DN_USize count)
{
    if (list->chunk_size == 0)
        list->chunk_size = 128;

    if (!list->tail || (list->tail->count + count) > list->tail->size) {
        if (!DN_List_AllocArena_(list, arena, count))
            return nullptr;
    }

    T *result = list->tail->data + list->tail->count;
    list->tail->count += count;
    list->count       += count;
    return result;
}

template <typename T> DN_API T *DN_List_MakePool(DN_List<T> *list, DN_Pool *pool, DN_USize count)
{
    if (list->chunk_size == 0)
        list->chunk_size = 128;

    if (!list->tail || (list->tail->count + count) > list->tail->size) {
        if (!DN_List_AllocPool_(list, pool, count))
            return nullptr;
    }

    T *result = list->tail->data + list->tail->count;
    list->tail->count += count;
    list->count       += count;
    return result;
}

template <typename T> DN_API T *DN_List_AddArena(DN_List<T> *list, DN_Arena *arena, T const &value)
{
    T *result = DN_List_MakeArena(list, arena, 1);
    *result   = value;
    return result;
}

template <typename T> DN_API T *DN_List_AddPool(DN_List<T> *list, DN_Pool *pool, T const &value)
{
    T *result = DN_List_MakePool(list, pool, 1);
    *result   = value;
    return result;
}

template <typename T, size_t N> DN_API bool DN_List_AddCArray(DN_List<T> *list, T const (&array)[N])
{
    if (!list)
        return false;
    for (T const &item : array) {
        if (!DN_List_Add(list, item))
            return false;
    }
    return true;
}

template <typename T> DN_API void DN_List_AddListArena(DN_List<T> *list, DN_Arena *arena, DN_List<T> other)
{
    if (!list)
        return;
    // TODO(doyle): Copy chunk by chunk
    for (DN_ListIterator<T> it = {}; DN_List_Iterate(&other, &it, 0 /*start_index*/); )
        DN_List_AddArena(list, arena, *it.data);
}

template <typename T> DN_API void DN_List_AddListPool(DN_List<T> *list, DN_Pool *pool, DN_List<T> other)
{
    if (!list)
        return;
    // TODO(doyle): Copy chunk by chunk
    for (DN_ListIterator<T> it = {}; DN_List_Iterate(&other, &it, 0 /*start_index*/); )
        DN_List_AddPool(list, pool, *it.data);
}

template <typename T> void DN_List_Clear(DN_List<T> *list)
{
    if (!list)
        return;
    list->head  = list->tail = nullptr;
    list->count = 0;
}

template <typename T> DN_API bool DN_List_Iterate(DN_List<T> *list, DN_ListIterator<T> *it, DN_USize start_index)
{
    bool result = false;
    if (!list || !it || list->chunk_size <= 0)
        return result;

    if (it->init) {
        it->index++;
    } else {
        *it = {};
        if (start_index == 0) {
            it->chunk = list->head;
        } else {
            DN_List_At(list, start_index, &it->chunk);
            if (list->chunk_size > 0)
                it->chunk_data_index = start_index % list->chunk_size;
        }

        it->init = true;
    }

    if (it->chunk) {
        if (it->chunk_data_index >= it->chunk->count) {
            it->chunk            = it->chunk->next;
            it->chunk_data_index = 0;
        }

        if (it->chunk) {
            it->data = it->chunk->data + it->chunk_data_index++;
            result         = true;
        }
    }

    if (!it->chunk)
        DN_ASSERT(result == false);
    return result;
}

template <typename T> DN_API T *DN_List_At(DN_List<T> *list, DN_USize index, DN_ListChunk<T> **at_chunk)
{
    if (!list || index >= list->count || !list->head)
        return nullptr;

    // NOTE: Scan forwards to the chunk we need. We don't have random access to chunks
    DN_ListChunk<T> **chunk         = &list->head;
    DN_USize          running_index = index;
    for (; (*chunk) && running_index >= (*chunk)->size; chunk = &((*chunk)->next))
        running_index -= (*chunk)->size;

    T *result = nullptr;
    if (*chunk)
        result = (*chunk)->data + running_index;

    if (result && at_chunk)
        *at_chunk = *chunk;

    return result;
}

template <typename T> DN_Slice<T> DN_List_ToSliceCopy(DN_List<T> const *list, DN_Arena *arena)
{
    // TODO(doyle): Chunk memcopies is much faster
    DN_Slice<T> result = DN_Slice_Alloc<T>(arena, list->count, DN_ZeroMem_No);
    if (result.size) {
        DN_USize slice_index = 0;
        DN_MSVC_WARNING_PUSH
        DN_MSVC_WARNING_DISABLE(6011) // Dereferencing NULL pointer 'x'
        for (DN_ListIterator<T> it = {}; DN_List_Iterate<T>(DN_CAST(DN_List<T> *)list, &it, 0);)
            result.data[slice_index++] = *it.data;
        DN_MSVC_WARNING_POP
        DN_ASSERT(slice_index == result.size);
    }
    return result;
}
#endif // !defined(DN_NO_LIST)

// NOTE: [$SLIC] DN_Slice /////////////////////////////////////////////////////////////////////////
DN_API DN_Str8 DN_Slice_Str8Render(DN_Arena *arena, DN_Slice<DN_Str8> array, DN_Str8 separator)
{
    DN_Str8 result = {};
    if (!arena)
        return result;

    DN_USize total_size = 0;
    for (DN_USize index = 0; index < array.size; index++) {
        if (index)
            total_size += separator.size;
        DN_Str8 item  = array.data[index];
        total_size    += item.size;
    }

    result = DN_Str8_Alloc(arena, total_size, DN_ZeroMem_No);
    if (result.data) {
        DN_USize write_index = 0;
        for (DN_USize index = 0; index < array.size; index++) {
            if (index) {
                DN_MEMCPY(result.data + write_index, separator.data, separator.size);
                write_index += separator.size;
            }
            DN_Str8 item = array.data[index];
            DN_MEMCPY(result.data + write_index, item.data, item.size);
            write_index += item.size;
        }
    }

    return result;
}

DN_API DN_Str8 DN_Slice_Str8RenderSpaceSeparated(DN_Arena *arena, DN_Slice<DN_Str8> array)
{
    DN_Str8 result = DN_Slice_Str8Render(arena, array, DN_STR8(" "));
    return result;
}

DN_API DN_Str16 DN_Slice_Str16Render(DN_Arena *arena, DN_Slice<DN_Str16> array, DN_Str16 separator)
{
    DN_Str16 result = {};
    if (!arena)
        return result;

    DN_USize total_size = 0;
    for (DN_USize index = 0; index < array.size; index++) {
        if (index)
            total_size += separator.size;
        DN_Str16 item  = array.data[index];
        total_size    += item.size;
    }

    result = {DN_Arena_NewArray(arena, wchar_t, total_size + 1, DN_ZeroMem_No), total_size};
    if (result.data) {
        DN_USize write_index = 0;
        for (DN_USize index = 0; index < array.size; index++) {
            if (index) {
                DN_MEMCPY(result.data + write_index, separator.data, separator.size * sizeof(result.data[0]));
                write_index += separator.size;
            }
            DN_Str16 item = array.data[index];
            DN_MEMCPY(result.data + write_index, item.data, item.size * sizeof(result.data[0]));
            write_index += item.size;
        }
    }

    result.data[total_size] = 0;
    return result;
}

DN_API DN_Str16 DN_Slice_Str16RenderSpaceSeparated(DN_Arena *arena, DN_Slice<DN_Str16> array)
{
    DN_Str16 result = DN_Slice_Str16Render(arena, array, DN_STR16(L" "));
    return result;
}

#if !defined(DN_NO_DSMAP)
// NOTE: [$DMAP] DN_DSMap /////////////////////////////////////////////////////////////////////////
DN_API DN_DSMapKey DN_DSMap_KeyU64NoHash(DN_U64 u64)
{
    DN_DSMapKey result = {};
    result.type         = DN_DSMapKeyType_U64NoHash;
    result.u64          = u64;
    result.hash         = DN_CAST(DN_U32) u64;
    return result;
}

DN_API bool DN_DSMap_KeyEquals(DN_DSMapKey lhs, DN_DSMapKey rhs)
{
    bool result = false;
    if (lhs.type == rhs.type && lhs.hash == rhs.hash) {
        switch (lhs.type)  {
            case DN_DSMapKeyType_Invalid:    result = true; break;
            case DN_DSMapKeyType_U64NoHash:  result = true; break;
            case DN_DSMapKeyType_U64:        result = lhs.u64 == rhs.u64; break;

            case DN_DSMapKeyType_BufferAsU64NoHash: /*FALLTHRU*/
            case DN_DSMapKeyType_Buffer: {
                if (lhs.buffer_size == rhs.buffer_size)
                    result = DN_MEMCMP(lhs.buffer_data, rhs.buffer_data, lhs.buffer_size) == 0;
            } break;
        }
    }
    return result;
}

DN_API bool operator==(DN_DSMapKey lhs, DN_DSMapKey rhs)
{
    bool result = DN_DSMap_KeyEquals(lhs, rhs);
    return result;
}
#endif // !defined(DN_NO_DSMAP)