#pragma once

#include <forstio/reduce_templates.hpp>

#include "transfer.hpp"

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

template<>
class remote<rmt::Loopback>;

template<typename... Schema, typename Encoding>
class data_server<tmpl_group<Schema...>, Encoding, rmt::Loopback> final : public i_data_server<rmt::Loopback> {
private:
	typename impl::data_server_redux<Encoding, storage::Default, typename tmpl_reduce<tmpl_group<Schema...>>::type>::type values_;

	ptr<remote<rmt::Loopback>> remote_;
public:
	data_server(remote_address<rmt::Loopback>& addr){
		remote_().register_server(addr);
	}

	~data_server(){
		remote_().deregister_server(addr);
	}

	SAW_FORBID_COPY(data_server);
	SAW_FORBID_MOVE(data_server);

	/**
	 * Return the schema id
	 */
	std::pair<uint32_t,uint32_t> get_class_id() const override {
		uint32_t schema_hash = schema_hash<tmpl_group<Schema...>>::apply();
		uint32_t encode_hash = schema_hash<Encoding>::apply();

		return std::make_pair(schema_hash, encode_hash);
	}

	/**
	 * Get data from client
	 */
	template<typename Sch>
	error_or<void> send(const data<Sch, Encoding, storage::Default>& dat, id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);

		try {
			auto insert_res = vals.emplace(std::make_pair(store_id.get_value(), std::move(dat)));
			if(!insert_res.second){
				return make_error<err::already_exists>();
			}
		}catch(std::exception& ){
			return make_error<err::out_of_memory>();
		}
		return void_t{};
	}

	/**
	 *
	 */
	template<typename Sch>
	error_or<void> allocate(data<typename meta_schema<Sch>::MetaSchema, Encoding> meta, id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
		try {
			auto insert_res = vals.emplace(std::make_pair(store_id.get_value(), data<typename meta_schema<Sch>::MetaSchema, Encoding>{std::move(meta)}));
			if(!insert_res.second){
				return make_error<err::already_exists>();
			}
		}catch(std::exception& ){
			return make_error<err::out_of_memory>();
		}
		return make_void();
	}

	template<typename Sch>
	error_or<data<Sch, Encoding, storage::Default>> receive(id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);

		auto find_res = vals.find(store_id.get_value());
		if(find_res == vals.end()){
			return make_error<err::not_found>();
		}

		auto& dat = find_res->second;
		return dat;
	}

	template<typename Sch>
	error_or<void> erase(id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
		auto erase_op = vals.erase(store_id.get_value());
		if(erase_op == 0u){
			return make_error<err::not_found>();
		}
		return void_t{};
	}

	template<typename Sch>
	error_or<data<Sch, Encoding, storage::Default>*> find(id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
		auto find_res = vals.find(store_id.get_value());
		if(find_res == vals.end()){
			return make_error<err::not_found>();
		}

		auto& dat = find_res->second;
		return &dat;
	}
};

/**
 * Client for transporting data to remote and receiving data back
 */
template<typename... Schema, typename Encoding>
class data_client<tmpl_group<Schema...>, Encoding, rmt::Loopback> {
private:
	/**
	 * Corresponding server for this client
	 */
	data_server<tmpl_group<Schema...>, Encoding, rmt::Loopback>* srv_;

	/**
	 * The next id for identifying issues on the remote side.
	 */
	uint64_t next_id_;
public:
	/**
	 * Main constructor
	 */
	data_client(data_server<tmpl_group<Schema...>, Encoding, rmt::Loopback>& srv__):
		srv_{&srv__},
		next_id_{0u}
	{}

	/**
	 * Send data to the remote.
	 */
	template<typename Sch>
	error_or<id<Sch>> send(const data<Sch, Encoding, storage::Default>& dat){
		id<Sch> dat_id{next_id_};
		auto eov = srv_->send(dat, dat_id);
		if(eov.is_error()){
			auto& err = eov.get_error();
			return std::move(err);
		}

		++next_id_;
		return dat_id;
	}
	
	/**
	 * Preallocate data
	 */
	template<typename Sch>
	error_or<id<Sch>> allocate(const data<typename meta_schema<Sch>::MetaSchema, Encoding>& meta){
		id<Sch> dat_id{next_id_};
		auto eov = srv_->allocate(meta, dat_id);
		if(eov.is_error()){
			auto& err = eov.get_error();
			return std::move(err);
		}
		++next_id_;
		return dat_id;
	}

	/**
	 * Receive data
	 */
	template<typename Sch>
	conveyor<data<Sch, Encoding, storage::Default>> receive(id<Sch> dat_id){
		auto eov = srv_->receive(dat_id);
		if(eov.is_error()){
			auto& err = eov.get_error();
			return std::move(err);
		}

		auto& val = eov.get_value();
		return std::move(val);
	}

	/**
	 * Erase data
	 */
	template<typename Sch>
	error_or<void> erase(id<Sch> dat_id){
		return srv_->erase(dat_id);
	}

	/**
	 * An exception for the Loopback backend. Here we can safely use find from
	 * the client side.
	 */
	template<typename Sch>
	error_or<data<Sch, Encoding>*> find(id<Sch> dat_id){
		auto eov = srv_->find(dat_id);
		if(eov.is_error()){
			auto& err = eov.get_error();
			return std::move(err);
		}

		auto val = eov.get_value();
		return val;
	}

};

}