#pragma once

#include <stdexcept>

namespace sp {
namespace io {
template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(IOInterface<IOTag>&& a_Interface) : m_Interface(std::move(a_Interface)) {}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(Stream<IOTag, MessageDispatcher, MessageFactory>&& a_Stream) : m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
void Stream<IOTag, MessageDispatcher, MessageFactory>::SendMessage(const MessageBase& a_Message) {
	// TODO: process compress + encryption
	DataBuffer data = a_Message.Write();
	DataBuffer dataSize;
	m_Interface.Write(dataSize << sp::VarInt{data.GetSize()} << data);
}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
	// TODO: process compress + encryption
	while (true) {

		// reading the first VarInt part byte by byte
		std::uint64_t lenghtValue = 0;
		unsigned int readPos = 0;

		while (true) {
			static constexpr int SEGMENT_BITS = (1 << 7) - 1;
			static constexpr int CONTINUE_BIT = 1 << 7;

			DataBuffer buffer = m_Interface.Read(sizeof(std::uint8_t));

			// eof
			if (buffer.GetSize() == 0)
				return;

			std::uint8_t part;
			buffer >> part;
			lenghtValue |= static_cast<std::uint64_t>(part & SEGMENT_BITS) << readPos;

			if ((part & CONTINUE_BIT) == 0)
				break;

			readPos += 7;

			if (readPos >= 8 * sizeof(lenghtValue))
				throw std::runtime_error("VarInt is too big");
		}

		// nothing to read
		if (lenghtValue == 0)
			return;

		DataBuffer buffer;
		buffer = m_Interface.Read(lenghtValue);

		// TODO: process compress + encryption

		MsgIdType packetType;
		buffer >> packetType;

		static const MessageFactory messageFactory;

		std::unique_ptr<MessageBase> message = messageFactory.CreateMessage(packetType);

		assert(message != nullptr);

		message->Read(buffer);

		GetDispatcher().Dispatch(*message);
	}
}

}  // namespace io
}  // namespace sp