#pragma once

#include "remote.hpp"

#include <map>

#include <forstio/codec/schema_hash.hpp>

namespace saw {
namespace rmt {
struct Loopback {};
}

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<>
class remote<rmt::Loopback> {
private:
	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<key_t, ptr<i_data_server<rmt::Loopback>>> registered_data_servers_;
	std::map<key_t, ptr<i_rpc_server<rmt::Loopback>>> registered_rpc_servers_;

	template<typename Iface, typename Encoding, uint64_t I>
	error_or<void> find_data_servers_ele(typename rpc_server<Iface,Encoding,rmt::Loopback>::DataServers& ret_val){
		if
	}

	template<typename Iface, typename Encoding>
	error_or<typename rpc_server<Iface, Encoding, rmt::Loopback>::DataServers> find_data_servers(){
		typename rpc_server<Iface,Encoding,rmt::Loopback>::DataServers ret_val;

		{
			auto eov = find_data_servers_ele<Iface,Encoding,0u>(ret_val);
			if(eov.is_error()){
				return std::move(eov.get_error());
			}
		}

		return ret_val;
	}
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>
	conveyor<rpc_client<Iface, Encode, rmt::Loopback>> rpc_connect(const remote_address<rmt::Loopback>& addr);

	/**
	 * Start listening
	 */
	template<typename Iface, typename Encode>
	error_or<own<rpc_server<Iface, Encode, rmt::Loopback>>> rpc_listen(remote_address<rmt::Loopback>& addr, typename rpc_server<Iface,Encode,rmt::Loopback>::InterfaceT iface){

		auto eo_dat_srvs = find_data_servers<Iface,Encode>();
		if(eo_dat_srvs.is_error()){
			return std::move(eo_dat_srvs.get_error());
		}
		auto& dat_srvs = eo_dat_srvs.get_value();

		return heap<rpc_server<Iface,Encode,rmt::Loopback>>(*this, addr, std::move(iface), dat_srvs);
	}

	/**
	 * Start data server
	 */
	template<typename Schema, typename Encode>
	error_or<own<data_server<Schema, Encode, rmt::Loopback>>> data_listen(const remote_address<rmt::Loopback>& addr){

		auto key_v = key_t::template create<Schema,Encode>(addr);

		auto find = registered_data_servers_.find(key_v);
		if(find != registered_data_servers_.end()){
			return make_error<err::already_exists>("Server already bound to this address");
		}

		auto dat_srv = heap<data_server<Schema, Encode, rmt::Loopback>>(*this, addr);
		return dat_srv;
	}

	/**
	 * Connect to a data server
	 */
	template<typename Schema, typename Encode>
	conveyor<data_client<Schema, Encode, rmt::Loopback>> data_connect(const remote_address<rmt::Loopback>& addr){
		constexpr auto class_id = data_server<Schema, Encode, rmt::Loopback>::class_id;
		key_t key;
		key.data = std::array<uint64_t,3>{addr.get_address_id().get(), class_id.first, class_id.second};

		auto find = registered_data_servers_.find(key);
		if(find == registered_data_servers_.end()){
			return make_error<err::not_found>("Server not found");
		}
		auto eo_dat_srv = find->second().template cast_to<data_server<Schema, Encode, rmt::Loopback>>();
		if(eo_dat_srv.is_error()){
			auto& err = eo_dat_srv.get_error();
			return std::move(err);
		}
		auto dat_srv = eo_dat_srv.get_value();

		return data_client<Schema, Encode, rmt::Loopback>{dat_srv};
	}

	/**
	 * Internal function
	 */
	error_or<void> register_data_server(const remote_address<rmt::Loopback>& addr, i_data_server<rmt::Loopback>& srv){

		auto class_id = srv.get_class_id();
		key_t key;
		key.data = std::array<uint64_t,3>{addr.get_address_id().get(), class_id.first, class_id.second};
		
		auto insert = registered_data_servers_.emplace(std::make_pair(key, ptr<i_data_server<rmt::Loopback>>{srv}));
		if(insert.second){
			return make_error<err::already_exists>("Server already bound to this address");
		}

		return make_void();
	}

	error_or<void> deregister_data_server(const remote_address<rmt::Loopback>& addr, i_data_server<rmt::Loopback>& srv){
		auto class_id = srv.get_class_id();
		key_t key;
		key.data = std::array<uint64_t,3>{addr.get_address_id().get(), class_id.first, class_id.second};
		auto erase = registered_data_servers_.erase(key);
		if(erase == 0u){
			return make_error<err::not_found>("Server not found");
		}

		return make_void();
	}
};
}