#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 IOTag, typename MessageDispatcher, typename MessageFactory>
class Stream {
  protected:
	MessageDispatcher m_Dispatcher;
	IOInterface<IOTag> m_Interface;

	using MessageBase = typename MessageDispatcher::MessageBaseType;
	using MsgIdType = typename MessageBase::MsgIdType;

  public:
	Stream() {}
	Stream(IOInterface<IOTag>&& a_Interface) : m_Interface(std::move(a_Interface)) {}
	Stream(Stream&& a_Stream) : m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}

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

	MessageDispatcher& GetDispatcher() {
		return m_Dispatcher;
	}
};

}  // namespace io
}  // namespace sp

#include <sp/io/IOInterfaceImpl.inl>