#ifndef VARIANT_H_
#define VARIANT_H_

#include <algorithm>
#include <cstdint>
#include <new>
#include <type_traits>
#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)
    };

    template <typename T, int N = 0>
    static constexpr int index_of()
    {
        if constexpr (std::is_same_v<T, Type>)
            return N;
        else
            return Variant_Helper<Types...>::template index_of<T, N + 1>();
    }

    static void destroy(char* memory, int type)
    {
        if (type == 0)
        {
            as<Type>(memory).~Type();
        }
        else
        {
            Variant_Helper<Types...>::destroy(memory, type - 1);
        }
    }
    
};

template <>
struct Variant_Helper<>
{
    static constexpr std::size_t const size { 0 };

    template <typename T, int N = 0>
    static constexpr int index_of()
    {
        return -1;
    }

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

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

    using Helper = Variant_Helper<Types...>;
    
    char memory[ Helper::size ];
    int  type { -1 };
    
public:

    template <typename T, typename NormalizedType = std::remove_cv_t<std::remove_reference_t<T>>>
    Variant(T&& value)
        // Note: Helper is a dependent name (it depends on Types...) so the compiler will
        // assume that index_of is *not* a template. To fix this we have to add the template
        // keyword before index_of just to communicate to the compiler that it actually is
        // a template (See seminar 6 for details).
        : type { Helper::template index_of<NormalizedType>() }
    {
        new (&memory[0]) NormalizedType { std::forward<T>(value) };
    }

    template <typename T>
    T& get()
    {
        if (Helper::template index_of<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 (Helper::template index_of<NormalizedType>() == type)
        {
            as<NormalizedType>(&memory[0]) = std::forward<T>(value);
        }
        else
        {
            Helper::destroy(&memory[0], type);
            new (&memory[0]) NormalizedType { std::forward<T>(value) };
            type = Helper::template index_of<NormalizedType>();
        }

        return *this;
    }
    
};

#endif