viseq/src/app-manager.h

#pragma once

#include "clipboard.h"
#include "datatypes.h"
#include "graph-manager.h"
#include "midi-node.h"
#include "mouse.h"
#include "node.h"
#include "raylib.h"
#include "signal-manager.h"
#include "state.h"
#include "ui.h"

#include <memory>
#include <ranges>

namespace VISEQ::APP {

	class AppManager{
		public:
			
			AppManager() : sm(&gm, &mutex), mouse(&gm), ui(&sm, &gm) {}

			std::mutex mutex;

			VISEQ::GRAPH::GraphManager gm;
			VISEQ::SIGNAL::SignalManager sm;
			VISEQ::APP::Clipboard cb;
			VISEQ::APP::Mouse mouse;

			std::shared_ptr<APP::State> state = APP::State::get();

			UI::AppUI ui;

			void updateMidiPorts(){
				for(auto&n : gm.nodes | RANGE_FILTER([](VISEQ::GRAPH::NODES::SPTR_Node n){return n->getNodeType() == NodeType::MIDINODE;})){
					auto nc = std::dynamic_pointer_cast<MidiNode>(n);
					for(auto& mo : sm.midi.midi_out_ports){
						if(!nc->midi_outs.contains(mo.number) && mo.enabled){
							nc->midi_outs[mo.number] = {mo.number, mo.port.port_name, false};	
						}
						if(nc->midi_outs.contains(mo.number) && !mo.enabled){
							nc->midi_outs.erase(mo.number);
						}
					}
				}
			}

			void removeNodes(VEC_SPTR_Node nodes){

				VEC_SPTR_Node adjacent_nodes = gm.getAdjacentNodes(nodes);

				sm.rerouteSignal(nodes, adjacent_nodes);
				sm.rebaseSignal(nodes);

				gm.removeNodesAndEdges(nodes);
			}
			
			void doInteraction(){	
				while(event_queue.size() > 0){
					auto e = event_queue.front();
					std::cout << e.action << " " << e.item->z_index << std::endl;
					
					if(e.item->getType() == GraphItemType::NODE || e.item->getType() == GraphItemType::CONNECTOR) {
						switch(e.action){
							case VISEQ::APP::Interaction::PICKUP:
							{
								e.item->pickUp();
								break;
							}
							case VISEQ::APP::Interaction::DRAG:
							{
								e.item->drag();
								break;
							}
							case VISEQ::APP::Interaction::PUTDOWN:
							{
								e.item->putDown();
								break;
							}
						}	
					}

					event_queue.pop();
				}
			}

			void update(){
				mutex.lock();
				updateMidiPorts();
				mutex.unlock();
				doInteraction();
				mouse.update();

				if(KEYS_DOWN.ctrl && IsKeyPressed(KEY_C)){
					VEC_SPTR_Node selected_nodes = gm.getSelection();
					if(!selected_nodes.empty()) cb.pushNodes(selected_nodes);
				}

				if(KEYS_DOWN.ctrl && IsKeyPressed(KEY_V)){
					VEC_SPTR_Node paste_nodes = cb.pullNodes();
					if(!paste_nodes.empty()) gm.pasteNodesAndEdges(paste_nodes, MOD_MOUSE);
				}
			}

			void draw(Vec2Df mouse_pos, Camera2D camera){
				gm.drawNodes(mouse_pos, camera);
				gm.drawEdges(mouse_pos, camera);
				sm.drawSignals(mouse_pos, camera);
			}

			void drawUI(Vec2Df mouse_pos, Camera2D camera){
				mutex.lock();
				ui.draw(mouse_pos, camera);
				mutex.unlock();
			}
	};

	inline void to_json(json& j, const AppManager& A){
		j = json{{"graphmanager", A.gm}, {"signalmanager", A.sm}};
	}
	
	inline void from_json(const json& j, AppManager& A){
		j.at("graphmanager").get_to(A.gm); // = json{{"graphmanager", A.gm}, {"signalmanager", A.sm}};
	}
}