#pragma once

#include "common.hpp"
#include "data.hpp"
#include "device.hpp"

#include <forstio/error.hpp>
#include <forstio/reduce_templates.hpp>
#include <forstio/remote/transfer.hpp>
#include <forstio/codec/schema_hash.hpp>

namespace saw {

template<typename Schema, typename Encoding>
class data_server<Schema, Encoding, rmt::Hip> final : public i_data_server<rmt::Hip> {
private:
	our<device<rmt::Hip>> device_;

	std::map<uint64_t, data<Schema, encode::Hip<Encoding>>> values_;
public:
	static constexpr std::pair<uint32_t,uint32_t> class_id{schema_hash<Schema>::apply(), schema_hash<Encoding>::apply()};

	std::pair<uint32_t,uint32_t> get_class_id() const override {
		return class_id;
	}

	data_server(our<device<rmt::Hip>> device__):
		device_{std::move(device__)}
	{}

	error_or<void> send(const data<Schema,Encoding>& dat, id<Schema> store_id){

		auto ins = values_.emplace(std::make_pair(store_id.get_value(), data<Schema, encode::Hip<Encoding>>{dat}));
		if(!ins.second){
			return make_error<err::already_exists>();
		}

		return make_error<err::not_implemented>("Allocate not implemented. Since we don't actually do any device copies.");
		return make_void();
	}

	error_or<void> allocate(const data<typename meta_schema<Schema>::MetaSchema, Encoding>& dat, id<Schema> store_id){
		return make_error<err::not_implemented>("Allocate not implemented");
		return make_void();
	}
	
	error_or<data<Schema,Encoding>> receive(id<Schema> store_id){
		return make_error<err::not_implemented>("Receive not implemented");
	}
	
	error_or<void> erase(id<Schema> store_id){
		return make_error<err::not_implemented>("Erase not implemented");
		return make_void();
	}
	
	error_or<ptr<data<Schema, encode::Hip<Encoding>>>> find(id<Schema> store_id){
		auto find_res = values_.find(store_id.get_value());
		if(find_res == values_.end()){
			return make_error<err::not_found>();
		}

		return {(find_res.second)};
	}
};

template<typename... Schema, typename Encoding>
class data_server<tmpl_group<Schema...>, Encoding, rmt::Hip> {
private:
	/**
	 * Device context class
	 */
	our<device<rmt::Hip>> device_;

	/**
	 * Store for the data the server manages.
	 */
	typename impl::data_server_redux<encode::Hip<Encoding>, typename tmpl_reduce<tmpl_group<Schema...>>::type >::type values_;
public:
	/**
	 * Main constructor
	 */
	data_server(our<device<rmt::Hip>> device__):
		device_{std::move(device__)}
	{}

	/**
	 * Get data which we will store.
	 */
	template<typename Sch>
	error_or<void> send(const data<Sch, Encoding>& dat, id<Sch> store_id){
		return make_error<err::not_implemented>();
		/*
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,encode::Hip<Encoding>>>>(values_);
		auto eoval = device_->template copy_to_device<Sch, Encoding>(dat);
		if(eoval.is_error()){
			auto& err = eoval.get_error();
			return std::move(err);
		}
		auto& val = eoval.get_value();
		try {
			auto insert_res = vals.insert(std::make_pair(store_id.get_value(), std::move(val)));
			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(const data<typename meta_schema<Sch>::MetaSchema, Encoding>& dat, id<Sch> store_id){
		return make_error<err::not_implemented>();
		/*
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,encode::Hip<Encoding>>>>(values_);
		auto eoval = device_->template allocate_on_device<Sch, Encoding>(dat);
		if(eoval.is_error()){
			auto& err = eoval.get_error();
			return std::move(err);
		}
		auto& val = eoval.get_value();
		try {
			auto insert_res = vals.insert(std::make_pair(store_id.get_value(), std::move(val)));
			if(!insert_res.second){
				return make_error<err::already_exists>();
			}
		}catch ( std::exception& ){
			return make_error<err::out_of_memory>();
		}
		return void_t{};
		*/
	}

	/**
	 * Requests data from the server
	 */
	template<typename Sch>
	error_or<data<Sch, Encoding>> receive(id<Sch> store_id){
		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,encode::Hip<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 make_error<err::not_implemented>();
	}

	/**
	 * Request an erase of the stored data
	 */
	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{};
	}

	/**
	 * Get the stored data on the server side for immediate use.
	 * Insert operations may invalidate the pointer.
	 */
	template<typename Sch>
	error_or<data<Sch, encode::Hip<Encoding>>*> 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>();
		}

		return &(find_res.second);
	}
};

/**
 * Client for transporting data to remote and receiving data back
 */
template<typename... Schema, typename Encoding>
class data_client<tmpl_group<Schema...>, Encoding, rmt::Hip> {
private:
	/**
	 * Corresponding server for this client
	 */
	data_server<tmpl_group<Schema...>, Encoding, rmt::Hip>* 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::Hip>& srv__):
		srv_{&srv__},
		next_id_{0u}
	{}

	/**
	 * Send data to the remote.
	 */
	template<typename Sch>
	error_or<id<Sch>> send(const data<Sch, Encoding>& 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;
	}

	/**
	 * Receive data
	 */
	template<typename Sch>
	conveyor<data<Sch, Encoding>> 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);
	}
};
}