#pragma once

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

#include <forstio/buffer.hpp>
#include <forstio/error.hpp>

namespace saw {
namespace encode {
struct KelSimple {
	static constexpr string_literal name = "encode::KelSimple";
};
}

template<typename T>
class data<T, encode::KelSimple> {
private:
	own<buffer> buffer_;
public:
	data():
		buffer_{heap<ring_buffer>()}
	{}

	data(own<buffer> buffer__):
		buffer_{std::move(buffer__)}
	{}

	buffer& get_buffer(){
		return *buffer_;
	}
};

namespace impl {
template<typename Schema, typename FromEnc>
class kelsimple_encode {
	static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding.");
};

template<typename T, size_t N, typename FromEnc>
struct kelsimple_encode<schema::Primitive<T,N>, FromEnc> {
	static error_or<void> encode(const data<schema::Primitive<T,N>, FromEnc>& from, buffer& to){
		auto eov = stream_value<schema::Primitive<T,N>>::encode(from.get(), to);
		return eov;
	}
};

template<typename T, size_t Dim, typename FromEnc>
struct kelsimple_encode<schema::Array<T,Dim>, FromEnc> {
	template<std::size_t Level>
	static error_or<void> encode_level(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to, std::array<std::size_t, Dim>& index){
		if constexpr (Dim == Level){
			return kelsimple_encode<T,FromEnc>::encode(from.at(index), to);
		} else {
			const std::size_t dim_size = from.get_dim_size(Level);
			for(index[Level] = 0; (index.at(Level) < dim_size); ++index[Level]){
				auto eov = encode_level<Level+1>(from, to, index);
				if(eov.is_error()){
					return eov;
				}
			}
		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to){
		{
			for(uint64_t i = 0; i < Dim; ++i){
				auto eov = stream_value<schema::UInt64>::encode(from.get_dim_size(i), to);
				if(eov.is_error()){
					return eov;
				}
			}
		}
		{
			std::array<std::size_t, Dim> index;
			std::fill(index.begin(), index.end(), 0);

			return encode_level<0>(from, to, index);
		}
		return void_t{};
	}
};

template<typename... T, string_literal... Lits, typename FromEnc>
struct kelsimple_encode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> {
	template<std::size_t i>
	static error_or<void> encode_member(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
		using Type = typename parameter_pack_type<i,T...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
		{
			auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<Literal>(), to);
			if(eov.is_error()){
				return eov;
			}
		}
		if constexpr ((i+1) < sizeof...(T)){
			auto eov = encode_member<i+1>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
		return encode_member<0>(from, to);
	}
};

template<typename... T, string_literal... Lits, typename FromEnc>
struct kelsimple_encode<schema::Union<schema::Member<T,Lits>...>,FromEnc> {
	template<std::size_t i>
	static error_or<void> encode_member(const data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
		using Type = typename parameter_pack_type<i,T...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
		if (from.template holds_alternative<Literal>()) {
			{
				auto eov = stream_value<schema::UInt64>::encode(static_cast<uint64_t>(i), to);
				if(eov.is_error()){
					return eov;
				}
			}
			{
				auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<Literal>(), to);
				if(eov.is_error()){
					return eov;
				}
			}
		}

		if constexpr ( (i+1) < sizeof...(T) ){
			auto eov = encode_member<i+1>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
		return encode_member<0>(from, to);
	}
};

template<typename... T, typename FromEnc>
struct kelsimple_encode<schema::Tuple<T...>, FromEnc> {
	template<std::size_t i>
	static error_or<void> encode_member(const data<schema::Tuple<T...>, FromEnc>& from, buffer& to){
		using Type = typename parameter_pack_type<i,T...>::type;
		{
			auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<i>(), to);
		}
		if constexpr ((i+1) < sizeof...(T)){
			auto eov = encode_member<i+1>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Tuple<T...>, FromEnc>& from, buffer& to){
		return encode_member<0>(from, to);
	}
};

template<typename FromEnc>
struct kelsimple_encode<schema::String, FromEnc> {
	static error_or<void> encode(const data<schema::String, FromEnc>& from, buffer& to){
		const auto str_size = from.size();
		typename native_data_type<schema::UInt64>::type str_len = static_cast<uint64_t>(str_size);
		{
			auto eov = stream_value<schema::UInt64>::encode(str_len, to);
			if(eov.is_error()){
				return eov;
			}
		}

		for(std::size_t i = 0; i < str_size; ++i){
			auto eov = stream_value<schema::Int8>::encode(from.at(i), to);
			if(eov.is_error()){
				return eov;
			}
		}

		return void_t{};
	}
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename Schema, typename FromEnc>
class kelsimple_decode {
	static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding.");
};

template<typename T, size_t N, typename FromEnc>
struct kelsimple_decode<schema::Primitive<T,N>, FromEnc> {
	static error_or<void> decode(buffer& from, data<schema::Primitive<T,N>, FromEnc>& to){
		typename native_data_type<schema::Primitive<T,N>>::type val{};
		auto eov = stream_value<schema::Primitive<T,N>>::decode(val, from);
		if (eov.is_value()) {
			to.set(val);
		}
		return eov;
	}

};

template<typename T, size_t Dim, typename FromEnc>
struct kelsimple_decode<schema::Array<T,Dim>, FromEnc> {
	template<std::size_t Level>
	static error_or<void> decode_level(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to, std::array<std::size_t, Dim>& index){
		if constexpr (Level == Dim){
			return kelsimple_decode<T, FromEnc>::decode(from, to.at(index));
		}else{
			const std::size_t dim_size = to.get_dim_size(Level);
			for(index[Level] = 0; index[Level] < dim_size; ++index[Level]){
				auto eov = decode_level<Level+1>(from, to, index);
				if(eov.is_error()){
					return eov;
				}
			}
		}
		return void_t{};
	}

	static error_or<void> decode(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to){
		{
			std::array<std::size_t, Dim> dims{};
			for(std::size_t i = 0; i < Dim; ++i){
				uint64_t val{};
				auto eov = stream_value<schema::UInt64>::decode(val, from);
				if(eov.is_error()){
					return eov;
				}
				dims.at(i) = static_cast<std::size_t>(val);
			}
			to = data<schema::Array<T,Dim>,FromEnc>{dims};
		}
		{
			std::array<std::size_t, Dim> index{};
			return decode_level<0>(from, to, index);
		}
		return void_t{};
	}
};
template<typename... T, string_literal... Lits, typename FromEnc>
struct kelsimple_decode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> {
	template<std::size_t i>
	static error_or<void> decode_member(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){
		using Type = typename parameter_pack_type<i,T...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
		{
			auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<Literal>());
			if(eov.is_error()){
				return eov;
			}
		}
		if constexpr ((i+1) < sizeof...(T)){
			auto eov = decode_member<i+1>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};

	}
	static error_or<void> decode(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){
		return decode_member<0>(from, to);
	}
	
};

template<typename... T, string_literal... Lits, typename FromEnc>
struct kelsimple_decode<schema::Union<schema::Member<T,Lits>...>,FromEnc> {
	template<uint64_t i>
	static error_or<void> decode_member(buffer& from, data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& to, uint64_t val){
		using Type = typename parameter_pack_type<i,T...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;

		if( i == val ){
			to.template set<Literal>(data<Type, FromEnc>{});
			auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<Literal>());
			if(eov.is_error()){
				return eov;
			}
			return void_t{};
		}

		if constexpr ((i+1) < sizeof...(T)){
			auto eov = decode_member<i+1>(from, to, val);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};

	}
	static error_or<void> decode(buffer& from, data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& to){
		uint64_t val{};
		auto eov = stream_value<schema::UInt64>::decode(val, from);
		if(eov.is_error()){
			return eov;
		}
		if ( val >= sizeof...(T) ){
			return make_error<err::invalid_state>();
		}
		return decode_member<0>(from, to, val);
	}
	
};

template<typename... T, typename FromEnc>
struct kelsimple_decode<schema::Tuple<T...>,FromEnc> {
	template<std::size_t i>
	static error_or<void> decode_member(buffer& from, data<schema::Tuple<T...>, FromEnc>& to){
		using Type = typename parameter_pack_type<i,T...>::type;
		{
			auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<i>());
		}
		if constexpr ((i+1) < sizeof...(T)){
			auto eov = decode_member<i+1>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};

	}
	static error_or<void> decode(buffer& from, data<schema::Tuple<T...>, FromEnc>& to){
		return decode_member<0>(from, to);
	}
	
};
template<typename FromEnc>
struct kelsimple_decode<schema::String, FromEnc> {
	static error_or<void> decode(buffer& from, data<schema::String, FromEnc>& to){
		{
			uint64_t val{};
			auto eov = stream_value<schema::UInt64>::decode(val, from);
			if(eov.is_error()){
				return eov;
			}
			to = data<schema::String,FromEnc>{val};
		}
		const std::size_t str_size = to.size();
		for(std::size_t i = 0; i < str_size; ++i){
			int8_t val{};
			auto eov = stream_value<schema::Int8>::decode(val, from);
			if(eov.is_error()){
				return eov;
			}
			to.set_at(i, val);
		}
		return void_t{};
	}
};

}

template<typename Schema>
class codec<Schema, encode::KelSimple> {
public:
	struct config {
		size_t depth = 16;
		size_t length = 1024;
	};
private:
	config cfg_;
public:
	codec() = default;

	SAW_FORBID_COPY(codec);
	SAW_DEFAULT_MOVE(codec);

	template<typename FromEnc>
	error_or<void> encode(const data<Schema, FromEnc>& from_enc, data<Schema, encode::KelSimple>& to_enc){
		buffer_view buff_v{to_enc.get_buffer()};

		auto eov = impl::kelsimple_encode<Schema, FromEnc>::encode(from_enc, buff_v);

		to_enc.get_buffer().write_advance(buff_v.write_offset());

		return eov;
	}

	template<typename ToDec>
	error_or<void> decode(data<Schema, encode::KelSimple>& from_dec, data<Schema, ToDec>& to){
		buffer_view buff_v{from_dec.get_buffer()};

		auto eov = impl::kelsimple_decode<Schema,ToDec>::decode(buff_v, to);

		return eov;
	}
};
}