#pragma once

#include <sp/protocol/Options.h>

namespace sp {
namespace details {

template <typename... TOptions>
struct MessageInterfaceParsedOptions {};

template <>
struct MessageInterfaceParsedOptions<> {
	static const bool HasMsgIdType = false;
	static const bool HasLittleEndian = false;
	static const bool HasReadOperations = false;
	static const bool HasWriteOperations = false;
	static const bool HasHandler = false;
	static const bool HasValid = false;
};





template <typename T, typename... TOptions>
struct MessageInterfaceParsedOptions<option::MsgIdType<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasMsgIdType = true;
	using MsgIdType = T;
};

template <typename... TOptions>
struct MessageInterfaceParsedOptions<option::LittleEndian, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasLittleEndian = true;
};

template <typename... TOptions>
struct MessageInterfaceParsedOptions<option::ReadOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasReadOperations = true;
};

template <typename... TOptions>
struct MessageInterfaceParsedOptions<option::WriteOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasWriteOperations = true;
};

template <typename T, typename... TOptions>
struct MessageInterfaceParsedOptions<option::Handler<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasHandler = true;
	using HandlerType = option::Handler<T>;
};

template <typename... TOptions>
struct MessageInterfaceParsedOptions<option::ValidCheckInterface, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
	static const bool HasValid = true;
};





// ID retrieval chunk
template <typename TBase, typename TId>
class MessageInterfaceIdTypeBase : public TBase {
  public:
	using MsgIdType = TId;
	MsgIdType GetId() const {
		return GetIdImpl();
	}

  protected:
	virtual MsgIdType GetIdImpl() const = 0;
};

// Big endian serialisation chunk
template <typename TBase>
class MessageInterfaceBigEndian : public TBase {
  protected:
	template <typename T>
	static T ReadData(DataBuffer& buffer) {
		// use big endian
	}

	template <typename T>
	static void WriteData(T value, DataBuffer& buffer) {
		// use big endian
	}
};

// Little endian serialisation chunk
template <typename TBase>
class MessageInterfaceLittleEndian : public TBase {
  protected:
	template <typename T>
	static T ReadData(DataBuffer& buffer) {
		// use little endian
	}

	template <typename T>
	static void WriteData(const T& value, DataBuffer& buffer) {
		// use little endian
	}
};

// Read functionality chunk
template <typename TBase>
class MessageInterfaceReadBase : public TBase {
  public:
	void Read(DataBuffer& buffer) {
		return ReadImpl(buffer);
	}

  protected:
	virtual void ReadImpl(DataBuffer& buffer) = 0;
};

// Write functionality chunk
template <typename TBase>
class MessageInterfaceWriteBase : public TBase {
  public:
	void Write(DataBuffer& buffer) {
		return WriteImpl(buffer);
	}

  protected:
	virtual void WriteImpl(DataBuffer& buffer) = 0;
};

// Handler functionality chunk
template <typename TBase, typename THandler>
class MessageInterfaceHandlerBase : public TBase {
  public:
	using HandlerType = typename THandler::HandlerT;

	void Dispatch(HandlerType& handler) {
		DispatchImpl(handler);
	}

  protected:
	virtual void DispatchImpl(HandlerType& handler) = 0;
};

// Validity functionality chunk
template <typename TBase>
class MessageInterfaceValidityBase : public TBase {
  public:
	bool Valid() const {
		return ValidImpl();
	}

  protected:
	virtual bool ValidImpl() const = 0;
};






// Build message Id
template <typename TBase, typename TParsedOptions, bool THasMsgIdType>
struct MessageInterfaceProcessMsgId;

template <typename TBase, typename TParsedOptions>
struct MessageInterfaceProcessMsgId<TBase, TParsedOptions, true> {
	using Type = MessageInterfaceIdTypeBase<TBase, typename TParsedOptions::MsgIdType>;
};

template <typename TBase, typename TParsedOptions>
struct MessageInterfaceProcessMsgId<TBase, TParsedOptions, false> {
	using Type = TBase;
};

// Build endianess
template <typename TBase, bool THasLittleEndian>
struct MessageInterfaceProcessEndian;

template <typename TBase>
struct MessageInterfaceProcessEndian<TBase, true> {
	using Type = MessageInterfaceLittleEndian<TBase>;
};

template <typename TBase>
struct MessageInterfaceProcessEndian<TBase, false> {
	using Type = MessageInterfaceBigEndian<TBase>;
};

// Build read
template <typename TBase, bool THasRead>
struct MessageInterfaceProcessRead;

template <typename TBase>
struct MessageInterfaceProcessRead<TBase, true> {
	using Type = MessageInterfaceReadBase<TBase>;
};

template <typename TBase>
struct MessageInterfaceProcessRead<TBase, false> {
	using Type = TBase;
};

// Build write
template <typename TBase, bool THasWrite>
struct MessageInterfaceProcessWrite;

template <typename TBase>
struct MessageInterfaceProcessWrite<TBase, true> {
	using Type = MessageInterfaceWriteBase<TBase>;
};

template <typename TBase>
struct MessageInterfaceProcessWrite<TBase, false> {
	using Type = TBase;
};

// Build handler
template <typename TBase, typename TParsedOptions, bool THasHandler>
struct MessageInterfaceProcessHandler;

template <typename TBase, typename TParsedOptions>
struct MessageInterfaceProcessHandler<TBase, TParsedOptions, true> {
	using Type = MessageInterfaceHandlerBase<TBase, typename TParsedOptions::HandlerType>;
};

template <typename TBase, typename TParsedOptions>
struct MessageInterfaceProcessHandler<TBase, TParsedOptions, false> {
	using Type = TBase;
};

// Build valid
template <typename TBase, bool THasValid>
struct MessageInterfaceProcessValid;

template <typename TBase>
struct MessageInterfaceProcessValid<TBase, true> {
	using Type = MessageInterfaceValidityBase<TBase>;
};

template <typename TBase>
struct MessageInterfaceProcessValid<TBase, false> {
	using Type = TBase;
};
}  // namespace details
}  // namespace sp