#pragma once

#include <variant>

#include <forstio/codec/interface.hpp>

#include "remote_loopback_base.hpp"
#include "transfer_loopback.hpp"

namespace saw {

template<typename T, typename Encoding>
class remote_data<T, Encoding, rmt::Loopback> {
private:
	id<T> id_;
public:
	remote_data(const id<T>& id):
		id_{id}
	{}

	/**
	 * Wait until data arrives
	 */
	error_or<data<T, Encoding>> wait(wait_scope& wait);

	/**
	 * Asynchronously wait for a result
	 */
	conveyor<data<T, Encoding>> on_receive();
};

/**
 * Client RPC reference structure
 */
template<typename Iface, typename Encoding>
class rpc_client<Iface, Encoding, rmt::Loopback> {
	/**
	 * request the data from the remote
	 */
	template<typename IdT>
	remote_data<IdT, Encoding, rmt::Loopback> request_data(id<IdT> data);
		
	/** @todo
	 * Determine type based on Name
	 */
	/*
	template<string_literal Name>
	error_or<
		id<
			typename schema_member_type<Name, Iface>::type
		>
	> call(data_or_id<Input> inp);
	*/
};

template<typename Iface, typename Encode>
class rpc_server<Iface, Encode, rmt::Loopback> {
public:
	using InterfaceT = interface<Iface, Encode>;
	using TypeGroup = typename schema_iface_type_group<Iface>::Type;
	using DataServers = typename impl::tmpl_group_to_data_server_ptr_std_tuple<TypeGroup, Encode, rmt::Loopback>::type;
private:
	ptr<remote<rmt::Loopback>> remote_;
	ptr<remote_address<rmt::Loopback>> addr_;
	InterfaceT iface_;
	DataServers dat_srvs_;

public:
	rpc_server(ptr<remote<rmt::Loopback>> remote__, remote_address<rmt::Loopback>& addr__, InterfaceT iface__, DataServers dat_srvs__):
		remote_{remote__},
		addr_{addr__},
		iface_{std::move(iface__)},
		dat_srvs_{dat_srvs__}
	{}

	template<string_literal Lit>
	error_or<void> call(id<typename schema_member_type<Lit, Iface>::type::RequestT> id_param, id<typename schema_member_type<Lit,Iface>::type::ResponseT> id_resp){
		using Req = typename schema_member_type<Lit,Iface>::type::RequestT;
		auto req_dat_ptr = std::get<ptr<data_server<Req,Encode,rmt::Loopback>>>(dat_srvs_);
		auto eo_req_param = req_dat_ptr().find(id_param);
		if(eo_req_param.is_error()){
			return std::move(eo_req_param.get_error());
		}
		auto& req_param = eo_req_param.get_value();

		auto eo_answer = iface_.template call<Lit>(req_param());
		if(eo_answer.is_error()){
			return std::move(eo_answer.get_error());
		}
		auto& answer = eo_answer.get_value();

		using Resp = typename schema_member_type<Lit,Iface>::type::ResponseT;
		auto resp_dat_ptr = std::get<ptr<data_server<Resp,Encode,rmt::Loopback>>>(dat_srvs_);
		auto eo_send = resp_dat_ptr().send(std::move(answer), id_resp);
		if(eo_send.is_error()){
			return std::move(eo_send.get_error());
		}

		return make_void();
	}
};

}