#pragma once

#include <cstdint>
#include <string>
#include <memory>

#include "misc/Time.h"
#include "game/Types.h"

namespace td {
namespace game {

class World;
class Mob;

typedef std::shared_ptr<Mob> MobPtr;

enum class TowerType : std::uint8_t {
    Archer = 0,
    Ice,
    Sorcerer,
    Zeus,
    Mage,
    Artillery,
    Quake,
    Poison,

    Leach,
    Turret,
    Necromancer,

    TowerCount
};

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;
    }
};

const TowerStats* getTowerStats(TowerType type, TowerLevel level);

typedef std::uint16_t TowerID;

class Tower {
private:
    TowerID m_ID;
    TowerType m_Type;
    std::uint16_t m_X, m_Y;
    TowerLevel m_Level{};
    PlayerID m_Builder;
protected:
    utils::CooldownTimer m_Timer;
public:
    Tower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : m_ID(id), m_Type(type), m_X(x), m_Y(y), m_Builder(builder),
        m_Timer(getStats()->getDamageRate() * 1000) { // converting seconds to millis

    }

    virtual TowerType getType() const = 0;
    virtual TowerSize getSize() const = 0;
    virtual void tick(std::uint64_t delta, World* world) = 0;

    void upgrade(std::uint8_t level, TowerPath path) {
        m_Level.setLevel(level);
        m_Level.setPath(path);
        m_Timer.setCooldown(getStats()->getDamageRate() * 1000); // converting seconds to millis
        m_Timer.reset();
    }

    std::uint16_t getID() const { return m_ID; }
    std::uint16_t getX() const { return m_X; }
    std::uint16_t getY() const { return m_Y; }
    const TowerLevel& getLevel() const { return m_Level; }
    const TowerStats* getStats() const { return getTowerStats(m_Type, m_Level); }
    PlayerID getBuilder() const { return m_Builder; }

    bool isMobInRange(MobPtr mob);
};

typedef std::shared_ptr<Tower> TowerPtr;

namespace TowerFactory {

TowerPtr createTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder);
std::string getTowerName(TowerType type);

} // namespace TowerFactory


class TowerInfo {
private:
    std::string m_Name, m_Description;
    bool m_IsBigTower;
public:
    TowerInfo(std::string&& name, std::string&& description, bool big) : m_Name(std::move(name)),
        m_Description(std::move(description)), m_IsBigTower(big) {}

    const std::string& getName() const { return m_Name; }
    const std::string& getDescription() const { return m_Description; }

    bool isBigTower() const { return m_IsBigTower; }
};

const TowerInfo& getTowerInfo(TowerType type);

// ---------- Little Towers ----------

class LittleTower : public Tower {
public:
    LittleTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}

    virtual TowerSize getSize() const { return TowerSize::Little; }

    virtual TowerType getType() const = 0;
    virtual void tick(std::uint64_t delta, World* world) = 0;
};

class ArcherTower : public LittleTower {
public:
    ArcherTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Archer; }
    virtual void tick(std::uint64_t delta, World* world);
};

class IceTower : public LittleTower {
public:
    IceTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Ice; }
    virtual void tick(std::uint64_t delta, World* world);
};

class MageTower : public LittleTower {
public:
    MageTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Mage; }
    virtual void tick(std::uint64_t delta, World* world);
};

class PoisonTower : public LittleTower {
public:
    PoisonTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Poison; }
    virtual void tick(std::uint64_t delta, World* world);
};

class QuakeTower : public LittleTower {
public:
    QuakeTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Quake; }
    virtual void tick(std::uint64_t delta, World* world);
};

class ArtilleryTower : public LittleTower {
public:
    ArtilleryTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Artillery; }
    virtual void tick(std::uint64_t delta, World* world);
};

class SorcererTower : public LittleTower {
public:
    SorcererTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Sorcerer; }
    virtual void tick(std::uint64_t delta, World* world);
};

class ZeusTower : public LittleTower {
public:
    ZeusTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Zeus; }
    virtual void tick(std::uint64_t delta, World* world);
};

// ---------- Big Towers ----------

class BigTower : public Tower {
public:
    BigTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}

    virtual TowerSize getSize() const { return TowerSize::Big; }

    virtual TowerType getType() const = 0;
    virtual void tick(std::uint64_t delta, World* world) = 0;
};

class TurretTower : public BigTower {
public:
    TurretTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Turret; }
    virtual void tick(std::uint64_t delta, World* world);
};

class NecromancerTower : public BigTower {
public:
    NecromancerTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Necromancer; }
    virtual void tick(std::uint64_t delta, World* world);
};

class LeachTower : public BigTower {
public:
    LeachTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}

    virtual TowerType getType() const { return TowerType::Leach; }
    virtual void tick(std::uint64_t delta, World* world);
};

} // namespace game
} // namespace td