#pragma once

#include <forstio/common.hpp>
#include <forstio/templates.hpp>
#include <forstio/string_literal.hpp>

namespace saw {
template <class T> struct is_primitive {
	constexpr static bool value = false;
};

namespace schema {
// NOLINTBEGIN

/**
 * Void Type used for function schemas
 */
struct Void {
	static constexpr string_literal name = "Void";
};

/**
 * Boolean type
 */
struct Bool {
	static constexpr string_literal name = "Bool";
};

template <typename Schema, string_literal Literal> struct Member {
	static constexpr string_literal name = "Member";

	using ValueType = Schema;
	static constexpr string_literal KeyLiteral = Literal;
};

template<typename Key, typename Value> struct Map {
	static constexpr string_literal name = "Map";

	using KeyType = Key;
	using ValueType = Value;
};

template <typename... T> struct Struct {
	static_assert(
		always_false<T...>,
		"This schema template doesn't support this type of template argument");
};

template <typename... Schema, string_literal... Key>
struct Struct<Member<Schema, Key>...> {
	static constexpr string_literal name = "Struct";
};

template <typename... T> struct Union {
	static_assert(
		always_false<T...>,
		"This schema template doesn't support this type of template argument");
};

template <typename... V, string_literal... K>
struct Union<Member<V, K>...> {
	static constexpr string_literal name = "Union";
};

template <typename T, size_t Dim = 1> struct Array {
	static constexpr string_literal name = "Array";
};

template<typename T, size_t... S> struct FixedArray {
	static constexpr string_literal name = "FixedArray";
};

template <typename... T> struct Tuple {
	static constexpr string_literal name = "Tuple";
};

/**
 * This acts as a separator of different encodings being mashed together
 * For example we can transport any base64 encodings in JSON
 *
 * using WrappedExample = schema::Tuple<
 *  schema::Wrapper<schema::String, encode::Base64>
 * >;
 *
 * data<WrappedExample, encode::Json> ex_data;
 */
template <typename Schema, typename Enc>
class Wrapper {
	static constexpr string_literal name = "Wrapper";
};

/**
 * The schema version of ref<T>.
 * See the Ptr<T> comment on this.
 */
template<typename Schema>
class Ref {
	static constexpr string_literal name = "Ref";
};

/**
 * The schema version of ptr<T>
 * It has the advantage that if used in the data class
 * it won't change the interface of the data instance.
 * Meaning that data<Ptr<UInt64>> acts as if it's data<UInt64>
 * in terms of arithmetic operations. It's mostly useful for arrays of primitive types.
 * In cases where Array<Float64> should be translated to a double*.
 * In that case we still want the data class as an accesor on the array, so we provide the
 * data<Ptr<Float64>> type.
 */
template<typename Schema>
class Ptr {
	static constexpr string_literal name = "Ptr";
};

struct String {
	static constexpr string_literal name = "String";
};

struct SignedInteger {
	static constexpr string_literal name = "SignedInteger";
};
struct UnsignedInteger {
	static constexpr string_literal name = "UnsignedInteger";
};
struct FloatingPoint {
	static constexpr string_literal name = "FloatingPoint";
};

template <class T, size_t N> struct Primitive {
	static_assert(((std::is_same_v<T, SignedInteger> ||
					std::is_same_v<T, UnsignedInteger>)&&(N == 1 || N == 2 ||
														  N == 4 || N == 8)) ||
					  (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
				  "Primitive Type is not supported");
	static constexpr string_literal name = "Primitive";
	
	using InterfaceSchema = Primitive<T,N>;
	using StorageSchema = Primitive<T,N>;
};

using Int8 = Primitive<SignedInteger, 1>;
using Int16 = Primitive<SignedInteger, 2>;
using Int32 = Primitive<SignedInteger, 4>;
using Int64 = Primitive<SignedInteger, 8>;

using UInt8 = Primitive<UnsignedInteger, 1>;
using UInt16 = Primitive<UnsignedInteger, 2>;
using UInt32 = Primitive<UnsignedInteger, 4>;
using UInt64 = Primitive<UnsignedInteger, 8>;

using Float32 = Primitive<FloatingPoint, 4>;
using Float64 = Primitive<FloatingPoint, 8>;

/**
 * Classes allowing to distinguish Ints from VarInts
 */
template<typename T, uint64_t MaxLen>
struct VariableLengthPrimitive {
	static constexpr string_literal name = "VariableLengthPrimitive";
};

using VarInt = VariableLengthPrimitive<SignedInteger, 5>;
using VarLong = VariableLengthPrimitive<SignedInteger, 10>;

template<typename PrimA, typename PrimB>
struct MixedPrecision {
	using InterfaceSchema = PrimA;
	using StorageSchema = PrimB;

	static_assert(is_primitive<PrimA>::value, "InterfaceSchema needs to be a Primitive");
	static_assert(is_primitive<PrimB>::value, "StorageSchema needs to be a Primitive");
};

/**
 * Classes enabling Rpc calls
 */
template <class Request, class Response>
struct Function {
	static constexpr string_literal name = "Function";

	using RequestT = Request;
	using ResponseT = Response;
};

template <class... T> struct Interface {
	static_assert(
		always_false<T...>,
		"This schema template doesn't support this type of template argument");
	
	static constexpr string_literal name = "Interface";
};

template <class... Requests, class... Responses, string_literal... Names>
struct Interface<Member<Function<Requests, Responses>,Names>...> {
	static constexpr string_literal name = "Interface";
};

// NOLINTEND
} // namespace schema

template<typename T, typename Schema> 
struct schema_has_member{
	static_assert(
		always_false<T, Schema>,
		"Not supported schema case");
};

/**
 * Checks if identical type exists in schema structure
 */
template<typename T, typename... Members>
struct schema_has_member<T, schema::Struct<Members...>> {
private:
	template<size_t i>
	static constexpr bool value_element() {
		if constexpr ( i < sizeof...(Members) ){
			using MT = typename parameter_pack_type<i, Members...>::type;
			if constexpr ( std::is_same_v<T,MT> ) {
				return true;
			} else {
				return value_element<i+1u>();
			}
		}
		return false;
	}
public:
	static constexpr bool value = value_element<0>();
};

/**
 *
 */
template<string_literal Key, typename Schema>
struct schema_has_key {
	static_assert(
		always_false<Schema>,
		"Not supported schema case");
};

template<string_literal Key, typename... Members>
struct schema_has_key<Key, schema::Struct<Members...>> {
private:
	template<size_t i>
	static constexpr bool value_element() {
		if constexpr ( i < sizeof...(Members) ){
			using MT = typename parameter_pack_type<i, Members...>::type;

			if constexpr ( Key == MT::KeyLiteral ) {
				return true;
			}else{
				return value_element<i+1u>();
			}
		}
		return false;
	}
public:
	static constexpr bool value = value_element<0>();
};

template<string_literal Name, typename Iface>
struct schema_member_index {
	static_assert(
		always_false<Iface>,
		"Not supported schema case");
};

template<string_literal Name, typename... MemberVals, string_literal... MemberKeys >
struct schema_member_index<Name, schema::Interface<schema::Member<MemberVals, MemberKeys>...>> {
	static constexpr uint64_t value = parameter_key_pack_index<Name, MemberKeys...>::value;
};

template<string_literal Name, typename Iface>
struct schema_member_type {
	static_assert(
		always_false<Iface>,
		"Not supported schema case");
};

template<string_literal Name, typename... MemberVals, string_literal... MemberKeys >
struct schema_member_type<Name, schema::Interface<schema::Member<MemberVals, MemberKeys>...>> {

	using type = typename parameter_pack_type<schema_member_index<Name, schema::Interface<schema::Member<MemberVals,MemberKeys>...>>::value, MemberVals...>::type;
};

template <class T> struct is_struct {
	constexpr static bool value = false;
};

template <class... V, string_literal... K> struct is_struct<schema::Struct<schema::Member<V,K>...>> {
	constexpr static bool value = true;
};

template <class T> struct is_string {
	constexpr static bool value = false;
};

template <> struct is_string<schema::String> {
	constexpr static bool value = true;
};

template <class T> struct is_tuple {
	constexpr static bool value = false;
};

template <class... T> struct is_tuple<schema::Tuple<T...>> {
	constexpr static bool value = true;
};

template <class T> struct is_array {
	constexpr static bool value = false;
};

template <class T, size_t Dim> struct is_array<schema::Array<T,Dim>> {
	constexpr static bool value = true;
};

template <typename T, size_t N> struct is_primitive<schema::Primitive<T,N>> {
	constexpr static bool value = true;
};
} // namespace saw