#pragma once

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

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

namespace saw {
namespace encode {
struct Csv {};
}

namespace impl {
struct csv_helper {
	static bool is_whitespace(int8_t ch){
		/**
		 * @TODO supply relevant control characters for checks.
		 * Newlines are whitespace technically, but also control characters in CSV.
		 * Contrary to JSON for example.
		 */
		return ch == '\t' || ch == ' ';
	}

	static void skip_whitespace(buffer_view& buff){
		while(buff.read_composite_length() > 0 && csv_helper::is_whitespace(buff.read())){
			buff.read_advance(1u);
		}
	}
};

template<typename Schema, typename FromDecode>
struct csv_encode {
	static_assert(always_false<Schema, FromDecode>, "Case not supported");
};

template<typename  T, size_t Dim, typename FromDecode>
struct csv_encode<schema::Array<T,Dim>, FromDecode> {
	static_assert(Dim == 1, "Only one dimension is allowed.");
	static_assert(!is_array<T>::value, "Array of an array is not allowed.");
	static_assert(is_tuple<T>::value || is_struct<T>::value, "Only struct or tuples allowed inside a csv array");

	using Schema = schema::Array<T,Dim>;

	static error_or<void> encode(const data<Schema, FromDecode>& from, buffer& to){
		if constexpr (is_struct<T>::value){
			auto eov = csv_encode<T,FromDecode>::encode_header(to);
			if(eov.is_error()){
				return eov;
			}
		}

		for(data<schema::UInt64> i = 0; i < from.size(); ++i){
			auto eov = csv_encode<T,FromDecode>::encode(from.at(i), to);
			if(eov.is_error()){
				return eov;
			}
		}
		
		return void_t{};
	}
};

template<typename... V, string_literal... K, typename FromDecode>
struct csv_encode<schema::Struct<schema::Member<V,K>...>, FromDecode> {
	using Schema = schema::Struct<schema::Member<V,K>...>;

	template<size_t i>
	static error_or<void> encode_header_i(buffer& to){
		// Encode string
		//
		constexpr auto str_view = parameter_key_pack_type<i, K...>::literal;

		for(auto& iter : str_view.view()){
				auto eov = stream_value<schema::Int8>::encode(iter, to);
				if(eov.is_error()){
					return eov;
				}
		}

		// Go to next string
		if constexpr ( (i+1) < sizeof...(K)){
			/**
			 * Replace this with col separator
			 */
			constexpr std::string_view lit = ",";
			for(int8_t iter : lit){
				auto eov = stream_value<schema::Int8>::encode(iter, to);
				if(eov.is_error()){
					return eov;
				}
			}
			return encode_header_i<i+1>(to);
		}

		{
			/**
			 * Replace this with row separator
			 */
			constexpr std::string_view lit = "\n";
			for(int8_t iter : lit){
				auto eov = stream_value<schema::Int8>::encode(iter, to);
				if ( eov.is_error()){
					return eov;
				}
			}
		}

		return make_void();
	}

	static error_or<void> encode_header(buffer& to){
		if constexpr (sizeof...(V) > 0u){
			return encode_header_i<0u>(to);
		}
		return make_void();
	}

	template<size_t i>
	static error_or<void> encode_i(const data<Schema, FromDecode>& from, buffer& to){
		constexpr auto str_view = parameter_key_pack_type<i,K...>::literal;

		{
			auto eov = csv_encode<typename parameter_pack_type<i,V...>::type, FromDecode>::encode(from.template get<str_view>(), to);
			if(eov.is_error()){
				return eov;
			}
		}

		if constexpr ( (i+1) < sizeof...(K)){
			/**
			 * Replace this with col separator
			 */
			constexpr std::string_view lit = ",";
			for(int8_t iter : lit){
				auto eov = stream_value<schema::Int8>::encode(iter, to);
				if(eov.is_error()){
					return eov;
				}
			}
			return encode_i<i+1>(from, to);
		}
		{
			/**
			 * Replace this with row separator
			 */
			constexpr std::string_view lit = "\r\n";
			for(int8_t iter : lit){
				auto eov = stream_value<schema::Int8>::encode(iter, to);
				if ( eov.is_error()){
					return eov;
				}
			}
		}

		return make_void();
	}

	static error_or<void> encode(const data<Schema, FromDecode>& from, buffer& to){
		return encode_i<0>(from, to);
	}
};

template<typename FromDecode>
struct csv_encode<schema::String, FromDecode> {
	using Schema = schema::String;

	static error_or<void> encode(const data<Schema, FromDecode>& from, buffer& to){
		for(data<schema::UInt64> i = 0; i < from.size(); ++i){
			auto eov = stream_value<schema::Int8>::encode(from.at(i.get()), to);
			if(eov.is_error()){
				return eov;
			}
		}
		return make_void();
	}
};

template<class T, size_t N, typename FromDecode>
struct csv_encode<schema::Primitive<T,N>, FromDecode> {
	using Schema = schema::Primitive<T,N>;

	static error_or<void> encode(const data<Schema, FromDecode>& from, buffer& to){
		std::string to_str;
		try {
			to_str = std::to_string(from.get());
		}catch(const std::exception& ){
			return make_error<err::out_of_memory>();
		}
		for(auto iter : to_str){
			auto eov = stream_value<schema::Int8>::encode(iter, to);
			if(eov.is_error()){
				return eov;
			}
		}
		return make_void();
	}
};

template<typename Schema, typename FromDecode>
struct csv_decode {
	static_assert(always_false<Schema, FromDecode>, "Case not supported");
};

template<typename  T, size_t Dim, typename FromDecode>
struct csv_decode<schema::Array<T,Dim>, FromDecode> {
	static_assert(Dim == 1, "Only one dimension is allowed.");
	static_assert(!is_array<T>::value, "Array of an array is not allowed.");
	static_assert(is_tuple<T>::value || is_struct<T>::value, "Only struct or tuples allowed inside a csv array");

	using Schema = schema::Array<T,Dim>;

	static error_or<void> decode(data<Schema, encode::Csv>& from, data<Schema, FromDecode>& to){
		buffer_view view{from.get_buffer()};
		if constexpr (is_struct<T>::value) {
			auto eov = csv_decode<T, FromDecode>::check_header(view);
			if(eov.is_error()){
				return eov;
			}
		}

		uint64_t len{};
		return make_error<err::not_implemented>();
	}
};
}

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

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

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

template<typename Schema>
class codec<Schema, encode::Csv> {
	static_assert(is_array<Schema>::value, "Only an Array is allowed as a base value");
public:
	template<typename FromEncode>
	static error_or<void> encode(const data<Schema, FromEncode>& from, data<Schema,encode::Csv>& to){
		buffer_view buff_v{to.get_buffer()};

		auto eov = impl::csv_encode<Schema, FromEncode>::encode(from, buff_v);
		if(eov.is_error()){
			return eov;
		}
		to.get_buffer().write_advance(buff_v.write_offset());

		return eov;
	}
	
	template<typename ToDecode>
	static error_or<void> decode(data<Schema,encode::Csv>& from, data<Schema, ToDecode>& to){
		auto& buff = from.get_buffer();
		buffer_view buff_v{buff};
		auto eov  = impl::csv_decode<Schema, ToDecode>::decode(buff_v, to);
		if(eov.is_error()){
			return eov;
		}
		buff.write_advance(buff_v.write_offset());

		return eov;
	}
};
}