#ifndef VARIANT_H_
#define VARIANT_H_

#include <algorithm>
#include <cstdint>
#include <new>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <utility>

template <typename T>
T& as(char* memory)
{
    return *std::launder(reinterpret_cast<T*>(memory));
}

template <typename... Types>
struct Variant_Helper;

template <typename Type, typename... Types>
struct Variant_Helper<Type, Types...>
{
    
    static constexpr std::size_t const size {
        std::max(sizeof(Type), Variant_Helper<Types...>::size)
    };

    static void destroy(char* memory, std::type_index type)
    {
        if (typeid(Type) == type)
            as<Type>(memory).~Type();
        else
            Variant_Helper<Types...>::destroy(memory, type);
            
    }
    
};

template <>
struct Variant_Helper<>
{

    static constexpr std::size_t const size { 0 };

    static void destroy(char*, std::type_index)
    {
        throw std::bad_cast{};
    }
    
};

template <typename... Types>
class Variant
{
private:

    using Helper = Variant_Helper<Types...>;
    
    char memory[ Helper::size ];
    std::type_index type;

public:

    template <typename T, typename NormalizedType = std::remove_cv_t<std::remove_reference_t<T>>>
    Variant(T&& value)
        : type { typeid(NormalizedType) }
    {
        new (&memory[0]) NormalizedType { std::forward<T>(value) };
    }

    template <typename T>
    T& get()
    {
        if (typeid(T) == type)
            return as<T>(&memory[0]);
        else
            throw std::bad_cast{};
    }

    template <typename T, typename NormalizedType = std::remove_cv_t<std::remove_reference_t<T>>>
    Variant& operator=(T&& value)
    {
        if (typeid(T) == type)
        {
            as<NormalizedType>(&memory[0]) = std::forward<T>(value);
        }
        else
        {
            Helper::destroy(&memory[0], type);
            new (&memory[0]) NormalizedType { std::forward<T>(value) };
            type = typeid(NormalizedType);
        }

        return *this;
    }
    
};

#endif