#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 Request, typename Response, typename Encode, typename Ctx>
struct FuncTypeHelper {
	using Type = std::function<data<Response, Encode>(data<Request, Encode>, Ctx)>;
};

template<typename Request, typename Response, typename Encode>
struct FuncTypeHelper<Request, Response, Encode, void_t> {
	using Type = std::function<data<Response, Encode>(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_;
public:
	template<typename Func>
		function(Func func):
				func_{std::move(func)}
		{}

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

template<typename Iface, typename Encode>
class i_interface {
public:
	virtual ~i_interface() = default;


};

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

template<typename... Requests, typename... Responses, string_literal... Names, typename Encode>
class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode> {
public:
	using Schema = schema::Interface<schema::Member<schema::Function<Requests, Responses>,Names>...>;
private:
		std::tuple<function<schema::Function<Requests, Responses>, Encode>...> funcs_;
public:
		interface(function<schema::Function<Requests, Responses>, Encode>... 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
		>& 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> create(Func func){
				return function<T,Encode>{std::move(func)};
		}
};

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