/*
requirement driven design

do we store graphs as files or in a db with UUID as key?

do we traverse the graph as direct recursive function calls or programmatically from outside?
or keep a reference to the container graph in each node?

graph parent;
vector<signal_input> signal_inputs;
vector<image_input> image_inputs;

//in input
int input_id;


&image get_ouput()
{
	for (int i=0;i<inputs.size;i++){
		if (inputs[i].input_id) parent.nodes[input_id].get_output(); ///how to find the output in the node? uids for everything?
	}

	render();
	return &image_data;
}

OR

for (int i=0;i<inputs.size;i++){
	if (inputs[i].connection) inputs[i].connection->get_output(); ///methinks this is neater? you can check pointer for NULL, can't be ref
}

NO NODE HAS MORE THAN ONE OUTPUT
WE DON'T LINK TO AN OUTPUT OBJECT WE LINK TO THE NODE - GET_OUTPUT IS THE RENDER FUNCTION

settings - how do we deal with settings being controllable
signal inputs can have a gui representation as well
other gui items don't have an input

scaling to come

time is always in floating points seconds - time has to be requested when rendering - either a preview
what about testing a float for equality?
maybe we should look at time in int (frames) - - what does this imply
is it easier to have a function like:
bool Same_frame(float time1, float time2);

2 main questions
authentication - how
authentication to renderer or just session?
files - where
generated images & movies where?

nb where a signal enters a channel comp input - it is duplicated

next - Poco create thread

1st - create thread and return id - create method to kill it

sql stuff


messaging - http factory includes a poco notication center
when it creates the rotor session it registers it
session messages are posted thus and consumed

*/

#include <unordered_map>
#include <deque>

#include "Poco/UUID.h"
#include "Poco/UUIDGenerator.h"
#include "Poco/Notification.h"
#include "Poco/NotificationCenter.h"
#include "Poco/Observer.h"
#include "Poco/ThreadPool.h"
#include "Poco/Thread.h"
#include "Poco/Runnable.h"
#include "Poco/Mutex.h"
#include "Poco/Random.h"
#include "Poco/AutoPtr.h"
#include <iostream>

using Poco::UUID;
using Poco::UUIDGenerator;

#define ROTOR_READY 0
#define ROTOR_ANALYSING_AUDIO 1
#define ROTOR_CREATING_PREVIEW 2
#define ROTOR_RENDERING 3

namespace Rotor {

	//forward declaration
	class Node;

	class Render_status{
		public:
			int id;
			float progress;
	};
	class Render_requirements{
		public:
			int num_performances;
			int num_clips;
	};
	class Render_context: public Poco::Task {	                                //Poco task object
                                                                                //manages a 'patchbay'
                                                                                //high level interfaces for the wizard
                                                                                //and low level interface onto the graph
		public:
			Render_context(const std::string& name): Task(name) {
			};
			void runTask() {
				while (!isCancelled()) {
				    mutex.lock();
				    if (work_queue.size()){
				        std::string out=name()+": "+work_queue[0]+"\n";
				        printf(out.c_str());
                        work_queue.pop_front();
                    }
                    mutex.unlock();
				    sleep(100);
				}
				printf("Rotor: stopping thread\n");
			}
			void add_queue(std::string item) {
                mutex.lock();
                work_queue.push_back(item);
                mutex.unlock();
			}
			Render_status get_status();
			void cancel();							                            //interrupt locking process
			int make_preview(int nodeID, float time); 	                        //starts a frame preview - returns status code -  how to retrieve?
			int load_graph(Poco::UUID uid);
			UUID save_graph();						                            //returns UUID of saved graph
			int load_audio(string filename);
			Render_requirements get_requirements();
			int load_video(int num,string filename);		                    //can be performance or clip

		private:
			int status;
			float progress;							                            //for a locking process: audio analysis or rendering
			std::deque<std::string> work_queue;

            Poco::Mutex mutex;                                                  //access to notification queue
	};
	class Input{
		public:
			Node* connection;

	};
	class Image_input: public Input{
		public:

	};
	class Signal_input: public Input{
		public:

	};
	class Node{
		public:
			UUID uid;								//every usable node has a UUID
			int id;
			vector<Signal_input> inputs;				//simple node has signal inputs and outputs
			void get_output(float time);
			void gather_inputs(float time) {
				for (uint i=0;i<inputs.size();i++){
					if (inputs[i].connection) inputs[i].connection->get_output(time);
				}
			}
	};
	class Image{
		char* data;
	};
	class Image_node: public Node{
		public:
			vector<Image_input> image_inputs;		//image node also has image inputs and outputs
			void gather_inputs(float time) {
				Node::gather_inputs(time);
				for (uint i=0;i<image_inputs.size();i++){
					if (image_inputs[i].connection) image_inputs[i].connection->get_output(time);
				}
			}
			Image* get_output(float time){			//sample implementation
				gather_inputs(time);
				//do something with the inputs

				//and then
				return ((Image_node*)image_inputs[0].connection)->image;
			}
			void get_preview(float time);
			Image* image; 						//this can be privately allocated or just passed on as the node see fit
		private:
			float image_time;
	};
	class Graph{
		public:
			UUID uid;								//every version of a graph has a UUID
		private:
			std::unordered_map<int,Node> nodes;
	};
}

/*
coding style
Types begin with a capital, use underscore as a seperator
*/