#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(data<Schema,Encoding>& dat, id<Schema> store_id){
		data<Schema, encode::Hip<Encoding>> hip_dat;
		{
			auto eov = device_->copy_to_device(dat, hip_dat);
			if(eov.is_error()){
				return eov;
			}
		}

		auto ins = values_.emplace(std::make_pair(store_id.get_value(), hip_dat));
		if(!ins.second){
			return make_error<err::already_exists>();
		}

		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)};
	}
};

}