viseq/src/state-manager.h

#pragma once

#include "edge.h"
#include "datatypes.h"
#include "graph-manager.h"
#include "midi-node.h"
#include "signal-manager.h"
#include "ui.h"

#include <algorithm>
#include <iterator>
#include <memory>
#include <ranges>
#include <vector>

class AppState{
	public:

		AppState() : sm(&gm, &mutex), ui(&settings, &sm, &gm) {}

		enum States {IDLE, CONFIG};
		
		AppSettings settings;

		States state;

		std::mutex mutex;

		GraphManager gm;
		SignalManager sm;

		AppUI ui;

		void updateMidiPorts(){
			for(auto&n : gm.nodes | RANGE_FILTER([](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 copyNodesAndConnections(VEC_SPTR_Node nodes, Vec2Df position){

			VEC_SPTR_Edge copy_connections;
			for(auto n : nodes){
				for(auto c : n->connections){
					if(std::ranges::contains(nodes, c->start) && std::ranges::contains(nodes, c->end)) {
						copy_connections.push_back(std::make_shared<Edge>(*c));
					}
				}
			}
			std::cout << copy_connections.size() << std::endl;

			for(auto old_node : nodes){
				SPTR_Node new_node;

				if(old_node->getNodeType() == NodeType::MIDINODE) {
					new_node = gm.copyNode(std::dynamic_pointer_cast<MidiNode>(old_node), position + old_node->drag_offset);
				} else {
					new_node = gm.copyNode(old_node, position + old_node->drag_offset);
				}

				new_node->copied = false;
				new_node->selected = false;

				for(auto c : copy_connections){
					if(c->start == old_node) {
						c->start = new_node;
						c->start->connections.push_back(c);
					}
					if(c->end == old_node) {
						c->end = new_node;
						c->end->connections.push_back(c);
					}
				}
			}
			std::ranges::copy(copy_connections.begin(), copy_connections.end(), std::back_inserter(gm.edges));
		}

		void removeNodes(VEC_SPTR_Node nodes){

			for(auto n : gm.nodes){
				n->highlighted = false;
			}

			auto erase_connections = gm.edges | RANGE_FILTER([nodes](SPTR_Edge c){ return std::ranges::contains(nodes, c->start) || std::ranges::contains(nodes, c->end);});

			VEC_SPTR_Node adjacent_nodes;

			for(auto c : erase_connections){
				if(!c->start->selected) adjacent_nodes.push_back(c->start);
				if(!c->end->selected) adjacent_nodes.push_back(c->end);
			}

			auto reroute_signals = sm.signals | RANGE_FILTER([nodes](SPTR_Signal s){return std::ranges::contains(nodes, s->next);});

			for(auto s : reroute_signals){
				float dist = 10000000;
				SPTR_Node next_node;
				for(auto n : adjacent_nodes){
					if(n->position.dist(s->position) < dist) {
						dist = n->position.dist(s->position);
						next_node = n;
					}
				}
				s->next = next_node;
				s->last = next_node;
			}
			
			auto rebase_signals = sm.signals | RANGE_FILTER([nodes](SPTR_Signal s){return std::ranges::contains(nodes, s->start);});
			
			for(auto s : rebase_signals){
				s->start = s->next;
			}

			for(auto n : adjacent_nodes){
				std::erase_if(n->connections, [n, nodes](SPTR_Edge c){ return std::ranges::contains(nodes, c->start) || std::ranges::contains(nodes, c->end);});
			}
			
			for(auto n : nodes){
				std::erase_if(gm.edges, [n](SPTR_Edge c){ return c->start == n || c->end == n;});
			}
			std::erase_if(gm.nodes, [nodes](SPTR_Node n){ return std::ranges::contains(nodes, n);});
		}
		
		void draw(Vec2Df mouse_pos, Camera2D camera){
			mutex.lock();
			updateMidiPorts();
			mutex.unlock();
			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();
		}
};