#include <sp/protocol/ConcreteMessage.h>
#include <sp/protocol/MessageDispatcher.h>
#include <sp/protocol/MessageFactory.h>
#include <sp/protocol/MessageHandler.h>
#include <sp/io/MessageStream.h>
#include <sp/io/StdIo.h>

#include <cstdint>
#include <iostream>
#include <fstream>

enum class PacketID { KeepAlive = 0 };

class PacketHandler;

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

template <typename TData, PacketID ID>
using Message = sp::ConcreteMessage<TData, PacketID, ID, PacketHandler>;

struct KeepAlivePacket {
	std::uint64_t m_KeepAlive;
};

using KeepAliveMessage = Message<KeepAlivePacket, PacketID::KeepAlive>;

using AllMessages = std::tuple<KeepAliveMessage>;

class PacketHandler : public sp::MessageHandler<AllMessages> {};

class MyHandler : public PacketHandler {
  public:
	virtual void Handle(const KeepAlivePacket& msg) {
		std::cout << "I recieved a keep alive : " << msg.m_KeepAlive << "\n";
	}
};

using PacketDispatcher = sp::MessageDispatcher<PacketBase>;

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

using PacketStream = sp::MessageStream<PacketFactory>;

int main() {
	KeepAliveMessage m{69UL};

	// dispatch tests

	MyHandler h;
	PacketDispatcher d;
	d.RegisterHandler(PacketID::KeepAlive, &h);
	d.Dispatch(m);
	PacketFactory f;
	auto message = f.CreateMessage(PacketID::KeepAlive);
	d.Dispatch(*message);



	// write tests

	std::ofstream file {"test.bin"};

	PacketStream p(std::make_shared<sp::StdOuput>(file));

	p.WriteMessage(m);

	file.flush();

	std::ifstream file2 {"test.bin"};

	PacketStream p2(std::make_shared<sp::StdInput>(file2));

	auto message2 = p2.ReadMessage();

	d.Dispatch(*message2);

	// message->Write(file);
	// file << std::endl;
	// m.Write(file);
	// file << std::endl;
	// message->Read(file);
	return 0;
}