#pragma once

#include <sp/common/DataBuffer.h>

namespace sp {

template <typename TMessageFactory>
class SerializableMessage {
	using MessageBaseType = typename TMessageFactory::MessageBaseType;
	using HandlerType = typename MessageBaseType::HandlerType;
	using MessageIdType = typename MessageBaseType::MessageIdType;

  public:
	std::shared_ptr<MessageBaseType> m_Message;

	SerializableMessage() {}
	SerializableMessage(std::shared_ptr<MessageBaseType>&& a_Message) : m_Message(a_Message) {}
	SerializableMessage(const std::shared_ptr<MessageBaseType>& a_Message) : m_Message(a_Message) {}

	MessageBaseType* operator->() {
		return m_Message.get();
	}

	operator bool() {
		return m_Message.get();
	}

	const MessageBaseType* operator->() const {
		return m_Message.get();
	}
};


template <typename TMessageFactory>
DataBuffer& operator<<(DataBuffer& a_Buffer, const SerializableMessage<TMessageFactory>& a_Message) {
	return a_Buffer << VarInt{static_cast<std::uint64_t>(a_Message->GetId())} << a_Message->Write();
}

template <typename TMessageFactory>
DataBuffer& operator>>(DataBuffer& a_Buffer, SerializableMessage<TMessageFactory>& a_Message) {
	using MsgId = typename TMessageFactory::IdType;
	using MsgBase = typename TMessageFactory::MessageBaseType;
	static TMessageFactory factory;

	VarInt msgId;
	a_Buffer >> msgId;

	auto msgPtr = std::shared_ptr<MsgBase>(factory.CreateMessage(MsgId(msgId.GetValue())).release());

	a_Message = SerializableMessage<TMessageFactory>(msgPtr);
	a_Message->Read(a_Buffer);

	return a_Buffer;
}

}  // namespace sp