#pragma once

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

namespace sp {

template <typename ValueType>
class Field {
  public:
	// Provide an access to the stored value
	ValueType& GetValue() {
		return m_Value;
	}
	const ValueType& GetValue() const {
		return m_Value;
	}

	// Read (deserialise) and update internal value
	void Read(DataBuffer& buffer) {
		buffer >> m_Value;
	}

	// Write (serialise) internal value
	void Write(DataBuffer& buffer) const {
		buffer << m_Value;
	}

	Field& operator=(const ValueType& value) {
		m_Value = value;
		return *this;
	}

  private:
	ValueType m_Value;
};

// Functor used to read all tuple values
class FieldReader {
  public:
	FieldReader(DataBuffer& buffer) : m_Buffer(buffer) {}

	template <typename TField>
	void operator()(TField& field) {
		field.Read(m_Buffer);
	}

  private:
	DataBuffer& m_Buffer;
};

// Functor used to write all tuple values
class FieldWriter {
  public:
	FieldWriter(DataBuffer& buffer) : m_Buffer(buffer) {}

	template <typename TField>
	void operator()(TField& field) {
		field.Write(m_Buffer);
	}

  private:
	DataBuffer& m_Buffer;
};

namespace details {

template <typename... TFields>
struct FieldsBuilder {};

template <>
struct FieldsBuilder<> {
	using Type = std::tuple<>;
};

template <typename... TFields>
struct FieldsBuilder<std::tuple<TFields...>> {
	using Type = typename FieldsBuilder<TFields...>::Type;
};

template <typename TField, typename... TFields>
struct FieldsBuilder<TField, TFields...> {
	using Type = sp::tuple_cat_t<std::tuple<Field<TField>>, typename FieldsBuilder<TFields...>::Type>;
};
}  // namespace details

}  // namespace sp