#pragma once

#include "common.hpp"

namespace saw {

template<>
struct remote_address<rmt::Sycl> {
private:
	uint64_t dev_id_;

	SAW_FORBID_COPY(remote_address);
	SAW_FORBID_MOVE(remote_address);
public:
	remote_address(uint64_t id):
		dev_id_{id}
	{}

	uint64_t get_device_id() const {
		return dev_id_;
	}
};

template<>
class remote<rmt::Sycl> {
private:
	SAW_FORBID_COPY(remote);
	SAW_FORBID_MOVE(remote);

	struct key_t {
		std::array<uint64_t,3> data;

		template<typename Schema, typename Encoding>
		static key_t create(const remote_address<rmt::Loopback>& addr){
			key_t k;
			k.data = std::array<uint64_t,3>{addr.get_address_id().get(), schema_hash<Schema>::apply(), schema_hash<Encoding>::apply()};

			return k;
		}

		bool operator<(const key_t& rhs) const {
			for(uint64_t i = 0u; i < 3; ++i){
				if(data[i] != rhs.data[i]){
					return data[i] < rhs.data[i];
				}
			}
			return false;
		}
	};

	std::map<uint64_t, our<device<rmt::Sycl>>> devs_;
	std::map<key_t, ptr<i_data_server<rmt::Sycl>>> reg_dat_srvs_;
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(uint64_t dev_id = 0u){
		return heap<remote_address<rmt::Sycl>>(dev_id);
	}

	/**
	 * Parse address, but don't resolve it.
	 */
	error_or<own<remote_address<rmt::Sycl>>> parse_address(uint64_t dev_id = 0u){
		return heap<remote_address<rmt::Sycl>>(dev_id);
	}

	/**
	 * Spin up data server
	 */
	template<typename Schema, typename Encoding>
	error_or<own<data_server<Schema, Encoding, rmt::Sycl>>> data_listen(remote_address<rmt::Sycl>& dev){
		return heap<data_server<Schema, Encoding, rmt::Sycl>>(dev);
	}

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

}