#pragma once

#include <forstio/buffer.hpp>

#include "data.hpp"
#include "stream_value.hpp"


namespace saw {
namespace encode {
struct KelForst {};
}
}

#include "forst.tmpl.hpp"

namespace saw {
template <>
class data<schema::String, encode::KelForst> {
private:
	own<buffer> buff_;
public:
	data(own<buffer> buff):
		buff_{std::move(buff)}
	{}
};

template<typename T, uint64_t N>
class data<schema::Primitive<T,N>, encode::KelForst> {
public:
	using Schema = schema::Primitive<T,N>;
private:
	our<buffer> buff_;
	uint64_t displacement_;
public:
	data():
		buff_{share<array_buffer>(N)},
		displacement_{0u}
	{
		buff_->write_advance(N);
	}

	/**
	 * Constructor for root elements
	 */
	data(our<buffer> buff):
		buff_{std::move(buff)},
		displacement_{0u}
	{
		buff_->write_advance(N);
	}
	
	/**
	 * Constructor for child elements
	 */
	data(our<buffer> buff, uint64_t dsp):
		buff_{std::move(buff)},
		displacement_{dsp}
	{
		buff_->write_advance(N);
	}

	/**
	 * Get values
	 */
	typename native_data_type<Schema>::type get(){
		typename native_data_type<Schema>::type val;

		typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw = 0;

		for (size_t i = 0; i < N; ++i) {
			raw |= (static_cast<typename native_data_type<Schema>::type>(buff_->read(i+displacement_)) << (i * 8));
		}

		memcpy(&val, &raw, N);
		return val;
	}

	/**
	 * Set values
	 */
	void set(typename native_data_type<Schema>::type val){
		typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw{};
		memcpy(&raw, &val, N);

		for (size_t i = 0; i < N; ++i) {
			buff_->read(i+displacement_) = raw >> (i * 8);
		}	
	}
};

template<typename... T, string_literal... Keys>
class data<schema::Struct<schema::Member<T,Keys>...>, encode::KelForst> {
public:
	using Schema = schema::Struct<schema::Member<T,Keys>...>;
private:
	/**
	 * Buffer holding the whole packet
	 */
	our<buffer> buff_;
	/**
	 * Displacement to show the starting point
	 */
	uint64_t displacement_;
public:
	data():
		buff_{share<array_buffer>(impl::forst_codec_info<Schema>::static_size)},
		displacement_{0u}
	{
	}
	/**
	 * Constructor for root elements
	 */
	data(our<buffer> buff):
		buff_{std::move(buff)},
		displacement_{0u}
	{}

	/**
	 * Constructor for child elements
	 */
	data(our<buffer> buff, uint64_t dsp):
		buff_{std::move(buff)},
		displacement_{dsp}
	{}
};
}