#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<
		id<
			typename schema_member_type<Lit, Iface>::type::Response
		>
	> call(id<typename schema_member_type<Lit, Iface>::type::Request> id_param){

		return make_error<err::not_implemented>();
	}
};

}