#pragma once

#include <patch/patch.h>
#include <eq_packet.h>
#include "daybreak_connection.h"
#include <vector>

namespace EQ
{
	namespace Net
	{
		struct EQStreamManagerOptions
		{
			EQStreamManagerOptions() {
				compressed = false;
			}

			DaybreakConnectionManagerOptions daybreak_options;
			bool compressed;
		};

		class EQStream;
		class EQStreamManager
		{
		public:
			EQStreamManager(EQStreamManagerOptions &options);
			~EQStreamManager();

			void OnNewConnection(std::function<void(std::shared_ptr<EQStream>)> func) { m_on_new_connection = func; }
			void OnConnectionStateChange(std::function<void(std::shared_ptr<EQStream>, DbProtocolStatus, DbProtocolStatus)> func) { m_on_connection_state_change = func; }
			void OnPacketRecv(std::function<void(std::shared_ptr<EQStream>, EmuOpcode, Packet &)> func) { m_on_packet_recv = func; }

			void RegisterPotentialPatch(EQ::Patches::BasePatch *patch) { m_possible_patches.push_back(std::unique_ptr<EQ::Patches::BasePatch>(patch)); }
		private:
			EQStreamManagerOptions m_options;
			DaybreakConnectionManager m_daybreak;
			std::function<void(std::shared_ptr<EQStream>)> m_on_new_connection;
			std::function<void(std::shared_ptr<EQStream>, DbProtocolStatus, DbProtocolStatus)> m_on_connection_state_change;
			std::function<void(std::shared_ptr<EQStream>, EmuOpcode, Packet &)> m_on_packet_recv;
			std::map<std::shared_ptr<DaybreakConnection>, std::shared_ptr<EQStream>> m_streams;
			std::vector<std::unique_ptr<EQ::Patches::BasePatch>> m_possible_patches;

			void DaybreakNewConnection(std::shared_ptr<DaybreakConnection> connection);
			void DaybreakConnectionStateChange(std::shared_ptr<DaybreakConnection> connection, DbProtocolStatus from, DbProtocolStatus to);
			void DaybreakPacketRecv(std::shared_ptr<DaybreakConnection> connection, Packet &p);
			friend class EQStream;
		};

		class EQStream
		{
		public:
			EQStream(EQStreamManager *parent, std::shared_ptr<DaybreakConnection> connection);
			~EQStream();

			const std::string& RemoteEndpoint() const { return m_connection->RemoteEndpoint(); }
			int RemotePort() const { return m_connection->RemotePort(); }

			void QueuePacket(EmuOpcode type, Packet &p);
			const DaybreakConnectionStats& GetStats() const { return m_connection->GetStats(); }
			void ResetStats();
			size_t GetRollingPing() const { return m_connection->GetRollingPing(); }
			void Close();
			void QueuePacket(EQApplicationPacket *p);
			void FastQueuePacket(EQApplicationPacket **p);

			void RegisterPatch(EQ::Patches::BasePatch *p) { m_patch = p; }
			EQ::Patches::BasePatch *GetRegisteredPatch() { return m_patch; }
		private:
			EQStreamManager *m_owner;
			std::shared_ptr<DaybreakConnection> m_connection;
			EQ::Patches::BasePatch *m_patch;
			friend class EQStreamManager;
		};
	}
}