Simple-Protocol-Lib/include/sp/io/IOInterfaceImpl.inl

#pragma once

#include <sp/extensions/Compress.h>
#include <stdexcept>

namespace sp {

namespace details {

template <typename... TOptions>
struct MessageEncapsulatorPack {};

template <>
struct MessageEncapsulatorPack<> {
	static DataBuffer Encapsulate(const DataBuffer& a_Data) {
		return a_Data;
	}
	static DataBuffer Decapsulate(DataBuffer& a_Data) {
		return a_Data;
	}
};

template <typename TOption, typename... TOptions>
struct MessageEncapsulatorPack<TOption, TOptions...> {
	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
		DataBuffer data = io::MessageEncapsulator<TOption>::Encapsulate(a_Data, a_Option);
		return MessageEncapsulatorPack<TOptions...>::Encapsulate(data, a_Options...);
	}
	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
		DataBuffer data = io::MessageEncapsulator<TOption>::Decapsulate(a_Data, a_Option);
		return MessageEncapsulatorPack<TOptions...>::Decapsulate(data, a_Options...);
	}
};

}  // namespace details

namespace io {

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options) :
	m_Interface(std::move(a_Interface)), m_Options(std::make_tuple<TOptions...>(std::move(a_Options)...)) {}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
	Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>&& 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, typename... TOptions>
void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(const MessageBase& a_Message) {
	DataBuffer data = a_Message.Write();
	DataBuffer encapsulated = std::apply([&data](const auto&... a_Options) {
		return Encapsulate(data, a_Options...);
	}, m_Options);
	DataBuffer finalData;
	finalData << VarInt{encapsulated.GetSize()} << encapsulated;
	m_Interface.Write(finalData);
}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessages() {
	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);

		buffer = std::apply([&buffer, lenghtValue](const auto&... a_Options) {
			return Decapsulate(buffer, a_Options...);
		}, m_Options);

		VarInt packetType;
		buffer >> packetType;

		static const MessageFactory messageFactory;

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

		assert(message != nullptr);

		message->Read(buffer);

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

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Encapsulate(
	const DataBuffer& a_Data, const TOptions&... a_Options) {
	return details::MessageEncapsulatorPack<TOptions...>::Encapsulate(a_Data, a_Options...);
}

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Decapsulate(
	DataBuffer& a_Data, const TOptions&... a_Options) {
	return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Options...);
}

}  // namespace io
}  // namespace sp