#pragma once

#include <forstio/error.hpp>
#include "schema.hpp"
#include "data.hpp"

namespace saw {
template<typename SchemaFunc, typename Encode, typename Func>
class function;

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

		error_or<data<Response, Encode>> call(data<Request, Encode> req){
				return func_(std::move(req));
		}
};

template<typename T, typename Encode, typename... Funcs>
class interface;

template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename... Funcs>
class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Funcs...> {
private:
		std::tuple<function<schema::Function<Requests, Responses>, Encode, Funcs>...> funcs_;
public:
		interface(function<schema::Function<Requests, Responses>, Encode, Funcs>... 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
		,
				typename parameter_pack_type<
						parameter_key_pack_index<
								Lit, Names...
						>::value
				, Funcs...>::type
		>& 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>> call(
						data<
								typename parameter_pack_type<
										parameter_key_pack_index<
												Lit, Names...
										>::value
								, Requests...>::type
						, Encode> req
				){
				return get<Lit>().call(std::move(req));
		}

};

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

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