#pragma once

#include <variant>

#include <forstio/codec/interface.hpp>

#include "remote.hpp"
#include "transfer_loopback.hpp"

namespace saw {

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

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

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

/**
 * Client RPC reference structure
 */
template<typename Iface, typename Encoding, typename Storage>
class rpc_client<Iface, Encoding, Storage, rmt::Loopback> {
	/**
	 * request the data from the remote
	 */
	template<typename IdT>
	remote_data<IdT, Encoding, Storage, 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<>
class remote_address<rmt::Loopback> {
private:
	data<schema::UInt64> addr_id_;
public:
	remote_address(data<schema::UInt64> addr_id__):
		addr_id_{addr_id__}
	{}

	const data<schema::UInt64>& get_address_id() const {
		return addr_id_;
	}
};

template<typename Iface, typename Encode, typename Storage>
class rpc_server<Iface, Encode, Storage, rmt::Loopback> {
public:
	using InterfaceT = interface<Iface, Encode, Storage>;
private:
	const remote_address<rmt::Loopback>* addr_;
	InterfaceT iface_;
public:
	rpc_server(const remote_address<rmt::Loopback>& addr__, InterfaceT iface__):
		addr_{&addr__},
		iface_{std::move(iface__)}
	{}

	// error_or<id<>>
};

template<>
class remote<rmt::Loopback> {
private:
public:
	/**
	 * Resolves an address for the remote
	 */
	error_or<own<remote_address<rmt::Loopback>>> parse_address(data<schema::UInt64> id){
		return heap<remote_address<rmt::Loopback>>(id);
	}

	/**
	 * Connect to a remote
	 */
	template<typename Iface, typename Encode, typename Storage>
	conveyor<rpc_client<Iface, Encode, Storage, rmt::Loopback>> connect(const remote_address<rmt::Loopback>& addr);

	/**
	 * Start listening
	 */
	template<typename Iface, typename Encode, typename Storage>
	rpc_server<Iface, Encode, Storage, rmt::Loopback> listen(const remote_address<rmt::Loopback>& addr, typename rpc_server<Iface,Encode,Storage,rmt::Loopback>::InterfaceT iface){
		return {addr, std::move(iface)};
	}
};
}