#pragma once

#include <sp/protocol/MessageBase.h>
#include <sp/io/MessageIO.h>

namespace sp {

template <typename TData, typename MessageBase, typename MessageBase::MessageIdType ID, bool DefineDispatch = true>
class ConcreteMessage : public MessageBase {
  public:
	using DataType = TData;
	using MessageIdType = typename MessageBase::MessageIdType;
	using HandlerType = typename MessageBase::HandlerType;

	template <typename... T>
	ConcreteMessage(T&&... args) : m_Data{std::move(args)...} {}

	virtual ~ConcreteMessage() {}

	virtual MessageIdType GetId() const override {
		return ID;
	}

	virtual void Dispatch(HandlerType& handler) const override {
		if constexpr (DefineDispatch)
			handler.Handle(*this);
	}

	virtual void Read(DataBuffer& a_Buffer) override {
		ReadMessage(a_Buffer, m_Data);
	}

	virtual DataBuffer Write() const override {
		return WriteMessage(m_Data);
	}

	DataType& operator*() {
		return m_Data;
	}

	DataType* operator->() {
		return &m_Data;
	}

	const DataType& operator*() const {
		return m_Data;
	}

	const DataType* operator->() const {
		return &m_Data;
	}

  private:
	DataType m_Data;
};

}  // namespace sp