#pragma once

#include <functional>

#include <forstio/error.hpp>

#include "schema.hpp"
#include "data.hpp"

namespace saw {
template<typename SchemaFunc, typename Encode, typename Context = void_t >
class function;

namespace impl {
template<typename DataSchema, typename Encode>
struct FuncReturnTypeHelper {
	using Type = data<DataSchema,Encode>;
};

template<typename Encode>
struct FuncReturnTypeHelper<schema::Void, Encode> {
	using Type = void;
};

template<typename Request, typename Response, typename Encode, typename Ctx>
struct FuncTypeHelper {
	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response,Encode>::Type>(data<Request, Encode>&, Ctx)>;
};

template<typename Request, typename Response, typename Encode>
struct FuncTypeHelper<Request, Response, Encode, void_t> {
	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response, Encode>::Type>(data<Request, Encode>&)>;
};

}

template<typename Request, typename Response, typename Encode, typename Context>
class function<schema::Function<Request, Response>, Encode, Context> {
private:
	typename impl::FuncTypeHelper<Request, Response, Encode, Context>::Type func_;
	using ResponseDataType = typename impl::FuncReturnTypeHelper<Response, Encode>::Type;
public:
	template<typename Func>
		function(Func func):
				func_{std::move(func)}
		{}

		error_or<ResponseDataType> call(data<Request, Encode>& req, Context ctx = {}){
			if constexpr (std::is_same_v<Context, void_t>){
				(void) ctx;
				return func_(req);
			} else {
				return func_(req, ctx);
			}
		}
};

template<typename T, typename Encode, typename Context = void_t >
class interface;

template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename Context>
class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Context> {
public:
	using Schema = schema::Interface<schema::Member<schema::Function<Requests, Responses>,Names>...>;
private:
		std::tuple<function<schema::Function<Requests, Responses>, Encode, Context>...> funcs_;
public:
		interface(function<schema::Function<Requests, Responses>, Encode, Context>... funcs):
				funcs_{std::move(funcs)...}
		{}

		/**
		 * Get the function based on the string literal matching the position in the tuple
		 */
		template<string_literal Lit>
		function<
				schema::Function<
						typename parameter_pack_type<
								parameter_key_pack_index<
										Lit, Names...
								>::value
						, Requests...>::type
				,
						typename parameter_pack_type<
								parameter_key_pack_index<
										Lit, Names...
								>::value
						, Responses...>::type
				>
		,		Encode
		,		Context
		>& get(){
				return std::get<parameter_key_pack_index<Lit, Names...>::value>(funcs_);
		}

		template<string_literal Lit>
		error_or<
			typename impl::FuncReturnTypeHelper<
				typename parameter_pack_type<
						parameter_key_pack_index<
								Lit, Names...
						>::value
				, Responses...>::type
		, Encode>::Type > call(
						data<
								typename parameter_pack_type<
										parameter_key_pack_index<
												Lit, Names...
										>::value
								, Requests...>::type
						, Encode>& req,
						Context ctx = {}
				){
				if constexpr (std::is_same_v<Context, void_t>) {
					(void) ctx;
					return get<Lit>().call(req);
				}else{
					return get<Lit>().call(req, ctx);
				}
		}
};

template<typename T, typename Encode, typename Context = void_t>
struct function_factory {
		template<typename Func>
		static function<T,Encode, Context> create(Func func){
				return function<T,Encode, Context> {std::move(func)};
		}
};

template<typename T, typename Encode, typename Context = void_t>
struct interface_factory {
		template<typename... Func>
		static interface<T,Encode,Context> create(Func... func){
				return interface<T,Encode,Context>{std::move(func)...};
		}
};
}