#pragma once

#include "schema.hpp"

namespace saw {

template<typename Schema>
struct meta_schema {
	static_assert(always_false<Schema>, "Not supported Schema.");
};

template<>
struct meta_schema<schema::Void> {
	using Schema = schema::Void;
	using MetaSchema = schema::Void;
};

template<>
struct meta_schema<schema::Bool> {
	using Schema = schema::Bool;
	using MetaSchema = schema::Void;
};

template<typename T, uint64_t N>
struct meta_schema<schema::Primitive<T,N>> {
	using Schema = schema::Primitive<T,N>;
	using MetaSchema = schema::Void;
};

template<typename TA, uint64_t NA, typename TB, uint64_t NB> 
struct meta_schema<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB> >> {
	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
	using MetaSchema = schema::Void;
};

template<typename T>
struct meta_schema<schema::Ref<T>> {
	using Schema = schema::Ref<T>;
	using MetaSchema = schema::Void;
};

template<typename Key, typename Value>
struct meta_schema<schema::Map<Key,Value>> {
	using Schema = schema::Map<Key,Value>;
	using MetaSchema = schema::Void;
};	

template<typename... T, string_literal... Lit>
struct meta_schema<schema::Struct<schema::Member<T,Lit>...>> {
	using Schema = schema::Struct<schema::Member<T,Lit>...>;
	using MetaSchema = schema::Struct<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
};

template<typename... T, string_literal... Lit>
struct meta_schema<schema::Union<schema::Member<T,Lit>...>> {
	using Schema = schema::Union<schema::Member<T,Lit>...>;
	using MetaSchema = schema::Union<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
};

template<typename... T>
struct meta_schema<schema::Tuple<T...>> {
	using Schema = schema::Tuple<T...>;
	using MetaSchema = schema::Tuple<typename meta_schema<T>::MetaSchema...>;
};

template<>
struct meta_schema<schema::String> {
	using Schema = schema::String;
	using MetaSchema = schema::UInt64;
};

/**
 * Technically we also can distinguish if T is primitive.
 */
template<typename T, uint64_t Dim>
struct meta_schema<schema::Array<T,Dim>> {
	// TODO Technically this should be a FixedArray of the inner meta schema, except when the inner meta schema is Void
	using Schema = schema::Array<T,Dim>;
	using MetaSchema = schema::FixedArray<schema::UInt64,Dim>;
};

template<typename T, uint64_t... Dim>
struct meta_schema<schema::FixedArray<T,Dim...>> {
	// TODO Technically this should be a FixedArray of the inner meta schema, except when the inner meta schema is Void
	using Schema = schema::FixedArray<T,Dim...>;
	using MetaSchema = schema::Void;
};
}