#pragma once

#include <initializer_list>
#include <type_traits>

template<typename BitEnum>
class Flags
{
  using UnderlyingType = std::underlying_type_t<BitEnum>;

  template<typename T1, typename... REST>
  static constexpr UnderlyingType makeMask(T1 first, REST... rest)
  {
    static_assert((std::is_same_v<T1, BitEnum> && ... && std::is_same_v<REST, BitEnum>), "Arguments must be of enum type");
    return (UnderlyingType(first) | ... | UnderlyingType(rest));
  }

public:
  constexpr Flags() = default;

  /// Constructs a flag set by combining/disjuncting its' arguments.
  template<typename T1, typename... REST>
  constexpr Flags(T1 first, REST... rest)
    : m_flags(makeMask(first, rest...))
  {
  }

  /// Constructs a flag set by combining/disjuncting flags in passed initializer list.
  constexpr Flags(std::initializer_list<BitEnum> list)
  {
    for (auto flag : list)
      m_flags |= UnderlyingType(flag);
  }

  /// Tells whether any of specified flags is set.
  template<typename T1, typename... REST>
  constexpr bool any(T1 first, REST... rest) const
  {
    return bool(m_flags & makeMask(first, rest...));
  }

  /// Tells whether all of specified flags are set.
  template<typename T1, typename... REST>
  constexpr bool all(T1 first, REST... rest) const
  {
    const auto mask = makeMask(first, rest...);
    return (m_flags & mask) == mask;
  }

  /// Tells whether none of specified flags are set.
  template<typename T1, typename... REST>
  constexpr bool none(T1 first, REST... rest) const
  {
    const auto mask = makeMask(first, rest...);
    return !(m_flags & mask);
  }

  /// Sets specified flags.
  template<typename T1, typename... REST>
  Flags& set(T1 first, REST... rest)
  {
    m_flags |= makeMask(first, rest...);
    return *this;
  }

  /// Unsets specified flags.
  template<typename T1, typename... REST>
  Flags& reset(T1 first, REST... rest)
  {
    m_flags &= ~makeMask(first, rest...);
    return *this;
  }

  /// Unsets all flags.
  Flags& clear()
  {
    m_flags = 0;
    return *this;
  }

  constexpr explicit operator bool() const
  {
    return m_flags != 0;
  }

  constexpr bool operator!() const
  {
    return m_flags == 0;
  }

  constexpr operator BitEnum() const
  {
    return BitEnum(m_flags);
  }

  constexpr Flags operator&(Flags r)
  {
    return Flags{BitEnum(m_flags & r.m_flags)};
  }

  constexpr friend Flags operator&(BitEnum l, Flags r)
  {
    return Flags(l) & r;
  }

  constexpr Flags operator|(Flags r)
  {
    return Flags{BitEnum(m_flags | r.m_flags)};
  }

  constexpr friend Flags operator|(BitEnum l, Flags r)
  {
    return Flags(l) | r;
  }

  Flags& operator&=(Flags r)
  {
    m_flags &= r.m_flags;
    return *this;
  }

  Flags& operator|=(Flags r)
  {
    m_flags |= r.m_flags;
    return *this;
  }

private:
  UnderlyingType m_flags = 0;
};

#define MARTY_CPP_MAKE_ENUM_FLAGS(TEnum)                                                       \
    inline constexpr bool operator==(TEnum a, std::underlying_type<TEnum>::type b) {           \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TUnder>(a) == b;                                                    \
    }                                                                                          \
    inline constexpr bool operator==(std::underlying_type<TEnum>::type a, TEnum b) {           \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return a == static_cast<TUnder>(b);                                                    \
    }                                                                                          \
    inline constexpr bool operator!=(TEnum a, std::underlying_type<TEnum>::type b) {           \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TUnder>(a) != b;                                                    \
    }                                                                                          \
    inline constexpr bool operator!=(std::underlying_type<TEnum>::type a, TEnum b) {           \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return a != static_cast<TUnder>(b);                                                    \
    }                                                                                          \
    inline constexpr TEnum operator<<(TEnum a, unsigned b) {                                   \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(static_cast<TUnder>(a) << b);                                \
    }                                                                                          \
    inline constexpr TEnum operator>>(TEnum a, unsigned b) {                                   \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(static_cast<TUnder>(a) >> b);                                \
    }                                                                                          \
    inline constexpr TEnum operator~(TEnum a) {                                                \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(~static_cast<TUnder>(a));                                    \
    }                                                                                          \
    inline constexpr TEnum operator|(TEnum a, TEnum b) {                                       \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(static_cast<TUnder>(a) | static_cast<TUnder>(b));            \
    }                                                                                          \
    inline constexpr TEnum operator&(TEnum a, TEnum b) {                                       \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(static_cast<TUnder>(a) & static_cast<TUnder>(b));            \
    }                                                                                          \
    inline constexpr TEnum operator^(TEnum a, TEnum b) {                                       \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        return static_cast<TEnum>(static_cast<TUnder>(a) ^ static_cast<TUnder>(b));            \
    }                                                                                          \
    inline constexpr TEnum& operator<<=(TEnum& a, unsigned b) {                                \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        a = static_cast<TEnum>(static_cast<TUnder>(a) << b );                                  \
        return a;                                                                              \
    }                                                                                          \
    inline constexpr TEnum& operator>>=(TEnum& a, unsigned b) {                                \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        a = static_cast<TEnum>(static_cast<TUnder>(a) >> b );                                  \
        return a;                                                                              \
    }                                                                                          \
    inline constexpr TEnum& operator|=(TEnum& a, TEnum b) {                                    \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        a = static_cast<TEnum>(static_cast<TUnder>(a) | static_cast<TUnder>(b));               \
        return a;                                                                              \
    }                                                                                          \
    inline constexpr TEnum& operator&=(TEnum& a, TEnum b) {                                    \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        a = static_cast<TEnum>(static_cast<TUnder>(a) & static_cast<TUnder>(b));               \
        return a;                                                                              \
    }                                                                                          \
    inline constexpr TEnum& operator^=(TEnum& a, TEnum b) {                                    \
        using TUnder = typename std::underlying_type<TEnum>::type;                             \
        a = static_cast<TEnum>(static_cast<TUnder>(a) ^ static_cast<TUnder>(b));               \
        return a;                                                                              \
    }

enum class EWinVkFlags : std::uint16_t
{
    kbdExtended     = 1,
    kbdExt          = 1,
    kbdMultivk      = 2,
    kbdSpecial      = 4,
    kbdNumpad       = 8,
    kbdUnicode      = 16,
    kbdInjectedvk   = 32,
    kbdMappedvk     = 64,
    kbdBreak        = 128

}; // enum class EWinVkFlags : std::uint16_t

MARTY_CPP_MAKE_ENUM_FLAGS(EWinVkFlags)

//...

lout << "enum_serialize_flags: " << virtual_keys::enum_serialize_flags(EWinVkFlags::kbdExt | EWinVkFlags::kbdSpecial) << "\n";

// Выводит: enum_serialize_flags: Special|Extended

namespace mask
{
    namespace internal
    {
        template<typename Element>
        constexpr size_t offset(Element const el, Element const base = static_cast<Element>(0))
        {
            const auto diff = toe::cast(el) - toe::cast(base);
            DEBUG_ASSERT(diff >= 0, "Offset can't be negative. Probably base element was set incorrect");
            return diff >= 0 ? static_cast<size_t>(diff) : 0;
        }


        template<typename Enum>
        constexpr Enum clearRightMostBit(Enum const val)
        {
            return static_cast<Enum>((toe::cast(val) - 1) & toe::cast(val));
        }

        template<typename Enum>
        constexpr Enum findRightMostBit(Enum const val)
        {
            return static_cast<Enum>(toe::cast(val) ^ toe::cast(clearRightMostBit(val)));
        }

        template<typename Element, typename Mask>
        constexpr Element transformMaskToValue(Mask const mask, Element const base, const size_t index = 0)
        {
            const auto maskVal = toe::cast(mask);
            if (maskVal == 0) {
                throw std::runtime_error{ "transformMaskToValue was called on the end element of range (mask is 0)" };
            }
            return (maskVal & 1) == 0
                ? transformMaskToValue<Element>(static_cast<Mask>(maskVal >> 1), base, index + 1)
                : static_cast<Element>(index + toe::cast(base));
        }
    }

    template<typename Element, typename Mask>
    constexpr Mask set(Mask const mask, Element const el, Element const base = static_cast<Element>(0))
    {
        return static_cast<Mask>(toe::cast(mask) | 1 << internal::offset(el, base));
    }

    namespace internal
    {
        template<typename Element, typename Mask>
        struct range
        {
            using value_type = Element;
            struct iterator
            {
                using iterator_category = std::input_iterator_tag;
                using value_type = typename range::value_type;
                using difference_type = std::ptrdiff_t;
                using pointer = value_type*;
                using reference = value_type;

                explicit iterator(const Mask mask_, Element const base_)
                    : mask{ mask_ }
                    , base{ base_ }
                {}
                iterator& operator++() { mask = clearRightMostBit(mask); return *this; }
                iterator operator++(int) { iterator retval = *this; ++(*this); return retval; }
                bool operator==(iterator other) const noexcept { return mask == other.mask; }
                bool operator!=(iterator other) const noexcept { return !(*this == other); }
                reference operator*() const
                {
                    return transformMaskToValue<Element>(mask, base);
                }

            private:
                Mask mask;
                Element base;
            };

            using const_iterator = iterator;

            range(Mask const mask_, Element const base_)
                : mask{mask_}
                , base{ base_ }
            {}
            range() = default;
            iterator begin() const { return iterator{ mask, base }; }
            iterator end() const { return iterator{ static_cast<Mask>(0), base }; }

        private:
            Mask mask;
            Element base;
        };
    }

    // base is a first element which is represented by first bit in mask
    template<typename Element, typename Mask>
    internal::range<Element, Mask> split(Mask const mask, Element const base = static_cast<Element>(0))
    {
        return internal::range<Element, Mask>{ mask, base };
    }

    template<typename Element, typename Mask>
    constexpr bool contains(Mask const mask, Element const el, Element const base) noexcept
    {
        return (toe::cast(mask) & (1 << internal::offset(el, base))) != 0;
    }
}