#pragma once

namespace rtc {

namespace detail {

template <typename FlagsT>
struct [[gnu::packed]] FlagsImpl
{
	static_assert(sizeof(FlagsT) == sizeof(uint8_t), "Must use uint8_t enum class flags");

	uint8_t data = 0;
	using Flags = FlagsT;

	FlagsImpl() : data(0) {}
	FlagsImpl(const Flags &flag) : data(static_cast<uint8_t>(flag)) {}

	FlagsImpl(const FlagsImpl &other) : data(other.data) {}
	FlagsImpl(const FlagsImpl &&) = delete;

	FlagsImpl &operator=(const FlagsImpl &rhs)
	{
		data = rhs.data;
		return *this;
	}
	FlagsImpl &operator=(const FlagsImpl &&) = delete;

	FlagsImpl &operator=(const FlagsT &rhs)
	{
		data = static_cast<uint8_t>(rhs);
		return *this;
	}

	FlagsImpl &operator|=(const FlagsT &flag)
	{
		data |= static_cast<uint8_t>(flag);
		return *this;
	}

	FlagsImpl &operator|=(const uint8_t &flag)
	{
		data |= flag;
		return *this;
	}

	FlagsImpl &operator&=(const FlagsT &flag)
	{
		data &= static_cast<uint8_t>(flag);
		return *this;
	}

	FlagsImpl &operator&=(const uint8_t &flag)
	{
		data &= flag;
		return *this;
	}

	FlagsImpl &operator~()
	{
		data = ~data;
		return *this;
	}

	bool operator==(const FlagsT &flag) const
	{
		return data & static_cast<uint8_t>(flag);
	}
};

template <typename FlagsT>
FlagsT operator|(const FlagsT &lhs, const FlagsT &rhs)
{
	const auto lhsInt = static_cast<uint8_t>(lhs);
	const auto rhsInt = static_cast<uint8_t>(rhs);
	return static_cast<FlagsT>(lhsInt | rhsInt);
}

template <typename FlagsT>
FlagsT operator&(const FlagsT &lhs, const FlagsT &rhs)
{
	const auto lhsInt = static_cast<uint8_t>(lhs);
	const auto rhsInt = static_cast<uint8_t>(rhs);
	return static_cast<FlagsT>(lhsInt & rhsInt);
}

} // namespace detail

} // namespace rtc