#ifndef _RIVE_DIRTY_FLAGS_HPP_
#define _RIVE_DIRTY_FLAGS_HPP_
#include <type_traits>

namespace rive
{
	enum class ComponentDirt : unsigned short
	{
		None = 0,

		Dependents = 1 << 0,

		/// General flag for components are dirty (if this is up, the update
		/// cycle runs). It gets automatically applied with any other dirt.
		Components = 1 << 1,

		/// Draw order needs to be re-computed.
		DrawOrder = 1 << 2,

		/// Path is dirty and needs to be rebuilt.
		Path = 1 << 3,

		/// Vertices have changed, re-order cached lists.
		Vertices = 1 << 4,

		/// Used by any component that needs to recompute their local transform.
		/// Usually components that have their transform dirty will also have
		/// their worldTransform dirty.
		Transform = 1 << 5,

		/// Used by any component that needs to update its world transform.
		WorldTransform = 1 << 6,

		/// Marked when the stored render opacity needs to be updated.
		RenderOpacity = 1 << 7,

		/// Dirt used to mark some stored paint needs to be rebuilt or that we
		/// just want to trigger an update cycle so painting occurs.
		Paint = 1 << 8,

		/// Used by the gradients track when the stops need to be re-ordered.
		Stops = 1 << 9,

		/// Blend modes need to be updated
		// TODO: do we need this?
		// BlendMode = 1 << 9,

		// Everything is dirty.
		Filthy = 0xFFFF
	};

	inline constexpr ComponentDirt operator&(ComponentDirt lhs,
	                                         ComponentDirt rhs)
	{
		return static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) &
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));
	}

	inline constexpr ComponentDirt operator^(ComponentDirt lhs,
	                                         ComponentDirt rhs)
	{
		return static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) ^
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));
	}

	inline constexpr ComponentDirt operator|(ComponentDirt lhs,
	                                         ComponentDirt rhs)
	{
		return static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) |
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));
	}

	inline constexpr ComponentDirt operator~(ComponentDirt rhs)
	{
		return static_cast<ComponentDirt>(
		    ~static_cast<std::underlying_type<ComponentDirt>::type>(rhs));
	}

	inline ComponentDirt& operator|=(ComponentDirt& lhs, ComponentDirt rhs)
	{
		lhs = static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) |
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));

		return lhs;
	}

	inline ComponentDirt& operator&=(ComponentDirt& lhs, ComponentDirt rhs)
	{
		lhs = static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) &
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));

		return lhs;
	}

	inline ComponentDirt& operator^=(ComponentDirt& lhs, ComponentDirt rhs)
	{
		lhs = static_cast<ComponentDirt>(
		    static_cast<std::underlying_type<ComponentDirt>::type>(lhs) ^
		    static_cast<std::underlying_type<ComponentDirt>::type>(rhs));

		return lhs;
	}
} // namespace rive
#endif