#pragma once

#include <forstio/templates.hpp>
#include <forstio/codec/schema.hpp>
#include <forstio/codec/data.hpp>
#include <forstio/codec/json/json.hpp>

#include <deque>
#include <fstream>
#include <iostream>

namespace saw {
namespace impl {
struct cli_mode {
	struct read {};
	struct write {};
	struct list {};
};

template<typename Schema, typename Encoding>
struct cli_traverser {	
	template<typename Traversal>
	static error_or<void> traverse(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
		return make_error<err::invalid_state>("Exhausted path or structure is not supported as of this moment");
	}
};

template<typename Schema, typename Encoding>
struct cli_modifier {
	codec<Schema, encode::Json> json;
	static_assert( std::is_same_v<Encoding, encode::Native<storage::Default>>, "Not supported" );

	error_or<void> read(
				std::deque<std::string>& sch_path,
				data<Schema, Encoding>& enc_data, 
				std::string& json_data_str
			)
	{
		{
			data<Schema, encode::Json> json_data;
			auto eov = json.template encode<Encoding>(enc_data, json_data);
			if(eov.is_error()){
				return eov;
			}

			json_data_str = convert_to_string(json_data.get_buffer());
		}

		return void_t{};
	}
	
	error_or<void> write(
					std::deque<std::string>& sch_path,
					data<Schema, Encoding>& enc_data,
					std::string& json_data_str
					){
		{
			/// @todo string to data
			data<Schema, encode::Json> json_data{ std::string_view{json_data_str} };
			auto eov = json.template decode<Encoding>(json_data, enc_data);
			if(eov.is_error()){
				return eov;
			}
		}
		return void_t{};
	}
};

template<typename Encoding>
struct cli_traverser<schema::String, Encoding> {
	using Schema = schema::String;

	template<typename Traversal>
	static error_or<void> traverse(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
		if(not sch_path.empty()){
			return make_error<err::invalid_state>("Schema path too long");
		}

		cli_modifier<Schema, Encoding> mod;
		if constexpr (std::is_same_v<Traversal, cli_mode::read>){
			return mod.read(sch_path, enc_data, json_data);
		} else if constexpr (std::is_same_v<Traversal, cli_mode::write>) {
			return mod.write(sch_path, enc_data, json_data);
		} else {
			return make_error<err::invalid_state>("We only support cli_mode::read and cli_mode::write");
		}
	}

};

template<typename... T, typename Encoding>
struct cli_traverser<schema::Tuple<T...>, Encoding> {
		using Schema = schema::Tuple<T...>;

		template<typename Traversal, size_t i>
		static error_or<void> traverse_member(std::deque<std::string>& sch_path, data<Schema, Encoding>& enc_data, std::string& json_data){
				using Type = typename parameter_pack_type<i,T...>::type;

				std::string num_str = std::to_string(i);
				if( num_str == sch_path.front() ){
						sch_path.pop_front();
						return cli_traverser<Type, Encoding>::template traverse<Traversal>(sch_path, enc_data.template get<i>(), json_data);
				}

				if ( (i+1) < sizeof...(T)){
						return traverse_member<Traversal, i+1>(sch_path, enc_data, json_data);
				}
			return make_error<err::invalid_state>("Didn't find tuple path element");
		}
};

/**
 * Traverse the path until we hit the end of the provided path
 */
template<typename... T, string_literal... Lits, typename Encoding>
struct cli_traverser<schema::Struct<schema::Member<T,Lits>...>, Encoding> {
	using Schema = schema::Struct<schema::Member<T,Lits>...>;

	template<typename Traversal, size_t i>
    static error_or<void> traverse_member(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
			using Type = typename parameter_pack_type<i,T...>::type;
		    constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;

			if ( Literal.view() == sch_path.front() ){
				sch_path.pop_front();
				return cli_traverser<Type, Encoding>::template traverse<Traversal>(sch_path, enc_data.template get<Literal>(), json_data);
			}

			if constexpr ( (i+1) < sizeof...(T) ) {
				return traverse_member<Traversal, i+1>(sch_path, enc_data, json_data);
			}
			return make_error<err::invalid_state>("Didn't find struct path element");
	}

	template<typename Traversal>
	static error_or<void> traverse(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
		/**
		 * If our path is empty, then we have reached the desired destination.
		 */
		if(sch_path.empty()){
		    /**
			 * Decide during this step if we are reading or not
			 */
			cli_modifier<Schema, Encoding> mod;
			if constexpr (std::is_same_v<Traversal, cli_mode::read>){
				return mod.read(sch_path, enc_data, json_data);
			} else if constexpr (std::is_same_v<Traversal, cli_mode::write>) {
				return mod.write(sch_path, enc_data, json_data);
			} else {
				return make_error<err::invalid_state>("We only support cli_mode::read and cli_mode::write");
			}
		} else {
				if constexpr ( sizeof...(T) > 0 ){
						return traverse_member<Traversal, 0>(sch_path, enc_data, json_data);
				}
				return make_error<err::invalid_state>("No elements in struct while path isn't empty");
		}

		return void_t{};
	}
};
}

struct parsed_args {
		bool read_mode = true;
		std::string file_path;
		std::deque<std::string> sch_path;
};

template<typename Schema, typename Encoding>
error_or<void> modify_data_on_cli(const std::string_view& mode, const std::string_view& file_path, std::deque<std::string> sch_path, std::string& json_data){
  /**
	 * Read data from file
	 */
	std::string file_data = [&]() -> std::string {
		std::fstream fstr{std::string{file_path}, fstr.binary | fstr.in};
		if(!fstr.is_open()){
			return {};
		}
		std::stringstream sstr;
		sstr << fstr.rdbuf();
		return sstr.str();
	}();
	if(file_data.empty()){
		return make_error<err::not_found>("File exists, but is empty.");
	}
	data<Schema, Encoding> enc_data{std::string_view{file_data}};
	codec<Schema, Encoding> enc_codec;
	
	data<Schema> native_data;
	{
		auto eov = enc_codec.decode(enc_data, native_data);
		if(eov.is_error()){
			return eov;
		}
	}

	if (mode == "r") {
		{
			auto eov = impl::cli_traverser<Schema, encode::Native<storage::Default>>::template traverse<impl::cli_mode::read>(sch_path, native_data, json_data);
			if(eov.is_error()){
				return eov;
			}
		}
	} else if (mode == "w") {
		{
			auto eov = impl::cli_traverser<Schema, encode::Native<storage::Default>>::template traverse<impl::cli_mode::write>(sch_path, native_data, json_data);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			auto eov = enc_codec.template encode<encode::Native<storage::Default>>(native_data, enc_data);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			std::fstream fstr{std::string{file_path}, fstr.binary | fstr.out | fstr.trunc };
			if(!fstr.is_open()){
				return make_error<err::invalid_state>("Couldn't open file");
			}
			std::stringstream sstr;
			std::string enc_str = convert_to_string(enc_data.get_buffer());

			fstr << enc_str;
			fstr.close();
		}
	} else if (mode == "l"){
		{
		}
	}else{
		return make_error<err::invalid_state>("Invalid mode");
	}

	return void_t{};
}
}