#pragma once

#include <memory>
#include <sp/common/DataBuffer.h>

namespace sp {
namespace io {

template <typename IOTag>
class IOInterface {
  public:
	DataBuffer Read(std::size_t a_Amount);
	void Write(const DataBuffer& a_Data);
};

template <typename TOption>
class MessageEncapsulator {
  public:
	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option);
	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option);
};

template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
class Stream {
  protected:
	MessageDispatcher m_Dispatcher;
	IOInterface<IOTag> m_Interface;
	std::tuple<TOptions...> m_Options;

	using MessageBase = typename MessageDispatcher::MessageBaseType;

  public:
	Stream() {}
	Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options);
	Stream(Stream&& a_Stream);

	void RecieveMessages();
	void SendMessage(const MessageBase& a_Message);


	template <typename TOption>
	TOption& GetOption() {
		return std::get<TOption>(m_Options);
	}

	MessageDispatcher& GetDispatcher() {
		return m_Dispatcher;
	}

  private:
	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOptions&... a_Options);
	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOptions&... a_Options);
};

}  // namespace io
}  // namespace sp

#include <sp/io/IOInterfaceImpl.inl>