#pragma once

#include <thread>

namespace saw {
/**
 * ### Device ###
 * Device acts a launcher?
 * 
 * Acts a logical device.
 * Though logical devices are not findable by an address as of now.
 *
 * Generally a device represents some info about the remote object?
 * But what exactly? Does it store capabilities?
 *
 * In that case I'd prefer it has compile time information about
 * those.
 * 
 * ### RpcServer ###
 * Should always be created on the side which it is run on.
 * For SYCL it's kernel launches, so it's created on the local
 * thread.
 * For Threads it's supposed to be created on the remote thread.
 * How do I solve this cleanly?
 * Technically the server shouldn't know about the device.
 * It should register with an authority, so it gets requests
 * though.
 */
namespace rmt {
struct Thread {};
}

/**
 * A device representing a remote thread. Technically it's
 * a logical distinction and not a physical.
 */
template<>
class device<rmt::Thread> final {
private:
	event_loop ev_loop_;
	bool keep_running_;
	std::function<void()> run_func_;

	std::thread thread_;

	void run(){
		wait_scope wait{ev_loop_};

		while(keep_running_){
			run_func_();
			wait.wait(std::chrono::seconds{16u});
		}

		wait.poll();
	}
public:
	template<typename Func>
	device(Func func):
		ev_loop_{},
		keep_running_{true},
		run_func_{std::move(func)}
		thread_{&device<rmt::Thread>::run, this},
	{}

	void stop(){
		keep_running_ = false;
	}
};

template<>
class remote<rmt::Thread> final {
	private:
public:
		remote() = default;

		conveyor<own<remote_address<rmt::Thread>>> resolve_address(){
			return heap<remote_address<rmt::Thread>>(*this);
		}

		device<rmt::Thread> connect_device(const remote_address<rmt::Thread>& ){
			return {};
		}
};
}