#pragma once

#include <functional>

#include <forstio/error.hpp>

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

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

namespace impl {
template<typename Request, typename Response, typename Encode, typename Storage, typename Ctx>
struct FuncTypeHelper {
	using Type = std::function<data<Response, Encode, Storage>(data<Request, Encode, Storage>, Ctx)>;
};

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

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

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

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

template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t >
class interface;

template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename Storage, typename Context>
class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Storage, Context> {
public:
	using Schema = schema::Interface<schema::Member<schema::Function<Requests, Responses>,Names>...>;
private:
		std::tuple<function<schema::Function<Requests, Responses>, Encode, Storage, Context>...> funcs_;
public:
		interface(function<schema::Function<Requests, Responses>, Encode, Storage, 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
		,		Storage
		,		Context
		>& get(){
				return std::get<parameter_key_pack_index<Lit, Names...>::value>(funcs_);
		}

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

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

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