#pragma once

#include "network/DataBuffer.h"
#include "game/World.h"
#include "game/BaseGame.h"

namespace td {
namespace protocol {

class PacketHandler;

enum class PacketType : std::uint8_t{
    PlayerLogin = 0,
    PlayerJoin,
    PlayerLeave,
    WorldBeginData,
    WorldData,
    ChunkData,
    KeepAlive,
    UpdateMoney,
    UpdateEXP,
    UpdateLobbyTime,
    UpdateGameState,
    Disconnect,
    PlayerList,
    ConnectionInfo,
    SelectTeam,
    UpdatePlayerTeam,
    ServerTps,
    SpawnMob,
};

class Packet{
public:
    Packet(){}
    virtual ~Packet(){}

    virtual DataBuffer Serialize() const = 0;
    virtual void Deserialize(DataBuffer& data) = 0;
    virtual void Dispatch(PacketHandler* handler) = 0;

    virtual PacketType getType() const = 0;
    std::uint8_t getID() const{ return (std::uint8_t)getType(); }
};


class KeepAlivePacket : public Packet{
private:
    std::uint64_t m_AliveID;
public:
    KeepAlivePacket(){}
    KeepAlivePacket(std::uint64_t aliveID): m_AliveID(aliveID){}
    virtual ~KeepAlivePacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    std::uint64_t getAliveID(){ return m_AliveID; }

    virtual PacketType getType() const{ return PacketType::KeepAlive; }
};

class PlayerLoginPacket : public Packet{
private:
    std::string m_PlayerName;
public:
    PlayerLoginPacket(){}
    PlayerLoginPacket(std::string playerName): m_PlayerName(playerName){}
    virtual ~PlayerLoginPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    virtual PacketType getType() const{ return PacketType::PlayerLogin; }

    const std::string& getPlayerName(){ return m_PlayerName; }
};

class WorldBeginDataPacket : public Packet{
private:
    game::TowerTileColorPalette m_TowerPlacePalette;
    game::Color m_WalkablePalette;
    std::vector<game::Color> m_DecorationPalette;

    game::SpawnColorPalette m_SpawnColorPalette;

    game::TilePalette m_TilePalette;

    game::Spawn m_RedSpawn, m_BlueSpawn;
    game::TeamCastle m_RedTower, m_BlueTower;

    const game::World* m_World;
public:
    WorldBeginDataPacket(){}
    WorldBeginDataPacket(const game::World* world): m_World(world){}
    virtual ~WorldBeginDataPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    virtual PacketType getType() const{ return PacketType::WorldBeginData; }

    const game::TowerTileColorPalette& getTowerTilePalette() const{ return m_TowerPlacePalette; }
    const game::Color& getWalkableTileColor() const{ return m_WalkablePalette; }
    const std::vector<game::Color>& getDecorationPalette() const{ return m_DecorationPalette; }

    const game::Spawn& getRedSpawn() const{ return m_RedSpawn; }
    const game::Spawn& getBlueSpawn() const{ return m_BlueSpawn; }

    const game::SpawnColorPalette& getSpawnPalette() const{ return m_SpawnColorPalette; }

    const game::TeamCastle& getRedCastle() const{ return m_RedTower; }
    const game::TeamCastle& getBlueCastle() const{ return m_BlueTower; }

    const game::TilePalette getTilePalette() const{ return m_TilePalette; }
};

class WorldDataPacket : public Packet{
private:
    std::unordered_map<game::ChunkCoord, game::ChunkPtr> m_Chunks;

    const game::World* m_World;
public:
    WorldDataPacket(){}
    WorldDataPacket(const game::World* world): m_World(world){}
    virtual ~WorldDataPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    virtual PacketType getType() const{ return PacketType::WorldData; }

    const std::unordered_map<game::ChunkCoord, game::ChunkPtr>& getChunks() const{ return m_Chunks; }
};

class UpdateMoneyPacket : public Packet{
private:
    std::uint32_t m_NewAmount;
public:
    UpdateMoneyPacket(){}
    UpdateMoneyPacket(std::uint32_t newAmount): m_NewAmount(newAmount){}
    virtual ~UpdateMoneyPacket(){}

    std::uint32_t getGold() const{ return m_NewAmount; }

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    virtual PacketType getType() const{ return PacketType::UpdateMoney; }
};

class UpdateExpPacket : public Packet{
private:
    std::uint32_t m_NewAmount;
public:
    UpdateExpPacket(){}
    UpdateExpPacket(std::uint32_t newAmount): m_NewAmount(newAmount){}
    virtual ~UpdateExpPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    virtual PacketType getType() const{ return PacketType::UpdateEXP; }
};

class UpdateLobbyTimePacket : public Packet{
private:
    std::uint32_t m_RemainingTime;
public:
    UpdateLobbyTimePacket(){}
    UpdateLobbyTimePacket(std::uint32_t remainingTime): m_RemainingTime(remainingTime){}
    virtual ~UpdateLobbyTimePacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    std::uint32_t getRemainingTime() const{ return m_RemainingTime; }

    virtual PacketType getType() const{ return PacketType::UpdateLobbyTime; }
};

class UpdateGameStatePacket : public Packet{
private:
    game::GameState m_GameState;
public:
    UpdateGameStatePacket(){}
    UpdateGameStatePacket(game::GameState gameState): m_GameState(gameState){}
    virtual ~UpdateGameStatePacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    game::GameState getGameState() const{ return m_GameState; }

    virtual PacketType getType() const{ return PacketType::UpdateGameState; }
};

struct PlayerInfo{
    std::string name;
    game::TeamColor team;
};

class PlayerListPacket : public Packet{
private:
    std::map<std::uint8_t, PlayerInfo> m_Players;
public:
    PlayerListPacket(){}
    PlayerListPacket(std::map<std::uint8_t, PlayerInfo> players): m_Players(players){}
    virtual ~PlayerListPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    const std::map<std::uint8_t, PlayerInfo>& getPlayers() const{ return m_Players; }

    virtual PacketType getType() const{ return PacketType::PlayerList; }
};

class PlayerJoinPacket : public Packet{
private:
    std::uint8_t m_PlayerID;
    std::string m_PlayerName;
public:
    PlayerJoinPacket(){}
    PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName): m_PlayerID(playerID), m_PlayerName(playerName){}
    virtual ~PlayerJoinPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    std::uint8_t getPlayerID() const{ return m_PlayerID; }
    const std::string& getPlayerName() const{ return m_PlayerName; }

    virtual PacketType getType() const{ return PacketType::PlayerJoin; }
};

class PlayerLeavePacket : public Packet{
private:
    std::uint8_t m_PlayerID;
public:
    PlayerLeavePacket(){}
    PlayerLeavePacket(std::uint8_t playerID): m_PlayerID(playerID){}
    virtual ~PlayerLeavePacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    std::uint8_t getPlayerID() const{ return m_PlayerID; }

    virtual PacketType getType() const{ return PacketType::PlayerLeave; }
};

class ConnexionInfoPacket : public Packet{
private:
    std::uint8_t m_ConnectionID;
public:
    ConnexionInfoPacket(){}
    ConnexionInfoPacket(std::uint8_t connectionID): m_ConnectionID(connectionID){}
    virtual ~ConnexionInfoPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    std::uint8_t getConnectionID() const{ return m_ConnectionID; }

    virtual PacketType getType() const{ return PacketType::ConnectionInfo; }
};

class SelectTeamPacket : public Packet{
private:
    game::TeamColor m_SelectedTeam;
public:
    SelectTeamPacket(){}
    SelectTeamPacket(game::TeamColor selectedTeam): m_SelectedTeam(selectedTeam){}
    virtual ~SelectTeamPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; }

    virtual PacketType getType() const{ return PacketType::SelectTeam; }
};

class UpdatePlayerTeamPacket : public Packet{
private:
    std::uint8_t m_PlayerID;
    game::TeamColor m_SelectedTeam;
public:
    UpdatePlayerTeamPacket(){}
    UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam): m_PlayerID(playerID), m_SelectedTeam(selectedTeam){}
    virtual ~UpdatePlayerTeamPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; }
    std::uint8_t getPlayerID() const{ return m_PlayerID; }

    virtual PacketType getType() const{ return PacketType::UpdatePlayerTeam; }
};

class DisconnectPacket : public Packet{
private:
    std::string m_Reason; // only when sent from server
public:
    DisconnectPacket(){}
    DisconnectPacket(std::string reason): m_Reason(reason){}
    virtual ~DisconnectPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    const std::string& getReason() const{ return m_Reason; }

    virtual PacketType getType() const{ return PacketType::Disconnect; }
};

class ServerTpsPacket : public Packet{
private:
    float m_TPS;
    std::uint64_t m_PacketSendTime; // used to calculate ping
public:
    ServerTpsPacket(){}
    ServerTpsPacket(float tps, std::uint64_t sendTime): m_TPS(tps), m_PacketSendTime(sendTime){}
    virtual ~ServerTpsPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    float getTPS() const{ return m_TPS; }
    std::uint64_t getPacketSendTime() const {return m_PacketSendTime;}

    virtual PacketType getType() const{ return PacketType::ServerTps; }
};

class SpawnMobPacket : public Packet{
private:
    game::MobID m_MobID;
    game::MobType m_MobType;
    game::MobLevel m_MobLevel;
    game::Direction m_MobDirection;
    game::PlayerID m_Sender;
    float m_MobX, m_MobY;
public:
    SpawnMobPacket(){}
    SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender, 
        float x, float y, game::Direction dir) : m_MobID(id), m_MobType(type), m_MobLevel(level),
        m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y){}
    virtual ~SpawnMobPacket(){}

    virtual DataBuffer Serialize() const;
    virtual void Deserialize(DataBuffer& data);
    virtual void Dispatch(PacketHandler* handler);

    game::MobID getMobID() const{ return m_MobID; }
    game::MobType getMobType() const{ return m_MobType; }
    game::MobLevel getMobLevel() const{ return m_MobLevel; }
    game::Direction getMobDirection() const{ return m_MobDirection; }
    game::PlayerID getSender() const{ return m_Sender; }
    float getMobX() const{ return m_MobX; }
    float getMobY() const{ return m_MobY; }

    virtual PacketType getType() const{ return PacketType::SpawnMob; }
};

}
}