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

#include <string>
#include <sstream>
#include <map>

#include <iostream>

namespace saw {

namespace schema {

using CVar = Struct<
	Member<schema::String, "schema">,
	Member<schema::String, "type">,
	Member<schema::String, "name">
>;

using CStruct = Struct<
	Member<schema::String, "schema">,
	Member<schema::String, "name">,
	Member<Array<CVar>, "members">
>;

using CFunction = Struct<
	Member<schema::String, "schema">,
	Member<schema::String, "name">,
	Member<Array<CVar>, "params">,
	Member<CVar, "return">
>;

using CIface = Struct<
	Member<schema::String, "schema">,
	Member<Array<CStruct>,"structs">,
	Member<Array<CFunction>,"functions">
>;
}
/**
 * Type meant to provide future help if I decide to introduce more maps
 */
/**
namespace schema {
using namespace saw::schema;
Pseudo flattened
using Foo = Struct<
		Member<Array<Int32>, "a">
		Member<Array<Float32>, "b">
>;

Needs to be flattened to

template<typename InnerSchema>
using FlattenedSchemaElement = Struct<
		Member<Array<String>, "path">,
		Member<InnerSchema, "inner_schema">
>;

// Illegal, but doable with more lines of code
// Just use typename... T and 
// "T..." for
// "Member<FlattenedSchemaElement<Ele>,Names>...>"
// and specialize somewhere else
template<typename... Ele, string_literal... Names>
using FlattenedSchema = Struct<
		Member<String, "top_schema">,
		Member<FlattenedSchemaElement<Ele>, Names>...
>;
}
 */
template<typename T, typename Res>
struct schema_flattener {
		static_assert(always_false<T>, "Not supported");
};

template<typename T0, string_literal Name0, typename... T, string_literal... Names, typename Res>
struct schema_flattener<schema::Struct<schema::Member<T0,Name0>,schema::Member<T,Names>...>, Res> {
};

/**
 * Helper to determine if we are dealing with primitive types
 */
template<typename Schema>
struct c_is_primitive {
		static constexpr bool value = false;
};

template<typename T, size_t N>
struct c_is_primitive<schema::Primitive<T,N>> {
		static constexpr bool value = true;
};

template<typename Schema>
struct c_primitive_string {
	static_assert(always_false<Schema>, "Not supported");
};

template<>
struct c_primitive_string<schema::Int8> {
	static constexpr std::string_view value = "int8_t";
};

template<>
struct c_primitive_string<schema::Int16> {
	static constexpr std::string_view value = "int16_t";
};

template<>
struct c_primitive_string<schema::Int32> {
	static constexpr std::string_view value = "int32_t";
};

template<>
struct c_primitive_string<schema::Int64> {
	static constexpr std::string_view value = "int64_t";
};

template<>
struct c_primitive_string<schema::UInt8> {
	static constexpr std::string_view value = "uint8_t";
};

template<>
struct c_primitive_string<schema::UInt16> {
	static constexpr std::string_view value = "uint16_t";
};

template<>
struct c_primitive_string<schema::UInt32> {
	static constexpr std::string_view value = "uint32_t";
};

template<>
struct c_primitive_string<schema::UInt64> {
	static constexpr std::string_view value = "uint64_t";
};

template<>
struct c_primitive_string<schema::Float32> {
	static constexpr std::string_view value = "float";
};

template<>
struct c_primitive_string<schema::Float64> {
	static constexpr std::string_view value = "double";
};

bool c_interface_function_exists(data<schema::CIface>& state, const std::string_view& name){
	auto& funcs = state.template get<"functions">();
	for(uint64_t i = 0; i < funcs.size(); ++i){
		if(funcs.at(i).get<"name">() == name){
			return true;
		}
	}
	return false;
}

template<typename Schema>
struct c_data_translater {
	static_assert(always_false<Schema>, "Not supported");
};

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

	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& prim){
		/// @TODO Check if exists in CVars already
		try{
			std::stringstream iss;
			schema_stringify<Schema>::apply(iss);
			prim.template get<"schema">().set(iss.str());
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}

		return void_t{};
	}
};

template<typename Req, typename Ret>
struct c_data_translater<schema::Function<Req,Ret>> {
	using Schema = schema::Function<Req,Ret>;

	static error_or<void> generate(data<schema::CIface>& state, const std::string_view& func_name){
		if(c_interface_function_exists(state, func_name)){
			return make_error<err::invalid_state>("Function already exists");
		}

		auto& funcs = state.template get<"functions">();
		data<schema::CFunction> function;
		function.template get<"name">().set(std::string{func_name});
		
		try{
			std::stringstream iss;
			schema_stringify<Schema>::apply(iss);
			function.template get<"schema">().set(iss.str());
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}

		{
			auto& c_var = function.template get<"return">();
			c_var.template get<"name">().set("ret_val");
			auto eov = c_data_translater<Ret>::generate(state, c_var);
			if(eov.is_error()){
				return eov;
			}
		}

		{
			auto eov = funcs.add(std::move(function));
			if(eov.is_error()){
				return eov;
			}
		}

		return void_t{};
	}
};

template<typename... Funcs, string_literal... Names>
struct c_data_translater<schema::Interface<schema::Member<Funcs,Names>...>> {
	using Schema = schema::Interface<schema::Member<Funcs, Names>...>;

	template<std::size_t i>
	static error_or<void> generate_ele(data<schema::CIface>& state){
		using InnerSchema = typename parameter_pack_type<i, Funcs...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i, Names...>::literal;
		{
			auto eov = c_data_translater<InnerSchema>::generate(state, Literal.view());
			if(eov.is_error()){
				return eov;
			}
		}

		/**
		 * Continue if elements remain or finish
		 */
		if constexpr ( (i+1) < sizeof...(Funcs) ){
			return generate_ele<i+1>(state);
		}
		return void_t{};
	}

	static error_or<void> generate(data<schema::CIface>& state){
		try{
			std::stringstream iss;
			schema_stringify<Schema>::apply(iss);
			state.template get<"schema">().set(iss.str());
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}
		
		if constexpr (sizeof...(Funcs) > 0){
			return generate_ele<0>(state);
		}
		return void_t{};
	}
};

template<typename Interface>
error_or<void> generate_c_interface(data<schema::CIface>& state){
	auto eov = c_data_translater<Interface>::generate(state);
	return eov;
}

}