#pragma once

#include <forstio/string_literal.hpp>
#include "schema.hpp"
#include "crc32.hpp"

namespace saw {
template<string_literal lit>
struct hash_literal {
	static constexpr uint32_t apply(uint32_t seed){
		constexpr std::string_view view = lit.view();
		return hash<algs::crc32>::update(seed, view);
	}
};

template<typename Schema>
struct schema_hash_seed {
	static constexpr uint32_t apply(uint32_t seed){
		return hash_literal<Schema::name>::apply(seed);
	}
};

template<>
struct schema_hash_seed<schema::SignedInteger> {
	using Schema = schema::SignedInteger;

	static constexpr uint32_t apply(uint32_t seed){
		return hash_literal<Schema::name>::apply(seed);
	}
};

template<>
struct schema_hash_seed<schema::UnsignedInteger> {
	using Schema = schema::UnsignedInteger;

	static constexpr uint32_t apply(uint32_t seed){
		return hash_literal<Schema::name>::apply(seed);
	}
};

template<>
struct schema_hash_seed<schema::FloatingPoint> {
	using Schema = schema::FloatingPoint;

	static constexpr uint32_t apply(uint32_t seed){
		return hash_literal<Schema::name>::apply(seed);
	}
};

template<>
struct schema_hash_seed<schema::String> {
	using Schema = schema::String;

	static constexpr uint32_t apply(uint32_t seed){
		return hash_literal<Schema::name>::apply(seed);
	}
};

template<typename P, uint64_t N>
struct schema_hash_seed<schema::Primitive<P,N>> {
	using Schema = schema::Primitive<P,N>;

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		seed = schema_hash_seed<P>::apply(seed);
		uint64_t val = N;
		std::array<uint8_t,sizeof(uint64_t)> dat{
			static_cast<uint8_t>(val >> 0),
			static_cast<uint8_t>(val >> 8),
			static_cast<uint8_t>(val >> 16),
			static_cast<uint8_t>(val >> 24),
			static_cast<uint8_t>(val >> 32),
			static_cast<uint8_t>(val >> 40),
			static_cast<uint8_t>(val >> 48),
			static_cast<uint8_t>(val >> 56)
		};
		seed = hash<algs::crc32>::update(seed, &dat[0], dat.size());
		return seed;
	}
};

template<typename T, uint64_t N>
struct schema_hash_seed<schema::Array<T,N>> {
	using Schema = schema::Array<T,N>;

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		seed = schema_hash_seed<T>::apply(seed);
		uint64_t val = N;
		std::array<uint8_t,sizeof(uint64_t)> dat{
			static_cast<uint8_t>(val >> 0),
			static_cast<uint8_t>(val >> 8),
			static_cast<uint8_t>(val >> 16),
			static_cast<uint8_t>(val >> 24),
			static_cast<uint8_t>(val >> 32),
			static_cast<uint8_t>(val >> 40),
			static_cast<uint8_t>(val >> 48),
			static_cast<uint8_t>(val >> 56)
		};
		seed = hash<algs::crc32>::update(seed, &dat[0], dat.size());
		return seed;
	}
};

template<typename... T>
struct schema_hash_seed<schema::Tuple<T...>> {
	using Schema = schema::Tuple<T...>;

	template<uint64_t i>
	static constexpr uint32_t apply_ele(uint32_t seed){
		using Type = typename parameter_pack_type<i,T...>::type;
		
		seed = schema_hash_seed<Type>::apply(seed);
		if constexpr ( (i+1) < sizeof...(T) ){
			return apply_ele<i+1>(seed);
		}
		return seed;
	}


	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		if constexpr (sizeof...(T) > 0){
			seed = apply_ele<0>(seed);
		}
		return seed;
	}
};

template<typename... T>
struct schema_hash_seed<tmpl_group<T...>> {
	template<uint64_t i>
	static constexpr uint32_t apply_ele(uint32_t seed){
		using Type = typename parameter_pack_type<i,T...>::type;

		seed = schema_hash_seed<Type>::apply(seed);
		if constexpr ( (i+1u) < sizeof...(T) ){
			return apply_ele<i+1u>(seed);
		}

		return seed;
	}

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<tmpl_group<T...>::name>::apply(seed);
		if constexpr (sizeof...(T)>0u){
			seed = apply_ele<0u>(seed);
		}
		return seed;
	}
};

template<typename V, string_literal K>
struct schema_hash_seed<schema::Member<V,K>> {
	using Schema = schema::Member<V,K>;

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		seed = schema_hash_seed<V>::apply(seed);
		seed = hash_literal<K>::apply(seed);
		return seed;
	}
};

template<typename... Members>
struct schema_hash_seed<schema::Struct<Members...>> {
	using Schema = schema::Struct<Members...>;

	template<uint64_t i>
	static constexpr uint32_t apply_ele(uint32_t seed){
		using MemberT = typename parameter_pack_type<i,Members...>::type;

		seed = schema_hash_seed<MemberT>::apply(seed);

		if constexpr ( (i+1) < sizeof...(Members) ){
			return apply_ele<i+1>(seed);
		}
		return seed;
	}

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		if constexpr (sizeof...(Members) > 0){
			seed = apply_ele<0>(seed);
		}
		return seed;
	}
};

template<typename Req, typename Resp>
struct schema_hash_seed<schema::Function<Req, Resp>> {
	using Schema = schema::Function<Req,Resp>;

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		seed = schema_hash_seed<Req>::apply(seed);
		seed = schema_hash_seed<Resp>::apply(seed);
		return seed;
	}
};

template<typename... T, string_literal... Names>
struct schema_hash_seed<schema::Interface<schema::Member<T, Names>...>> {
	using Schema = schema::Interface<schema::Member<T,Names>...>;

	template<uint64_t i>
	static constexpr uint32_t apply_ele(uint32_t seed){
		using Type = typename parameter_pack_type<i,T...>::type;
		constexpr string_literal Lit = parameter_key_pack_type<i,Names...>::literal;
		using MemberT = schema::Member<Type,Lit>;

		seed = schema_hash_seed<MemberT>::apply(seed);

		if constexpr ( (i+1) < sizeof...(T) ){
			return apply_ele<i+1>(seed);
		}

		return seed;
	}

	static constexpr uint32_t apply(uint32_t seed){
		seed = hash_literal<Schema::name>::apply(seed);
		if constexpr ( sizeof...(T) > 0){
			seed = apply_ele<0>(seed);
		}
		return seed;
	}
};

template<typename Schema>
struct schema_hash {
	static constexpr uint32_t apply() {
		constexpr uint32_t seed = 0;
		return schema_hash_seed<Schema>::apply(seed);
	}
};

}