#pragma once

#include <filesystem>

#include <forstio/codec/schema_hash.hpp>
#include <forstio/remote/remote.hpp>

namespace saw {
namespace rmt {
struct File {};
}

template<>
class remote_address<rmt::File> {
private:
	std::filesystem::path path_;
public:
	remote_address(const std::filesystem::path& path__):
		path_{path__}
	{}

	std::string get_path_string() const {
		return path_.string();
	}

	const std::filesystem::path& get_path() const {
		return path_;
	}
};

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

	std::map<std::string, ptr<i_data_server<rmt::File>>> registered_data_servers_;
public:
	remote() = default;

	error_or<own<remote_address<rmt::File>>> parse_address(const std::string_view& path_v){
		return heap<remote_address<rmt::File>>(path_v);
	}

	template<typename Schema, typename Encode>
	error_or<own<data_server<Schema, Encode, rmt::File>>> data_listen(ref<remote_address<rmt::File>> addr){
		auto insert_res = registered_data_servers_.emplace(std::make_pair(addr().get_path_string(),ptr<i_data_server<rmt::File>>{}));
		if(!insert_res.second){
			return make_error<err::already_exists>();
		}

		auto dat_srv = heap<data_server<Schema, Encode, rmt::File>>(*this, addr);
		insert_res.first->second = ptr<i_data_server<rmt::File>>{*dat_srv};
		return dat_srv;
	}

	template<typename Schema, typename Encode>
	conveyor<own<data_client<Schema, Encode, rmt::File>>> data_connect(ref<remote_address<rmt::File>> addr){
		auto path_str = addr().get_path_string();
		auto find = registered_data_servers_.find(path_str);
		if(find == registered_data_servers_.end()){
			return {make_error<err::not_found>()};
		}

		return {heap<data_client<Schema,Encode,rmt::File>>({*this},{find->second})};
	}

	/**
	 * Internal deregister function
	 */
	error_or<void> deregister_data_server(const std::string& path){
		auto erase_op = registered_data_servers_.erase(path);
		if(erase_op == 0u){
			return make_error<err::not_found>();
		}
		return make_void();
	}
};

namespace rmt {
struct FileSystem {};
}

template<>
class remote_address<rmt::FileSystem> {
private:
	std::filesystem::path path_;
public:
	remote_address(const std::filesystem::path& path__):
		path_{path__}
	{}

	std::string get_path_string() const {
		return path_.string();
	}

	const std::filesystem::path& get_path() const {
		return path_;
	}
};

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

	struct key_t {
		std::string path;
		uint32_t sch_crc32;
		uint32_t enc_crc32;

		bool operator<(const key_t& rhs) const {
			if(path != rhs.path){
				return path < rhs.path;
			}

			if(sch_crc32 != rhs.sch_crc32 ){
				return sch_crc32 < rhs.sch_crc32;
			}
			
			if(enc_crc32 != rhs.enc_crc32 ){
				return enc_crc32 < rhs.enc_crc32;
			}

			return false;
		}
	};

	std::map<key_t, ptr<i_data_server<rmt::FileSystem>>> registered_data_servers_;
public:
	remote() = default;

	error_or<own<remote_address<rmt::FileSystem>>> parse_address(const std::string_view& path_v){
		return heap<remote_address<rmt::FileSystem>>(path_v);
	}

	template<typename Schema, typename Encode>
	error_or<own<data_server<Schema, Encode, rmt::FileSystem>>> data_listen(ref<remote_address<rmt::FileSystem>> addr){
		key_t k;
		k.path = addr().get_path_string();
		constexpr auto crc_pair = data_server<Schema,Encode,rmt::FileSystem>::class_id;
		k.sch_crc32 = crc_pair.first;
		k.enc_crc32 = crc_pair.second;

		auto insert_res = registered_data_servers_.emplace(std::make_pair(std::move(k),ptr<i_data_server<rmt::FileSystem>>{}));
		if(!insert_res.second){
			return make_error<err::already_exists>();
		}

		auto dat_srv = heap<data_server<Schema, Encode, rmt::FileSystem>>(*this, addr);
		insert_res.first->second = ptr<i_data_server<rmt::FileSystem>>{*dat_srv};
		return dat_srv;
	}

	/**
	 * Internal deregister function
	 */
	error_or<void> deregister_data_server(const std::string& addr, uint32_t sch_crc32, uint32_t enc_crc32){
		key_t k;
		k.path = addr;
		k.sch_crc32 = sch_crc32;
		k.enc_crc32 = enc_crc32;

		auto erase_op = registered_data_servers_.erase(k);
		if(erase_op == 0u){
			return make_error<err::not_found>();
		}
		return make_void();
	}
};
}