#pragma once

#include "remote.hpp"

#include <forstio/buffer.hpp>
#include <forstio/remote/transfer.hpp>

#include <fstream>

namespace saw {
template<typename Schema, typename Encoding>
class data_server<Schema, Encoding, rmt::File> final : public i_data_server<rmt::File> {
private:
	ptr<remote<rmt::File>> remote_;
	remote_address<rmt::File> addr_;

	static error generate_invalid_id_error() {
		return make_error<err::invalid_state>("rmt::File data_server only supports Id 0.");
	}
public:
	static constexpr std::pair<uint32_t,uint32_t> class_id{schema_hash<Schema>::apply(), schema_hash<Encoding>::apply()};

	data_server(ptr<remote<rmt::File>> remote__, ref<remote_address<rmt::File>> addr__):
		remote_{remote__},
		addr_{addr__()}
	{}

	~data_server(){
		remote_().deregister_data_server(*this);
	}

	SAW_FORBID_MOVE(data_server);
	SAW_FORBID_COPY(data_server);

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

	error_or<void> send(data<Schema, Encoding>& dat, id<Schema> store_id){
		if(store_id.get_value() > 0u){
			return generate_invalid_id_error();
		}

		std::basic_fstream<uint8_t> s{addr_.get_path(), s.binary | s.out};
		if(!s.is_open()){
			return make_error<err::not_found>("Couldn't open file");
		}

		auto& buff = dat.get_buffer();
		buffer_view buff_v{buff};
		while(buff_v.read_segment_length() > 0u){
			s.write(&buff_v.read(), buff_v.read_segment_length());
			
			buff_v.read_advance(buff_v.read_segment_length());
		}
		return make_void();
	}

	error_or<void> allocate(data<typename meta_schema<Schema>::MetaSchema, Encoding> meta, id<Schema> store_id){
		if(store_id.get_value() > 0u){
			return generate_invalid_id_error();
		}
		return make_error<err::not_implemented>();
	}

	error_or<void> erase(id<Schema> store_id){
		if(store_id.get_value() > 0u){
			return generate_invalid_id_error();
		}
		return make_error<err::not_implemented>();
	}

	error_or<data<Schema,Encoding>> receive(id<Schema> store_id){
		if(store_id.get_value() > 0u){
			return generate_invalid_id_error();
		}

		data<Schema, Encoding> dat{heap<array_buffer>(1u)};
		std::basic_fstream<uint8_t> s{addr_.get_path(), s.binary | s.in};
		if(!s.is_open()){
			return make_error<err::not_found>("Couldn't open file");
		}
		uint8_t ele{};
		while(s.readsome(&ele, 1u) > 0u){
			auto err = dat.get_buffer().push(ele);
			if(err.failed()){
				return err;
			}
		}

		return dat;
	}
};
}