#pragma once

namespace saw {

template<>
struct remote_address<rmt::Sycl> {
private:
	remote<rmt::Sycl>* ctx_;
	our<device<rmt::Sycl>> device_;

	SAW_FORBID_COPY(remote_address);
	SAW_FORBID_MOVE(remote_address);
public:
	remote_address(remote<rmt::Sycl>& r_ctx, our<device<rmt::Sycl>> d_ctx):
		ctx_{&r_ctx},
		device_{std::move(d_ctx)}
	{}

	our<device<rmt::Sycl>> copy_device_reference() const {
		return device_;
	}

	device<rmt::Sycl>& get_device(){
		return *device_;
	}
};

template<>
class remote<rmt::Sycl> {
private:
	SAW_FORBID_COPY(remote);
	SAW_FORBID_MOVE(remote);
public:
	/**
	 * Default constructor
	 */
	remote(){}

	/**
	 * For now we don't need to specify the location since
	 * we just create a default.
	 */
	conveyor<own<remote_address<rmt::Sycl>>> resolve_address(){
		auto dev = std::make_shared<device<rmt::Sycl>>();
		return heap<remote_address<rmt::Sycl>>(*this, std::move(dev));
	}

	/**
	 * Parse address, but don't resolve it.
	 */
	error_or<own<remote_address<rmt::Sycl>>> parse_address(){
		auto dev = std::make_shared<device<rmt::Sycl>>();
		return heap<remote_address<rmt::Sycl>>(*this, std::move(dev));
	}

	/**
	 * Spin up a rpc server
	 */
	template<typename Iface, typename Encoding, typename Storage>
	rpc_server<Iface, Encoding, Storage, rmt::Sycl> listen(remote_address<rmt::Sycl>& dev, typename rpc_server<Iface, Encoding, Storage, rmt::Sycl>::InterfaceT iface){
		//using RpcServerT = rpc_server<Iface, Encoding, rmt::Sycl>;
		//using InterfaceT = typename RpcServerT::InterfaceT;
		return {dev.copy_device_reference(), std::move(iface)};
	}
};

}