#pragma once

#include <forstio/codec/schema.h>

#include <iostream>

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

template<typename T, typename Encoding>
struct cli_traverser {
	static_assert(always_false<T,Encoding>, "Not supported");
};

template<typename Schema, typename Encoding>
struct cli_modifier {
	codec<Schema, encode::Json> json;
	codec<Schema, Encoding> encoded;

	error_or<void> read(data<Schema, Encoding>& enc_data, std::deque<std::string>& sch_path, std::string& json_data_str){
		data<Schema, encode::Native> native;
		{
			auto eov = encoded.decode<encode::Native>(enc_data, native);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			data<Schema, encode::Json> json_data;
			auto eov = json.encode<encode::Native>(native, 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(data<Schema, Encoding>& enc_data, std::deque<std::string>& sch_path, std::string& json_data_str){
		data<Schema, encode::Native> native;
		{
			/// @todo string to data
			data<Schema, encode::Json> json_data{ std::string_view{json_data_str} };
			auto eov = json.decode<encode::Native>(json_data, native);
			if(eov.is_error()){
				return eov;
			}
		}
		{
			auto eov = encoded.encode<encode::Native>(native, enc_data);
			if(eov.is_error()){
				return eov;
			}
		}i

		return void_t{};

	}
};

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>
	static error_or<void> traverse(std::deque<std::string>& sch_path, std::string& json_data){
		if(sch_path.empty()){
			cli_modifier<Schema, Encoding> mod;
			if constexpr (std::is_same_v<Traversal, cli_mode::read>){
				return mod.read(sch_path, json_data);
			} else if constexpr (std::is_same_v<Traversal, cli_mode::write>) {
				return mod.write(sch_path, json_data);
			} else {
				return make_error<err::invalid_state>();
			}
		} else {

		}

		return void_t{};
	}
};
}

template<typename Schema, typename Encoding>
int modify_data_on_cli(int argc, char** argv){

	/// @todo parse cli data
	bool read_mode = true;

	std::deque<std::string> sch_path;
	std::string json_data;

	if (read_mode) {
		auto eov = impl::cli_modifier<Schema, Encoding>::traverse<impl::cli_mode::read>(sch_path, json_data);
		if(eov.is_error()){
			return -1;
		}
	} else {
		auto eov = impl::cli_modifier<Schema, Encoding>::traverse<impl::cli_mode::write>(sch_path, json_data);
		if(eov.is_error()){
			return -1;
		}
	}

	return 0;
}
}