#pragma once

#if !defined(VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED)
#define VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED 1

#include <array>
#include <cstddef>
#include <cstring>
#include <memory>
#include <vector>
#include "common.hpp"
#include "variant_wrap.hpp"
#include "vk_capture.h"

namespace vk_capture
{

//
// public defines
//

//
// public constants
//

//
// public types
//

struct VariantPool
{
    static constexpr std::size_t PAGE_SIZE = 1024;
    using page_t = std::array<VkVariantMWN, PAGE_SIZE>;
    using page_ptr_t = std::unique_ptr<page_t>;

    std::vector<page_ptr_t> pages;
    std::size_t nextIndex = 0;

    VkVariantMWN* allocate(std::size_t num = 1);
    inline void reset() { nextIndex = 0; }
};

//
// public functions
//

template<typename TValue>
inline void variantWrap(const TValue& /* value */, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_UNKNOWN_MWN;
}

inline void variantWrap(bool value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_BOOL_MWN;
    outVariant.uintValue = value;
}

inline void variantWrap(std::uint8_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_UINT8_MWN;
    outVariant.uintValue = value;
}

inline void variantWrap(std::int8_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_INT8_MWN;
    outVariant.intValue = value;
}

inline void variantWrap(std::uint16_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_UINT16_MWN;
    outVariant.uintValue = value;
}

inline void variantWrap(std::int16_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_INT16_MWN;
    outVariant.intValue = value;
}

inline void variantWrap(std::uint32_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_UINT32_MWN;
    outVariant.uintValue = value;
}

inline void variantWrap(std::int32_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_INT32_MWN;
    outVariant.intValue = value;
}

inline void variantWrap(std::uint64_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_UINT64_MWN;
    outVariant.uintValue = value;
}

inline void variantWrap(std::int64_t value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_INT64_MWN;
    outVariant.intValue = value;
}

inline void variantWrap(const void* value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_VOID_POINTER_MWN;
    outVariant.voidPointerValue = value;
}

inline void variantWrap(const char* value, VkVariantMWN& outVariant)
{
    const std::size_t len = std::strlen(value);
    outVariant.type = VK_VARIANT_TYPE_STRING_MWN;

    char* copy = allocType<char>(len + 1);
    std::memcpy(copy, value, len + 1);
    outVariant.stringValue = copy;
}

template<typename TPointed>
inline void variantWrap(const TPointed* value, VkVariantMWN& outVariant);

template<typename TEle, std::size_t count>
inline void variantWrap(const TEle (&value)[count], VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_ARRAY_MWN;
    outVariant.arrayValue.numElements = count;
    outVariant.arrayValue.elements = allocVariant(count);

    for (std::size_t idx = 0; idx < count; ++idx) {
        variantWrap(value[idx], outVariant.arrayValue.elements[idx]);
    }
}

template<typename TPointed>
inline void variantWrap(const TPointed* value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_POINTER_MWN;
    if (value != nullptr)
    {
        outVariant.pointerValue = allocVariant(1);
        variantWrap(*value, *outVariant.pointerValue);
    }
    else
    {
        // TODO: now the type is missing ...
        outVariant.pointerValue = nullptr;
    }
}

} // namespace vk_capture

#endif // !defined(VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED)