#pragma once

#include <memory>
#include <string>

#include <td/misc/Shapes.h>

#include <td/Types.h>

#include <sp/common/GenericHandler.h>
#include <sp/protocol/ConcreteMessage.h>
#include <sp/protocol/MessageFactory.h>

namespace td {
namespace game {

class World;
class Mob;

typedef std::shared_ptr<Mob> MobPtr;

enum class TowerSize : std::uint8_t {
	Little = 3,	 // 3x3
	Big = 5,	 // 5x5
};

enum class TowerPath : std::uint8_t {
	Top = 0,
	Base,  // Base Path
	Bottom
};

class TowerStats {
  private:
	float m_Rate;
	float m_Damage;
	std::uint8_t m_Range;

  public:
	TowerStats(float rate, float damage, std::uint8_t range) : m_Rate(rate), m_Damage(damage), m_Range(range) {}

	float GetDamageRate() const {
		return m_Rate;
	}
	float GetDamage() const {
		return m_Damage;
	}
	std::uint8_t GetRange() const {
		return m_Range;
	}
};

class TowerLevel {
  private:
	// 1, 2, 3, 4
	std::uint8_t m_Level : 3;
	// 0 : base path       1 : top path (if there is bottom path)     2 : bottom path (if there is top path)
	TowerPath m_Path : 2;

  public:
	TowerLevel() : m_Level(1), m_Path(TowerPath::Base) {}
	TowerLevel(std::uint8_t level, TowerPath path) : m_Level(level), m_Path(path) {}

	std::uint8_t GetLevel() const {
		return m_Level;
	}
	TowerPath GetPath() const {
		return m_Path;
	}

	void SetLevel(std::uint8_t level) {
		m_Level = level;
	}
	void SetPath(TowerPath path) {
		m_Path = path;
	}

	// operator to sort maps
	friend bool operator<(const TowerLevel& level, const TowerLevel& other) {
		return level.GetLevel() + static_cast<std::uint8_t>(level.GetPath()) * 4 <
			   other.GetLevel() + static_cast<std::uint8_t>(other.GetPath()) * 4;
	}
};

using TowerID = std::uint16_t;

class TowerHandler;

class Tower : public utils::shape::Circle, public sp::MessageBase<TowerType, TowerHandler> {
  public:
	TowerID m_ID;
	TowerLevel m_Level{};
	PlayerID m_Builder;

  public:
	Tower() : m_ID(0), m_Level({}), m_Builder(0) {}

	virtual TowerType GetType() const = 0;
	virtual TowerSize GetSize() const = 0;
	virtual void Tick(std::uint64_t delta, World* world) = 0;
};

struct TowerData {};

template <TowerType Type, TowerSize Size>
class ConcreteTower : public sp::ConcreteMessage<TowerData, Tower, Type, false> {
  public:
	using HandlerType = typename sp::ConcreteMessage<TowerData, Tower, Type, false>::HandlerType;

	virtual TowerSize GetSize() const override {
		return Size;
	}

	virtual TowerType GetType() const override {
		return Type;
	}

	virtual void Tick(std::uint64_t delta, World* world) override {}

	virtual void Dispatch(HandlerType& handler) const override {
		handler.Handle(*this);
	}
};

using TowerPtr = std::shared_ptr<Tower>;

using ArcherTower = ConcreteTower<TowerType::Archer, TowerSize::Little>;
using ArtilleryTower = ConcreteTower<TowerType::Artillery, TowerSize::Little>;
using IceTower = ConcreteTower<TowerType::Ice, TowerSize::Little>;
using LeachTower = ConcreteTower<TowerType::Leach, TowerSize::Big>;
using MageTower = ConcreteTower<TowerType::Mage, TowerSize::Little>;
using NecromancerTower = ConcreteTower<TowerType::Necromancer, TowerSize::Big>;
using PoisonTower = ConcreteTower<TowerType::Poison, TowerSize::Little>;
using QuakeTower = ConcreteTower<TowerType::Quake, TowerSize::Little>;
using SorcererTower = ConcreteTower<TowerType::Sorcerer, TowerSize::Little>;
using TurretTower = ConcreteTower<TowerType::Turret, TowerSize::Big>;
using ZeusTower = ConcreteTower<TowerType::Zeus, TowerSize::Little>;

using AllTowers = std::tuple<ArcherTower, ArtilleryTower, IceTower, LeachTower, MageTower, NecromancerTower, PoisonTower, QuakeTower,
	SorcererTower, TurretTower, ZeusTower>;

using TowerFactory = sp::MessageFactory<Tower, AllTowers>;

class TowerHandler : public sp::GenericHandler<AllTowers> {};

}  // namespace game
}  // namespace td