#pragma once

/**
 * \file Packets.h
 * \brief File containing the definitions of the packets
 */

#include <td/common/NonCopyable.h>
#include <td/protocol/packet/PacketData.h>

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

namespace td {
namespace protocol {

enum class PacketID : std::uint8_t {
	ChatMessage = 0,
	BeginGame,
	Disconnect,
	KeepAlive,
	LockSteps,
	LoggingSuccess,
	PlayerJoin,
	PlayerLeave,
	PlayerLogin,
	WorldHeader,
	WorldData,
};

class PacketHandler;

using PacketBase = sp::MessageBase<PacketID, PacketHandler>;


template <typename TData, PacketID ID>
using PacketMessage = sp::ConcreteMessage<TData, PacketBase, ID>;


namespace packets {

using BeginGamePacket = PacketMessage<pdata::BeginGame, PacketID::BeginGame>;
using ChatMessagePacket = PacketMessage<pdata::ChatMessage, PacketID::ChatMessage>;
using DisconnectPacket = PacketMessage<pdata::Disconnect, PacketID::Disconnect>;
using KeepAlivePacket = PacketMessage<pdata::KeepAlive, PacketID::KeepAlive>;
using LockStepsPacket = PacketMessage<pdata::LockSteps, PacketID::LockSteps>;
using LoggingSuccessPacket = PacketMessage<pdata::LoggingSuccess, PacketID::LoggingSuccess>;
using PlayerJoinPacket = PacketMessage<pdata::PlayerJoin, PacketID::PlayerJoin>;
using PlayerLeavePacket = PacketMessage<pdata::PlayerLeave, PacketID::PlayerLeave>;
using PlayerLoginPacket = PacketMessage<pdata::PlayerLogin, PacketID::PlayerLogin>;
using WorldHeaderPacket = PacketMessage<pdata::WorldHeader, PacketID::WorldHeader>;
using WorldDataPacket = PacketMessage<pdata::WorldData, PacketID::WorldData>;


}  // namespace packets

using AllPackets = std::tuple<packets::BeginGamePacket, packets::ChatMessagePacket, packets::DisconnectPacket,
	packets::KeepAlivePacket, packets::LockStepsPacket, packets::LoggingSuccessPacket, packets::PlayerJoinPacket,
	packets::PlayerLeavePacket, packets::PlayerLoginPacket, packets::WorldHeaderPacket, packets::WorldDataPacket>;

class PacketHandler : public sp::GenericHandler<AllPackets> {};

using PacketDispatcher = sp::MessageDispatcher<PacketBase>;

using PacketFactory = sp::MessageFactory<PacketBase, AllPackets>;

}  // namespace protocol
}  // namespace td