#pragma once

#include <sp/common/DataBuffer.h>
#include <sp/io/IoInterface.h>
#include <sp/io/MessageEncapsulator.h>
#include <vector>
#include <memory>

namespace sp {

template <typename TMessageFactory>
class MessageStream {
  protected:
	std::vector<std::shared_ptr<MessageEncapsulator>> m_Encapsulators;
	std::shared_ptr<IoInterface> m_Stream;

	using MessageBaseType = typename TMessageFactory::MessageBaseType;
	using MessageIdType = typename MessageBaseType::MessageIdType;

  public:
	MessageStream(std::shared_ptr<IoInterface>&& a_Stream) : m_Stream(std::move(a_Stream)) {}

	template<typename... TEnc>
	MessageStream(std::shared_ptr<IoInterface>&& a_Stream, TEnc&&... a_Encapsulators) :
		m_Stream(std::move(a_Stream)){
			m_Encapsulators.reserve(sizeof...(a_Encapsulators));
			AddEncapsulators(std::move(a_Encapsulators ...));
		}

	std::unique_ptr<MessageBaseType> ReadMessage();
	std::unique_ptr<MessageBaseType> ReadMessage(MessageIdType a_Id);

	void WriteMessage(const MessageBaseType& a_Message, bool a_WriteId = true);

	template<typename... Args>
	void AddEncapsulators(Args&& ... a_Encapsulators) {
		AddEncapsulators(std::move(std::make_tuple<>(a_Encapsulators ...)));
	}

	template<typename... Args>
	void AddEncapsulators(std::tuple<Args...>&& a_Encapsulators) {
		TupleForEach([this](auto&& a_Encapsulator){
			m_Encapsulators.push_back(std::move(a_Encapsulator));
		}, a_Encapsulators);
	}

  private:
	DataBuffer ReadAndDecapsulate();
	std::unique_ptr<MessageBaseType> MakeMessage(DataBuffer& buffer, MessageIdType a_Id);
};

}  // namespace sp

#include <sp/io/MessageStream.inl>