/**
 * @file
 * @brief Helper for using enum values as flags.
 */
#ifndef STA_CORE_ENUM_FLAGS_HPP
#define STA_CORE_ENUM_FLAGS_HPP

#include <cstdint>


namespace sta
{
    /**
     * @brief 32-bit flag register with enum type representing single flag bits.
     *
     * @tparam F    Enum type used for flag bits
     *
     * @ingroup sta_core
     */
    template <typename F>
    class EnumFlags
    {
    public:
        using flag_type = F;    /**< Enum type used for flag bits */

    public:
        /**
         * @brief Default constructor.
         */
        EnumFlags();
        /**
         * @brief Copy constructor.
         *
         * @param other Flags to copy
         */
        EnumFlags(const EnumFlags & other);
        /**
         * @brief Construct from single flag.
         *
         * @param flag  Single flag bit to set
         */
        EnumFlags(flag_type flag);


        // Modification
        //

        /**
         * @brief Set bits from flags register.
         *
         * @param flags     Flag bits to set
         */
        void set(const EnumFlags & flags);
        /**
         * @brief Clear flag bits.
         *
         * @param flags    Flag bits to clear
         */
        void clear(const EnumFlags & flags);
        /**
         * @brief Clear all flag bits.
         */
        void clear();


        // Inspection
        //

        /**
         * @brief Test if all flags are set.
         *
         * @param flags     Flag bits to check
         * @return          True if all checked flag bits are set
         */
        bool isSet(const EnumFlags & flags) const;

        /**
         * @brief Test if any flag is set.
         *
         * @param flags     Flag bits to check
         * @return          True if any checked flag bit is set
         */
        bool isAnySet(const EnumFlags & flags) const;


        // Operator overloads
        //

        /**
         * @brief Equal to operator.
         *
         * @param rhs   Flags to compare
         * @return      True if flags are equal
         */
        bool operator ==(const EnumFlags & rhs) const;
        /**
         * @brief Not equal to operator.
         *
         * @param rhs   Flags to compare
         * @return      True if flags are not equal
         */
        bool operator !=(const EnumFlags & rhs) const;

        /**
         * @brief Bitwise AND operator.
         *
         * @param rhs   Other flags
         * @return      Result of bitwise AND
         */
        EnumFlags operator &(const EnumFlags & rhs) const;
        /**
         * @brief Bitwise OR operator.
         *
         * @param rhs   Other flags
         * @return      Result of bitwise OR
         */
        EnumFlags operator |(const EnumFlags & rhs) const;

        /**
         * @brief Bitwise AND assignment operator.
         *
         * @param rhs   Other flags
         * @return      Reference to this
         */
        EnumFlags & operator &=(const EnumFlags & rhs);
        /**
         * @brief Bitwise OR assignment operator.
         *
         * @param rhs   Other flags
         * @return      Reference to this
         */
        EnumFlags & operator |=(const EnumFlags & rhs);

        /**
         * @brief Explicitly convert flags to uint32_t.
         */
        explicit operator uint32_t();

    private:
        /**
         * @brief Construct from uint32_t flags.
         *
         * @param flags Flags
         */
        EnumFlags(uint32_t flags);

    private:
        uint32_t flags_;    /**< Flags register */
    };
} // namespace sta


/**
 * @brief Provide overload for operator | to combine enum values.
 *
 * @param enumType  Enum type to overload
 *
 * @ingroup sta_core
 */
#define STA_ENUM_FLAGS_OVERLOAD(enumType) \
    sta::EnumFlags<enumType> operator |(enumType lhs, enumType rhs) \
    { \
        return sta::EnumFlags<enumType>{lhs} | rhs; \
    }

/**
 * @brief Declare alias for sta::EnumFlags specialization.
 *
 * @param enumType  Enum type for specialization
 *
 * @ingroup sta_core
 */
#define STA_ENUM_FLAGS_ALIAS(enumType) \
    using enumType ## Flags = sta::EnumFlags<enumType>

/**
 * @brief Declare enum and create sta::EnumFlags alias and overloads.
 *
 * @param enumType  Name of new enum class
 * @param value1    First enum value
 * @param ...       Enum values 2 - 32
 *
 * @ingroup sta_core
 */
#define STA_ENUM_FLAGS_DECL(enumType, value1, ...) \
    enum class enumType \
    { \
        value1, ##__VA_ARGS__ \
    }; \
    STA_ENUM_FLAGS_ALIAS(enumType); \
    STA_ENUM_FLAGS_OVERLOAD(enumType)


// Include template implementation
#include <sta/enum_flags.tpp>


#endif // STA_CORE_ENUM_FLAGS_HPP