#ifndef INCLUDE_NCURSES_FLAGS_HPP_
#define INCLUDE_NCURSES_FLAGS_HPP_

#include <type_traits>

#include <ncurses/utils/preamble.hpp>

namespace NCURSES_CPP_NAMESPACE {

template <typename FlagBitsType> struct is_bitmask : public std::false_type {};

template <typename BitType, typename std::enable_if<is_bitmask<BitType>::value,
                                                    bool>::type = true>
class flags {
public:
  using mask_type = typename std::underlying_type<BitType>::type;

  // constructors
  NCURSES_CPP_CONSTEXPR flags() NCURSES_CPP_NOEXCEPT : mask_(0) {}

  NCURSES_CPP_CONSTEXPR flags(BitType bit) NCURSES_CPP_NOEXCEPT
      : mask_(static_cast<mask_type>(bit)) {}

  NCURSES_CPP_CONSTEXPR
  flags(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT : mask_(rhs.mask_) {}

  NCURSES_CPP_CONSTEXPR explicit flags(mask_type flags) : mask_(flags) {}

  // relational operators

#define NCURSES_CPP_RELATIONAL(op)                                             \
  NCURSES_CPP_CONSTEXPR bool operator op(flags<BitType> const &rhs)            \
      const NCURSES_CPP_NOEXCEPT {                                             \
    return mask_ op rhs.mask_;                                                 \
  }

#define NCURSES_CPP_BITWISE(op)                                                \
  NCURSES_CPP_CONSTEXPR flags<BitType> operator op(flags<BitType> const &rhs)  \
      const NCURSES_CPP_NOEXCEPT {                                             \
    return flags<BitType>(mask_ op rhs.mask_);                                 \
  }

#define NCURSES_CPP_ASSIGNMENT(op)                                             \
  NCURSES_CPP_CONSTEXPR_14 flags<BitType> &operator op##=(                     \
      flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT {                        \
    mask_ op## = rhs.mask_;                                                    \
    return *this;                                                              \
  }

  NCURSES_CPP_RELATIONAL(<)
  NCURSES_CPP_RELATIONAL(<=)
  NCURSES_CPP_RELATIONAL(>)
  NCURSES_CPP_RELATIONAL(>=)
  NCURSES_CPP_RELATIONAL(==)
  NCURSES_CPP_RELATIONAL(!=)

  // logical operator
  NCURSES_CPP_CONSTEXPR bool operator!() const NCURSES_CPP_NOEXCEPT {
    return !mask_;
  }

  // bitwise operators
  NCURSES_CPP_BITWISE(&)
  NCURSES_CPP_BITWISE(|)
  NCURSES_CPP_BITWISE(^)

  /*NCURSES_CPP_CONSTEXPR flags<BitType> operator~() const {*/
  /*  return flags<BitType>(m_mask ^ is_bitmask<BitType>::allflags.m_mask);*/
  /*}*/

  // assignment operators
  NCURSES_CPP_CONSTEXPR_14 flags<BitType> &
  operator=(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT {
    mask_ = rhs.mask_;
    return *this;
  }

  NCURSES_CPP_ASSIGNMENT(&)
  NCURSES_CPP_ASSIGNMENT(|)
  NCURSES_CPP_ASSIGNMENT(^)

  // cast operators
  explicit NCURSES_CPP_CONSTEXPR operator bool() const NCURSES_CPP_NOEXCEPT {
    return !!mask_;
  }

  explicit NCURSES_CPP_CONSTEXPR
  operator mask_type() const NCURSES_CPP_NOEXCEPT {
    return mask_;
  }

#undef NCURSES_CPP_RELATIONAL
#undef NCURSES_CPP_BITWISE
#undef NCURSES_CPP_ASSIGNMENT

#if defined(NCURSES_CPP_FLAGS_MASK_TYPE_AS_PUBLIC)
public:
#else
private:
#endif
  mask_type mask_;
};

// TODO:const BitType& - link may be not as good as copy
#define NPP_DEF_GLOB_OP(type_arg, op)                                          \
  template <typename BitType,                                                  \
            typename std::enable_if<is_bitmask<BitType>::value, bool>::type =  \
                true>                                                          \
  NCURSES_CPP_CONSTEXPR_INLINE type_arg operator op(                           \
      const BitType &bit, flags<BitType> const &flags) NCURSES_CPP_NOEXCEPT {  \
    return flags.operator op(bit);                                             \
  }

#define NPP_DEF_GLOB_BITTYPE(op)                                               \
  template <typename BitType,                                                  \
            typename std::enable_if<is_bitmask<BitType>::value, bool>::type =  \
                true>                                                          \
  NCURSES_CPP_CONSTEXPR_INLINE flags<BitType> operator op(                     \
      BitType lhs, BitType rhs) NCURSES_CPP_NOEXCEPT {                         \
    return flags<BitType>(lhs) op rhs;                                         \
  }

#define NPP_DEF_GLOB_OP_BOOL(op) NPP_DEF_GLOB_OP(bool, op)
#define NPP_DEF_GLOB_OP_FLAG(op) NPP_DEF_GLOB_OP(flags<BitType>, op)

#if !defined(NCURSES_CPP_HAS_SPACESHIP_OPERATOR)
// relational operators only needed for pre C++20
NPP_DEF_GLOB_OP_BOOL(<)
NPP_DEF_GLOB_OP_BOOL(<=)
NPP_DEF_GLOB_OP_BOOL(>)
NPP_DEF_GLOB_OP_BOOL(>=)
NPP_DEF_GLOB_OP_BOOL(==)
NPP_DEF_GLOB_OP_BOOL(!=)
#endif

NPP_DEF_GLOB_OP_FLAG(&)
NPP_DEF_GLOB_OP_FLAG(|)
NPP_DEF_GLOB_OP_FLAG(^)

// bitwise operators on BitType
NPP_DEF_GLOB_BITTYPE(&)
NPP_DEF_GLOB_BITTYPE(|)
NPP_DEF_GLOB_BITTYPE(^)

#undef NPP_DEF_GLOB_OP
#undef NPP_DEF_GLOB_OP_BOOL
#undef NPP_DEF_GLOB_OP_FLAG
#undef NPP_DEF_GLOB_BITTYPE

template <typename BitType,
          typename std::enable_if<is_bitmask<BitType>::value>::type>
NCURSES_CPP_CONSTEXPR_INLINE flags<BitType>
operator~(BitType bit) NCURSES_CPP_NOEXCEPT {
  return ~(flags<BitType>(bit));
}

} // namespace NCURSES_CPP_NAMESPACE

#endif // INCLUDE_NCURSES_FLAGS_HPP_