#pragma once

#include "schema.hpp"
#include "data.hpp"

#include <algorithm>
#include <charconv>

namespace saw {
namespace encode {
struct Args {};
}

namespace schema {
template<typename InnerSchemaStruct, typename InnerSchemaTuple>
using Args = Struct<
	Member<String, "program">,
	Member<InnerSchemaStruct, "args">,
	Member<InnerSchemaTuple, "positionals">
>;
}

template<typename T>
class data<T, encode::Args> {
	static_assert(always_false<T>,"Not supported. Use the schema::Args alias or check how it's defined.");
};

template<typename... Str, string_literal... Lits, typename... Tup>
class data<schema::Args<schema::Struct<schema::Member<Str,Lits>...>, schema::Tuple<Tup...>>, encode::Args> {
private:
	int argc_;
	char** argv_;
public:
	data(int argc, char** argv):
		argc_{argc},
		argv_{argv}
	{}

	uint64_t size() const {
		if(argc_ < 0){
			return 0u;
		}

		static_assert(sizeof(int) <= sizeof(uint64_t), "size_t is smaller than int");

		return static_cast<uint64_t>(argc_);
	}

	std::string_view arg_view(uint64_t i){
		if(i < size()){
			return std::string_view{argv_[i]};
		}
		return "";
	}
};

namespace impl {
template<typename T, typename ToDec>
struct args_decode {
	static_assert(always_false<T,ToDec>, "Not supported");
};

template<typename T, uint64_t N, typename ToDec>
struct args_decode<schema::Primitive<T,N>, ToDec> {
	using Schema = schema::Primitive<T,N>;

	static error_or<void> decode(data<Schema, ToDec>& to, std::string_view view){
		if(view.empty()){
			return make_error<err::invalid_state>("Can't decode empty data.");
		}
		typename native_data_type<Schema>::type val{};
		auto fc_res = std::from_chars(view.data(), view.data()+view.size(), val);
		if(fc_res.ec != std::errc{}){
			auto err_bld = error_builder{[&](){
				return std::string{"Parsing of failed: "} + std::string{view};
			}};
			return err_bld.template make_error<err::invalid_state>("Parsing failed. ");
		}
		to.set(val);

		return make_void();
	}
};

template<typename ToDec>
struct args_decode<schema::String, ToDec> {
	using Schema = schema::String;

	static error_or<void> decode(data<Schema, ToDec>& to, std::string_view view){
		try{
			to.set(std::string{view});
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}
		return make_void();
	}
};

template<typename... Str, string_literal... Lits, typename... Tup, typename ToDec>
struct args_decode<schema::Args<schema::Struct<schema::Member<Str,Lits>...>,schema::Tuple<Tup...>>,ToDec> {
	using Schema = schema::Args<
		schema::Struct<schema::Member<Str,Lits>...>,
		schema::Tuple<Tup...>
	>;

	using SchemaStruct = schema::Struct<schema::Member<Str,Lits>...>;
	using SchemaTuple = schema::Tuple<Tup...>;

	template<uint64_t i>
	static error_or<void> decode_struct_member(data<SchemaStruct, ToDec>& to, std::string_view name, std::string_view value){
		if constexpr ( i < sizeof...(Str) ) {
			static constexpr string_literal Literal = parameter_key_pack_type<i,Lits...>::literal;
			using StrT = typename parameter_pack_type<i,Str...>::type;

			if(Literal.view() == name){
				auto& target = to.template get<Literal>();
				auto eov = args_decode<StrT, ToDec>::decode(target, value);
				return eov;
			}

			return decode_struct_member<i+1u>(to, name, value);
		}
		return make_error<err::not_found>("Couldn't decode argument");
	}
	
	template<uint64_t i>
	static error_or<void> decode_tuple_member(data<SchemaTuple, ToDec>& to, uint64_t ptr_i, std::string_view value){
		if constexpr ( i < sizeof...(Tup) ){
			if ( i == ptr_i ){
				using TupT = typename parameter_pack_type<i,Tup...>::type;
				auto& target = to.template get<i>();
				
				return args_decode<TupT, ToDec>::decode(target, value);
			}
			return decode_tuple_member<i+1u>(to, ptr_i, value);
		}
		return make_error<err::invalid_state>("Too many positional arguments.");
	}

	static error_or<void> decode(data<Schema, encode::Args>& from, data<Schema,ToDec>& to){
		if(from.size() == 0){
			return make_error<err::invalid_state>();
		}

		to.template get<"program">().set(std::string{from.arg_view(0)});
		uint64_t tuple_pos = 0;

		for(size_t i = 1; i < from.size(); ++i){
			auto view = from.arg_view(i);
			if(view.starts_with("--")){
				auto min_val = view.size() > 2u ? 2u : view.size();
				view.remove_prefix(min_val);
				++i;

				if( i >= from.size() ){
					return make_error<err::invalid_state>();
				}

				auto value_view = from.arg_view(i);

				auto eov = decode_struct_member<0>(to.template get<"args">(), view, value_view);
				if(eov.is_error()){
					return eov;
				}
			} else {
				auto eov = decode_tuple_member<0>(to.template get<"positionals">(), tuple_pos, view);
				if(eov.is_error()){
					return eov;
				}
				++tuple_pos;
			}
		}

		if(tuple_pos != sizeof...(Tup)){
			return make_error<err::invalid_state>("Didn't parse the whole set of positionals.");
		}

		return void_t{};
	}
};
}

template<typename Schema>
class codec<Schema, encode::Args> {
public:
	template<typename ToDec>
	error_or<void> decode(data<Schema, encode::Args>& from, data<Schema, ToDec>& to){
		/*
		struct name_and_value {
			std::string name;
			std::string value;
		};
		std::string program;
		std::vector<name_and_value> navs;
		std::vector<std::string> positionals;
		*/

		auto eov = impl::args_decode<Schema,ToDec>::decode(from,to);
		return eov;
	}
};
}