#pragma once

#include <forstio/buffer.hpp>
#include <forstio/common.hpp>
#include <forstio/codec/data.hpp>

#include <algorithm>

namespace saw {
namespace encode {
struct Json {
};
}

template<typename Schema>
class data<Schema, encode::Json> {
private:
	ring_buffer buffer_;
public:
	data():buffer_{}{}

	data(std::size_t ring_size_):buffer_{ring_size_}{}

	data(ring_buffer buff_):
		buffer_{std::move(buff_)}
	{}

	data(const std::string_view& view__):
		buffer_{view__.size()}
	{
		auto ptr = reinterpret_cast<const uint8_t*>(view__.data());
		if(!ptr){
			return;
		}
		buffer_.push(*ptr, view__.size());
	}

	buffer& get_buffer(){
		return buffer_;
	}

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

	error push(uint8_t val){
		return buffer_.push(val);
	}

	std::size_t get_size() const {
		return buffer_.read_composite_length();
	}

	uint8_t& at(std::size_t i){
		return buffer_.read(i);
	}
	
	const uint8_t& at(std::size_t i) const {
		return buffer_.read(i);
	}
};
}

#include "json.tmpl.hpp"

namespace saw {

/**
 * Codec class for json
 */
template<typename Schema>
class codec<Schema, encode::Json> {
public:
	struct config {
		size_t depth = 16;
		size_t length = 4096;
		bool pretty = false;
	};
private:
	config cfg_;
public:
	/**
	 * Default constructor
	 */
	codec(){}

	/**
	 * Constructor
	 */
	codec(config cfg__):cfg_{std::move(cfg__)}{}

	SAW_FORBID_COPY(codec);
	SAW_DEFAULT_MOVE(codec);

	template <typename FromEncoding>
	error_or<void> encode(const data<Schema, FromEncoding>& from_encode, data<Schema, encode::Json>& to_encode){
		// To Be encoded
		buffer_view buff_v{to_encode.get_buffer()};
		auto eov = impl::json_encode<Schema, FromEncoding>::encode(from_encode, buff_v);
		if(eov.is_error()){
			return std::move(eov.get_error());
		}
		to_encode.get_buffer().write_advance(buff_v.write_offset());

		return void_t{};
	}

	template <typename ToEncoding>
	error_or<void> decode(data<Schema, encode::Json>& from_decode, data<Schema, ToEncoding>& to_decode){
		buffer_view buff_v{from_decode.get_buffer()};

		auto eov = impl::json_decode<Schema, ToEncoding>::decode(buff_v, to_decode);
		if(eov.is_error()){
			return std::move(eov.get_error());
		}
		from_decode.get_buffer().read_advance(buff_v.read_offset());

		return void_t {};
	}
};
}