namespace saw {
namespace impl {

/**
 * This class provides basic info on sizes of the encode::Forst 
 */
template<typename Schema>
struct forst_codec_info {
	static_assert(always_false<Schema>, "Not supported.");
};

template<typename T, uint64_t N>
struct forst_codec_info<schema::Primitive<T,N>> {
public:
	static constexpr uint64_t layers = 0u;

	static constexpr uint64_t static_size = N;
	
	template<typename Encoding>
	static uint64_t dynamic_size(const data<schema::Primitive<T,N>, Encoding>&) noexcept {
		return 0u;
	}
};

template<>
struct forst_codec_info<schema::String> {
public:
	static constexpr uint64_t layers = 1u;
	
	static constexpr uint64_t static_size = forst_codec_info<typename meta_schema<schema::String>::MetaSchema>::static_size;

	template<typename Encoding>
	static uint64_t dynamic_size (const data<schema::String, Encoding>& dat) noexcept {
		return dat.size() * 1u;
	}
};

template<typename T, uint64_t N>
struct forst_codec_info<schema::Array<T,N>> {
public:
	static constexpr uint64_t layers = 1u + forst_codec_info<T>::layers;

	/// Dimension and the relative pointer
	static constexpr uint64_t static_size = 8u * N + 8u;
	
	template<typename Encoding>
	static uint64_t dynamic_size (const data<schema::String, Encoding>& dat) {
		return dat.size() * forst_codec_info<T>::static_size;
	}
};

template<typename... Members>
struct forst_codec_info<schema::Struct<Members...> > {
public:
	template<uint64_t i>
	static constexpr uint64_t max_layers() noexcept {
		if constexpr ( i < sizeof...(Members) ) {
			using MT = typename parameter_pack_type<i, Members...>::type;

			constexpr uint64_t layer_i = forst_codec_info<typename MT::ValueType>::layers;

			constexpr uint64_t layer_next = max_layers<i+1u>();

			constexpr uint64_t layer_val = layer_i > layer_next ? layer_i : layer_next;

			return layer_val;
		}
		return 0u;
	}

public:
	static constexpr uint64_t layers = max_layers<0u>();

public:
	template<uint64_t i>
	static constexpr uint64_t static_size_calc(){
		if constexpr ( i < sizeof...(Members) ) {
			using MT = typename parameter_pack_type<i, Members...>::type;

			constexpr uint64_t layer_i = forst_codec_info<typename MT::ValueType>::static_size + static_size_calc<i+1u>();
			return layer_i;
		}
		return 0u;
	}
	
public:
	static constexpr uint64_t static_size = static_size_calc<0>();

	template<typename Encoding, uint64_t i>
	static uint64_t dynamic_size_calc(const data<schema::Struct<Members...>, Encoding>& dat) noexcept {
		if constexpr ( i < sizeof...(Members) ){
			using MT = typename parameter_pack_type<i, Members...>::type;

			constexpr uint64_t layer_i = forst_codec_info<typename MT::ValueType>::dynamic_size(dat) + dynamic_size_calc<i+1u>(dat);
			return layer_i;
		}
		return 0u;
	}
public:
	template<typename Encoding>
	static uint64_t dynamic_size(const data<schema::Struct<Members...>, Encoding>& dat) noexcept {
		return dynamic_size_calc<0u>(dat);
	}
};

template<typename... T>
struct forst_codec_info<schema::Tuple<T...>> {
public:
	template<uint64_t i>
	static constexpr uint64_t max_layers() noexcept {
		if constexpr ( i < sizeof...(T) ) {
			using MT = typename parameter_pack_type<i, T...>::type;

			constexpr uint64_t layer_i = forst_codec_info<MT>::layers;

			constexpr uint64_t layer_next = max_layers<i+1u>();

			constexpr uint64_t layer_val = layer_i > layer_next ? layer_i : layer_next;

			return layer_val;
		}
		return 0u;
	}
public:
	static constexpr uint64_t layers = max_layers<0u>();
public:
	template<uint64_t i>
	static constexpr uint64_t static_size_calc(){
		if constexpr ( i < sizeof...(T) ) {
			using MT = typename parameter_pack_type<i, T...>::type;

			constexpr uint64_t layer_i = forst_codec_info<MT>::static_size + layer_size_calc<i+1u>();
		}
		return 0u;
	}
	
public:
	static constexpr uint64_t static_size = static_size_calc<0>();

	template<typename Encoding, uint64_t i>
	static uint64_t dynamic_size_calc(const data<schema::Tuple<T...>, Encoding>& dat) noexcept {
		if constexpr ( i < sizeof...(T) ){
			using MT = typename parameter_pack_type<i, T...>::type;

			constexpr uint64_t layer_i = forst_codec_info<MT>::dynamic_size(dat) + dynamic_size_calc<i+1u>(dat);
			return layer_i;
		}
		return 0u;
	}
public:
	template<typename Encoding>
	static uint64_t dynamic_size(const data<schema::Tuple<T...>, Encoding>& dat) noexcept {
		return dynamic_size_calc<0u>(dat);
	}
};
}
}