#include <forstio/error.hpp>
#include <forstio/codec/data.hpp>
#include <forstio/codec/schema.hpp>
#include <forstio/codec/schema_hash.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::UInt32, "crc32">,
	Member<schema::String, "type">,
	Member<schema::String, "type_name">,
	Member<schema::String, "name">,
	Member<schema::Int8, "is_primitive">
>;

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

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

using CIface = Struct<
	Member<schema::String, "schema">,
	Member<schema::UInt32, "crc32">,
	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 string_literal name = "int8";
	static constexpr string_literal value = "int8_t";
};

template<>
struct c_primitive_string<schema::Int16> {
	static constexpr string_literal name = "int16";
	static constexpr string_literal value = "int16_t";
};

template<>
struct c_primitive_string<schema::Int32> {
	static constexpr string_literal name = "int32";
	static constexpr string_literal value = "int32_t";
};

template<>
struct c_primitive_string<schema::Int64> {
	static constexpr string_literal name = "int64";
	static constexpr string_literal value = "int64_t";
};

template<>
struct c_primitive_string<schema::UInt8> {
	static constexpr string_literal name = "uint8";
	static constexpr string_literal value = "uint8_t";
};

template<>
struct c_primitive_string<schema::UInt16> {
	static constexpr string_literal name = "uint16";
	static constexpr string_literal value = "uint16_t";
};

template<>
struct c_primitive_string<schema::UInt32> {
	static constexpr string_literal name = "uint32";
	static constexpr string_literal value = "uint32_t";
};

template<>
struct c_primitive_string<schema::UInt64> {
	static constexpr string_literal name = "uint64";
	static constexpr string_literal value = "uint64_t";
};

template<>
struct c_primitive_string<schema::Float32> {
	static constexpr string_literal name = "float32";
	static constexpr string_literal value = "float";
};

template<>
struct c_primitive_string<schema::Float64> {
	static constexpr string_literal name = "float64";
	static constexpr string_literal value = "double";
};

error_or<data<schema::UInt64>> c_interface_find_struct_by_crc32(const data<schema::CIface>& state, const data<schema::UInt32>& id){
	const auto& strs = state.template get<"structs">();
	for(uint64_t i = 0; i < strs.size(); ++i){
		const auto& str = strs.at(i);
		if(str.template get<"crc32">() == id){
			return data<schema::UInt64>{i};
		}
	}
	return make_error<err::not_found>();
}

error_or<void> c_interface_add_struct(data<schema::CIface>& state, data<schema::CStruct>&& val){
	auto& strs = state.template get<"structs">();
	auto eov = strs.add(std::move(val));
	if(eov.is_error()){
		return std::move(eov.get_error());
	}
	return void_t{};
}

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 constexpr string_literal c_type_name = c_primitive_string<Schema>::name;
	static constexpr string_literal c_type = c_primitive_string<Schema>::value;

	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& prim){
		try{
			std::stringstream iss;
			schema_stringify<Schema>::apply(iss);
			prim.template get<"schema">().set(iss.str());
			prim.template get<"crc32">().set(schema_hash<Schema>::apply());
			prim.template get<"is_primitive">().set(1);
			prim.template get<"type">().set(std::string{c_primitive_string<Schema>::value.view()});
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}

		return void_t{};
	}
};

template<typename T, uint64_t N>
struct c_data_translater<schema::Array<T,N>> {
	static_assert(N==1, "Doesn't support more than one dimension currently");

	using Schema = schema::Array<T,N>;
	static constexpr string_literal c_type_name = "array_"_sl + c_data_translater<T>::c_type_name + "_1d"_sl;
	static constexpr string_literal c_type = c_type_name + "_t"_sl;

	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& arr){
		try{
			{
				std::stringstream iss;
				schema_stringify<Schema>::apply(iss);
				arr.template get<"schema">().set(iss.str());
				arr.template get<"crc32">().set(schema_hash<Schema>::apply());
				arr.template get<"is_primitive">().set(0);
			}

			/// @todo change this !!!!!
			{
				auto eov = c_interface_find_struct_by_crc32(state, arr.template get<"crc32">());
				if(eov.is_error()){
					if(false){
						return std::move(eov.get_error());
					}
					data<schema::CStruct> str;
					str.template get<"schema">() = arr.template get<"schema">();
					str.template get<"crc32">() = arr.template get<"crc32">();
					str.template get<"type">().set(std::string{c_type.view()});
					auto& membs = str.template get<"members">();
					{
						data<schema::CVar> c_var;
						std::stringstream iss;
						schema_stringify<T>::apply(iss);
						c_var.template get<"schema">().set(iss.str());
						c_var.template get<"crc32">().set(schema_hash<T>::apply());
						if constexpr (is_primitive<T>::value){
							c_var.template get<"type">().set(std::string{c_primitive_string<T>::value.view()} + "*");
							c_var.template get<"name">().set(std::string{"data"});
							c_var.template get<"is_primitive">().set(1);
						}else{
							return make_error<err::not_implemented>();
						}

						auto eov_add = membs.add(std::move(c_var));
						if(eov_add.is_error()){
							return std::move(eov_add.get_error());
						}
					}
					{
						data<schema::CVar> c_var;
						std::stringstream iss;
						schema_stringify<schema::UInt64>::apply(iss);
						c_var.template get<"schema">().set(iss.str());
						c_var.template get<"crc32">().set(schema_hash<schema::UInt64>::apply());
						if constexpr (is_primitive<T>::value){
							c_var.template get<"type">().set(std::string{c_primitive_string<schema::UInt64>::value.view()});
							c_var.template get<"name">().set(std::string{"size"});
							c_var.template get<"is_primitive">().set(1);
						}else{
							return make_error<err::not_implemented>();
						}

						auto eov_add = membs.add(std::move(c_var));
						if(eov_add.is_error()){
							return std::move(eov_add.get_error());
						}
					}

					/**
					 * Add the struct to the struct array
					 */
					{
						auto eov_add = c_interface_add_struct(state, std::move(str));
						if(eov_add.is_error()){
							return std::move(eov_add.get_error());
						}
					}
				}
			}
			arr.template get<"type">().set(std::string{c_type.view()});
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}

		return void_t{};
	}
};

/*
template<typename... Members>
struct c_data_translater<schema::Struct<Members...>> {
	using Schema = schema::Struct<Members...>;

	static error_or<void> generate(data<schema::CIface>& state){
		return void_t{};
	}
};
*/

template<typename Str>
struct c_parameter_translater {
	static_assert(always_false<Str>, "Type not supported");
};

template<typename... V, string_literal... K>
struct c_parameter_translater<schema::Struct<schema::Member<V,K>...>> {
	template<uint64_t i>
	static error_or<void> generate_ele(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
		using Type = typename parameter_pack_type<i, V...>::type;
		constexpr string_literal Literal = parameter_key_pack_type<i,K...>::literal;

		{
			auto c_var = data<schema::CVar>{};
			c_var.template get<"name">().set(std::string{Literal.view()});
			{
				auto eov = c_data_translater<Type>::generate(state,c_var);
				if(eov.is_error()){
					return eov;
				}
			}
			{
				auto eov = params.add(std::move(c_var));
				if(eov.is_error()){
					return eov;
				}
			}
		}

		if constexpr ( (i+1) < sizeof...(V) ) {
			return generate_ele<i+1>(state, params);
		}
		return void_t{};
	}

	static error_or<void> generate(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
		if constexpr ( sizeof...(V) > 0){
			return generate_ele<0>(state, params);
		}
		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_struct_params(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
		return c_parameter_translater<Req>::generate(state, params);
	}

	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());
			function.template get<"crc32">().set(schema_hash<Schema>::apply());
		}catch(const std::exception&){
			return make_error<err::out_of_memory>();
		}

		// Return value
		{
			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;
			}
		}

		// Request values
		auto& params = function.template get<"params">();
		if constexpr (is_primitive<Req>::value){
			auto c_var = data<schema::CVar>{};
			c_var.template get<"name">().set("req_val");
			{
				auto eov = c_data_translater<Req>::generate(state, c_var);
				if(eov.is_error()){
					return eov;
				}
			}
			{
				auto eov = params.add(std::move(c_var));
				if(eov.is_error()){
					return eov;
				}
			}
		} else {
			auto eov = generate_struct_params(state, params);
			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());
			state.template get<"crc32">().set(schema_hash<Schema>::apply());
		}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;
}

}