#include <sp/common/GenericHandler.h>
#include <sp/io/MessageStream.h>
#include <sp/io/StdIo.h>
#include <sp/protocol/BitField.h>
#include <sp/protocol/ConcreteMessage.h>
#include <sp/protocol/MessageDispatcher.h>
#include <sp/protocol/MessageFactory.h>

#include <sp/extensions/Compress.h>

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

enum class PacketID : std::uint8_t { KeepAlive = 0, MDC = 1 };

class PacketHandler;

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

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

struct KeepAlivePacket {
	sp::BitField<std::uint16_t, 12> one;
	sp::BitField<std::uint16_t, 4> two;
	std::shared_ptr<std::string> test;
};

struct MDCPacket {
	sp::BitField<std::uint16_t, 12> one;
	sp::BitField<PacketID, 4> two;
	std::unique_ptr<std::string> test;
};

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

using AllMessages = std::tuple<KeepAliveMessage, MDCMessage>;

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

class MyHandler : public PacketHandler {
  public:
	virtual void Handle(const KeepAliveMessage& msg) override {
		std::cout << "I recieved a keep alive : " << *msg->one << " : " << *msg->two << " : " << (msg->test ? *msg->test : "nullptr") << "\n";
	}
	virtual void Handle(const MDCMessage& msg) override {
		std::cout << "I recieved a mdc : " << *msg->one << " : " << static_cast<unsigned>(*msg->two) << " : " << *msg->test << "\n";
	}
};

using PacketDispatcher = sp::MessageDispatcher<PacketBase>;

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

using PacketStream = sp::MessageStream<PacketFactory>;

int main() {
	KeepAliveMessage m{69, 5, std::make_shared<std::string>("I'm a keepalive")};

	// dispatch tests

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



	// write tests

	auto compress = std::make_shared<sp::ZlibCompress>();

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

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

	p.WriteMessage(m);
	p.WriteMessage(MDCMessage{42, PacketID::MDC, std::make_unique<std::string>("Coucou")});

	file.flush();

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

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

	auto message2 = p2.ReadMessage();
	auto message3 = p2.ReadMessage();

	d.Dispatch(*message2);
	d.Dispatch(*message3);

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