#pragma once

#include <charconv>

namespace saw {
namespace impl {
template<typename Schema, typename RootSchema, typename FromEncode>
class json_encode {
	static_assert(always_false<Schema, RootSchema, FromEncode>, "This schema type is not being handle by the json encoding.");
};

template<typename T, size_t N, typename RootSchema, typename FromEncode>
struct json_encode<schema::Primitive<T,N>, RootSchema, FromEncode> {
	static error_or<void> encode(const data<schema::Primitive<T,N>, FromEncode>& from, buffer& to) {
		auto val = from.get();
		std::array<uint8_t, 256> data;
		auto tc_result = std::to_chars(reinterpret_cast<char*>(data.data()), reinterpret_cast<char*>(data.data())+data.size(), val);

		if(tc_result.ec != std::errc{}){
			return make_error<err::critical>();
		}

		size_t bytes_written = 0;
		for(char* ptr = reinterpret_cast<char*>(data.data()); ptr != tc_result.ptr; ++ptr){
			++bytes_written;
		}

		auto& buff = to;
		error err = buff.write_require_length(bytes_written);
		if(!err.template is_type<err::no_error>()){
			return std::move(err);
		}

		for(char* ptr = reinterpret_cast<char*>(data.data()); ptr != tc_result.ptr; ++ptr){
			uint8_t* un_ptr = reinterpret_cast<uint8_t*>(ptr);
			buff.push(un_ptr[0]);
		}

		return void_t{};
	}
};

template<typename RootSchema, typename FromEncode>
struct json_encode<schema::String, RootSchema, FromEncode>  {
	static error_or<void> encode(const data<schema::String, FromEncode>& from, buffer& to) {
		{
			auto err = to.push('"');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		for(std::size_t i = 0; i < from.size(); ++i){
			auto err = to.push(from.get_at(i));
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		{
			auto err = to.push('"');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}

		return void_t{};
	}
};

template<typename... T, typename RootSchema, typename FromEncode>
struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {

	template<size_t i>
	static error_or<void> encode_element(const data<schema::Tuple<T...>, FromEncode>& from, buffer& to){
		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<i>(), to);

		if(eov.is_error()){
			return eov;
		}

		if constexpr ( (i+1) < sizeof...(T)){
			{
				auto eov_ele = to.push(',');
				if(!eov_ele.template is_type<err::no_error>()){
					return eov_ele;
				}
			}
			{
				auto eov_ele = encode_element<i+1>(from, to);
				if(eov_ele.is_error()){
					return eov_ele;
				}
			}


		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Tuple<T...>, FromEncode>& from, buffer& to) {
		{
			auto err = to.push('[');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		if constexpr ( sizeof...(T) > 0 ){
			auto eov = encode_element<0>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			auto err = to.push(']');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}

		return void_t{};
	}
};

template<typename T, size_t D, typename RootSchema, typename FromEncode>
struct json_encode<schema::Array<T,D>, RootSchema, FromEncode>  {
	template<size_t Level>
	static error_or<void> encode_level(const data<schema::Array<T,D>, FromEncode>& from, buffer& to, std::array<std::size_t, D>& index){
		if constexpr (Level == D){
			auto eov = json_encode<T, RootSchema, FromEncode>::encode(from.at(index), to);
			if(eov.is_error()){
				return eov;
			}
		} else {
			{
				auto err = to.push('[');
				if(!err.template is_type<err::no_error>()){
					return err;
				}
			}
			for(std::size_t i = 0; i < from.get_dim_size(Level); ++i){
				if( i > 0 ){
					auto err = to.push(',');
					if(!err.template is_type<err::no_error>()){
						return err;
					}
				}
				{
					index[Level] = i;
					auto eov = encode_level<Level+1>(from, to, index);
					if(eov.is_error()){
						return eov;
					}
				}
			}
			{
				auto err = to.push(']');
				if(!err.template is_type<err::no_error>()){
					return err;
				}
			}
		}
		return void_t{};
	}

	static error_or<void> encode(const data<schema::Array<T,D>, FromEncode>& from, buffer& to) {
		std::array<std::size_t, D> index;
		return encode_level<0>(from, to, index);
	}
};

template<typename... T, string_literal... Key, typename RootSchema, typename FromEncode>
struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEncode>  {

	template<size_t i>
	static error_or<void> encode_element(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to){
		// Encode the name
		{
			std::string_view view = parameter_key_pack_type<i, Key...>::literal.view();
			error err = to.push('"');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
			err = to.push(*reinterpret_cast<const uint8_t *>(view.data()), view.size());
			if(!err.template is_type<err::no_error>()){
				return err;
			}
			err = to.push('"');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		// Add the separator
		{
			auto eov_ele = to.push(':');
			if(!eov_ele.template is_type<err::no_error>()){
				return eov_ele;
			}
		}
	
		// Encode the value
		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
		
		// Go to the next element
		if constexpr ( (i+1) < sizeof...(T)){
			{
				auto eov_ele = to.push(',');
				if(!eov_ele.template is_type<err::no_error>()){
					return eov_ele;
				}
			}
			{
				auto eov_ele = encode_element<i+1>(from, to);
				if(eov_ele.is_error()){
					return eov_ele;
				}
			}


		}

		return void_t{};
	}
	static error_or<void> encode(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to) {
		{
			auto err = to.push('{');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		if constexpr ( sizeof...(T) > 0 ){
			auto eov = encode_element<0>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			auto err = to.push('}');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}

		return void_t{};
	}
};

template<typename... T, string_literal... Key, typename RootSchema, typename FromEncode>
struct json_encode<schema::Union<schema::Member<T,Key>...>, RootSchema, FromEncode>  {

	template<size_t i>
	static error_or<void> encode_element(const data<schema::Union<schema::Member<T,Key>...>, FromEncode>& from, buffer& to){
		if(from.template holds_alternative<typename parameter_key_pack_type<i, Key...>::literal>()){
			// Encode the name
			{
				std::string_view view = parameter_key_pack_type<i, Key...>::literal.view();
				error err = to.push('"');
				if(!err.template is_type<err::no_error>()){
					return err;
				}
				err = to.push(*reinterpret_cast<const uint8_t *>(view.data()), view.size());
				if(!err.template is_type<err::no_error>()){
					return err;
				}
				err = to.push('"');
				if(!err.template is_type<err::no_error>()){
					return err;
				}
			}
			// Add the separator
			{
				auto eov_ele = to.push(':');
				if(!eov_ele.template is_type<err::no_error>()){
					return eov_ele;
				}
			}
		
			// Encode the value
			auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
		}
		// Go to the next element
		if constexpr ( (i+1) < sizeof...(T)){
			{
				auto eov_ele = encode_element<i+1>(from, to);
				if(eov_ele.is_error()){
					return eov_ele;
				}
			}


		}

		return void_t{};
	}
	static error_or<void> encode(const data<schema::Union<schema::Member<T,Key>...>, FromEncode>& from, buffer& to) {
		{
			auto err = to.push('{');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}
		if constexpr ( sizeof...(T) > 0 ){
			auto eov = encode_element<0>(from, to);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			auto err = to.push('}');
			if(!err.template is_type<err::no_error>()){
				return err;
			}
		}

		return void_t{};
	}
};

template<typename Schema, typename RootSchema, typename ToDecode>
struct json_decode;

template<typename T, size_t N, typename RootSchema, typename ToDecode>
struct json_decode<schema::Primitive<T,N>, RootSchema, ToDecode> {
	static error_or<void> decode(buffer_view& buff, data<schema::Primitive<T,N>, ToDecode>& to){
		assert((buff.read() >= '0' && buff.read() <= '9') ||
		   buff.read() == '+' || buff.read() == '-');

		std::size_t offset = 0;

		if(buff.read() == '-'){
			++offset;
		}else if(buff.read() == '+'){
			return make_error<err::not_supported>();
		}
		if (offset >= buff.read_composite_length()) {
			return make_error<err::buffer_exhausted>();
		}
		if(buff.read(offset) >= '1' && buff.read(offset) <= '9'){
			++offset;

			if(offset >= buff.read_composite_length()){
				return make_error<err::buffer_exhausted>();
			}

			while(1){
				if (buff.read(offset) >= '0' && buff.read(offset) <= '9'){
					++offset;

					if(offset >= buff.read_composite_length()){
						break;
					}
					continue;
				}
				break;
			}
		}else if (buff.read(offset) == '0' ){
			++offset;
		}else{
			return make_error<err::buffer_exhausted>();
		}

		{
			std::string_view num_view{reinterpret_cast<char*>(&buff.read()), offset};
			typename native_data_type<schema::Primitive<T,N>>::type result;
			auto fc_result = std::from_chars(num_view.data(), num_view.data() + num_view.size(), result);
			if(fc_result.ec != std::errc{}){
				return make_error<err::invalid_state>();
			}

			to.set(result);
		}
		buff.read_advance(offset);

		return void_t{};
	}	
};

template<typename T, size_t D, typename RootSchema, typename ToDecode>
struct json_decode<schema::Array<T,D>, RootSchema, ToDecode> {
	template<size_t Level>
	static error_or<void> decode_level(buffer_view& buff, data<schema::Array<T,D>, ToDecode>& to, std::array<std::size_t, D>& index){
		if constexpr (Level == D) {
			auto eov = json_decode<T, RootSchema, ToDecode>::decode(buff, to.at(index));
			if(eov.is_error()){
				return eov;
			}
		} else {
			assert(buff.read() == '[');
			buff.read_advance(1);
			if( buff.read_composite_length() == 0 ){
				return make_error<err::buffer_exhausted>();
			}
			
		}
		return void_t{};
	}

	static error_or<void> decode(buffer_view& buff, data<schema::Array<T,D>, ToDecode>& to){
		std::array<std::size_t, D> index;
		return decode_level<0>(buff, to, index);
	}
};
}
}