#ifndef FS_RUNEEFFECTS_H
#define FS_RUNEEFFECTS_H

struct RuneEffectLayer
{
	RuneEffectLayer() = default;

	RuneEffectLayer(std::string texture, uint16_t effectId,
		float offsetX, float offsetY,
		float speed, float scale, float opacity, std::string color,
		float flicker, float colorShift, int32_t drawOrder, bool behind) :
		texture(std::move(texture)), effectId(effectId),
		offsetX(offsetX), offsetY(offsetY),
		speed(speed), scale(scale), opacity(opacity), color(std::move(color)),
		flicker(flicker), colorShift(colorShift), drawOrder(drawOrder), behind(behind) {}

	std::string texture;
	uint16_t effectId = 0;
	float offsetX = 0.0f;
	float offsetY = 0.0f;
	float speed = 0.5f;
	float scale = 1.0f;
	float opacity = 0.8f;
	std::string color = "#ffffff";
	float flicker = 0.0f;
	float colorShift = 0.0f;
	int32_t drawOrder = 0;
	bool behind = true;
};

struct RuneEffect
{
	RuneEffect(uint8_t id, std::string name, std::string image,
		uint16_t effectId,
		float speed, float scale, float opacity, std::string color,
		std::string layer, float glow, float colorShift, float noise,
		float scanlines, float flicker,
		int32_t bonusLoot, int32_t bonusDamage, int32_t bonusSpeed, int32_t bonusXp,
		int32_t damageInterval, int32_t damageDelay,
		bool premium) :
		name(std::move(name)), image(std::move(image)), color(std::move(color)),
		layer(std::move(layer)),
		speed(speed), scale(scale), opacity(opacity),
		glow(glow), colorShift(colorShift), noise(noise),
		scanlines(scanlines), flicker(flicker),
		bonusLoot(bonusLoot), bonusDamage(bonusDamage),
		bonusSpeed(bonusSpeed), bonusXp(bonusXp),
		damageInterval(damageInterval > 0 ? damageInterval : 2000),
		damageDelay(damageDelay > 0 ? damageDelay : 200),
		id(id), effectId(effectId), premium(premium) {}

	std::string name;
	std::string image;
	std::string color;
	std::string layer;
	float speed;
	float scale;
	float opacity;
	float glow;
	float colorShift;
	float noise;
	float scanlines;
	float flicker;
	int32_t bonusLoot;
	int32_t bonusDamage;
	int32_t bonusSpeed;
	int32_t bonusXp;
	int32_t damageInterval;
	int32_t damageDelay;
	uint8_t id;
	uint16_t effectId;
	bool premium;

	// Multi-layer support
	std::vector<RuneEffectLayer> layers;

	bool hasLayers() const { return !layers.empty(); }
};

class RuneEffects
{
	public:
		bool reload();
		bool loadFromXml();
		RuneEffect* getRuneEffectByID(uint8_t id);
		RuneEffect* getRuneEffectByName(const std::string& name);

		const std::vector<RuneEffect>& getRuneEffects() const {
			return runeEffects;
		}

	private:
		std::vector<RuneEffect> runeEffects;
};

#endif