#pragma once

#include "config-node.h"
#include "midi-node.h"
#include "graph-item.h"
#include "node-handle.h"
#include "node.h"
#include "edge.h"

#include "datatypes.h"
#include "signal.h"

#include <iostream>
#include <memory>

typedef std::shared_ptr<VISEQ::GRAPH::GraphItem> SPTR_GraphItem;
typedef std::vector<SPTR_GraphItem> VEC_SPTR_GraphItem;

namespace nlohmann {
	template <typename T>
	struct adl_serializer<std::shared_ptr<T>> {
		static void to_json(json& j, const std::shared_ptr<T>& opt) {
			if (opt) {
				j = *opt;
			} else {
				j = nullptr;
			}
		}

		static void from_json(const json& j, std::shared_ptr<T>& opt) {
			if (j.is_null()) {
				opt = nullptr;
			} else {
				opt.reset(new T(j.get<T>()));
			}
		}
	};
	
	/*template <typename T>*/
	/*struct adl_serializer<std::shared_ptr<T>> {*/
	/*	template <typename J>*/
	/*	static void to_json(J& j, const std::shared_ptr<T>& opt) {*/
	/*		if (opt) {*/
	/*			j = *opt;*/
	/*		} else {*/
	/*			j = nullptr;*/
	/*		}*/
	/*	}*/
	/**/
	/*	template <typename J>*/
	/*	static void from_json(const J& j, std::shared_ptr<T>& opt) {*/
	/*		if (j.is_null()) {*/
	/*			opt = nullptr;*/
	/*		} else {*/
	/*			opt.reset(new T(j.template get<T>()));*/
	/*		}*/
	/*	}*/
	/*};*/
}

namespace VISEQ::GRAPH::EDGES {
	using namespace VISEQ::GRAPH::NODES;

	inline void to_json(json& j, const VISEQ::GRAPH::EDGES::Edge& E){
		j = json{{"id",E.id}, {"start", E.start.lock()->id}, {"end",E.end.lock()->id}, {"pass_forward",E.pass_forward}, {"pass_backward", E.pass_backward}}; 
	}
	
	inline void from_json(const json& j, Edge& E){
		j.at("id").get_to(E.id);
		j.at("pass_forward").get_to(E.pass_forward);
		j.at("pass_backward").get_to(E.pass_backward);
	}

	inline void to_json(json& j, const VISEQ::GRAPH::EDGES::SPTR_Edge& E){
		j = *E; 
	}

	inline void from_json(const json& j, VISEQ::GRAPH::EDGES::SPTR_Edge& E){
		E.reset(new Edge(j.get<Edge>()));
	}
}

namespace VISEQ::GRAPH::NODES {
	
	/* ------------------- MIDINODE ---------------------- */
	
	/*inline void to_json(json& j, const std::shared_ptr<MidiNode>& N){*/
	/*	j = *N;*/
	/*}*/
	/**/
	/*inline void from_json(const json& j, std::shared_ptr<MidiNode>& N){*/
	/*	N.reset(new MidiNode(j.get<MidiNode>()));*/
	/*}*/
	
	inline void to_json(json& j, const MidiNode::NodeMidiOut& MO){
		j = json{{"port_id", MO.i}, {"enabled", MO.enabled}, {"name", MO.name}};
	}

	/*template< typename T>*/
	/*inline void to_json(json& j, const std::shared_ptr<NodeHandle<T>>& NH){*/
	/*	j = json{{"position", NH->position}};*/
	/*}*/
	/* ----------------- CONFIG NODE -----------------*/


	/*inline void to_json(json& j, const std::shared_ptr<ConfigNode>& N){*/
	/*	j = *N;*/
	/*}*/
	/**/
	/*inline void from_json(const json& j, std::shared_ptr<ConfigNode>& N){*/
	/*	N.reset(new ConfigNode(j.get<ConfigNode>()));*/
	/*}*/
	
	/* ------------------- NODE ---------------------- */


	inline void to_json(json& j, const Node& N){
		if(N.getNodeType() == NodeType::MIDINODE){
			j = dynamic_cast<const MidiNode&>(N);
		}
		if(N.getNodeType() == NodeType::CONFIGNODE){
			j = dynamic_cast<const ConfigNode&>(N);
		}
	}
	
	inline void from_json(const json& j, Node& N){

		if(j.at("nodeType") == NodeType::MIDINODE){
			N = j.template get<MidiNode>();
		}
		if(j.at("nodeType") == NodeType::CONFIGNODE){
			N = j.template get<ConfigNode>();
		}
	}

	inline void to_json(json& j, const SPTR_Node& N){
		j = *N;
	}

	inline void from_json(const json& j, std::shared_ptr<Node>& N){
		std::cout << "SPTR_Node" << std::endl;
		if(N->getNodeType() == NodeType::MIDINODE){
			N.reset(new MidiNode(j.get<MidiNode>()));	
		}
		if(N->getNodeType() == NodeType::CONFIGNODE){
			N.reset(new ConfigNode(j.get<ConfigNode>()));	
		}
	}

}


namespace VISEQ::GRAPH {
	inline void to_json(json& j, const GraphItem& G){
		std::cout << "Movable" << std::endl;
		j = json{{"id", G.id}, {"type", G.gItemType}};
	}

	inline void to_json(json& j, const SPTR_GraphItem& G){
		j = *G; 
	}
}

namespace VISEQ::BASE{
	inline void to_json(json& j, const Movable& G){
		std::cout << "Movable" << std::endl;
		j = json{{"position", G.position}};
	}

	inline void to_json(json& j, const std::shared_ptr<Movable>& G){
		j = *G; 
	}
	
	inline void from_json(const json& j, Movable& G){
		std::cout << "Movable" << std::endl;
		j.at("position").get_to<Vec2Df>(G.position);
	}

	inline void from_json(json& j, const std::shared_ptr<Movable>& G){
		j = *G; 
	}
}

namespace VISEQ::SIGNAL{
	inline void to_json(json& j, const Signal& G){
		std::map<std::string, int> fc = {{"r",G.color.r},{"g",G.color.g},{"b",G.color.b},{"a",G.color.a}};
		j = json{{"color",fc},{"position", G.position},{"radius",G.radius},{"start",G.start.lock()->id},{"next",G.next.lock()->id},{"last",G.last.lock()->id},{"speed",G.speed},{"midi_note_offset",G.midi_note_offset},{"midi_cc_offset",G.midi_cc_offset},{"multiplier",G.multiplier}};
	}
	
	inline void from_json(const json& j, Signal& S){

		Color c;
		c.r = j.at("color")["r"].get<int>();
		c.g = j.at("color")["g"].get<int>();
		c.b = j.at("color")["b"].get<int>();
		c.a = j.at("color")["a"].get<int>();

		j.at("position").get_to<Vec2Df>(S.position);
		j.at("speed").get_to<float>(S.speed);
		j.at("radius").get_to<float>(S.radius);
		j.at("midi_note_offset").get_to(S.midi_note_offset);
		j.at("midi_cc_offset").get_to(S.midi_cc_offset);

		S.color = c;
	}

	inline void to_json(json& j, const std::shared_ptr<Signal>& G){
		j = *G; 
	}

	inline void from_json(const json& j, std::shared_ptr<Signal>& S){
		S.reset(new Signal(j.get<Signal>()));
	}
}