#include "rotor.h"

//float equality
bool fequal(const float u,const float v){
	if (abs(u-v)<.001) return true;
	else return false;
};
	

using namespace Rotor;

/*
    string soname="qm-vamp-plugins";
    string id="qm-tempotracker";
	string myname="";
	string output="";
	int outputNo=0;
	*/
	
void Render_context::runTask() {
	while (!isCancelled()) {
		int cmd=0;
		mutex.lock();
		if (work_queue.size()){
			cmd=work_queue[0];
			work_queue.pop_front();
		}
		mutex.unlock();
		if (cmd==ANALYSE_AUDIO) {
			state=ANALYSING_AUDIO;
			audio_analyser.process(audio_filename);
			//vampHost::runPlugin("","qm-vamp-plugins","qm-tempotracker", "",0, audio_filename, cerr,true);
			state=AUDIO_READY;
		}
		sleep(100);
	}
	printf("Rotor: stopping thread\n");
}
void Render_context::add_queue(int item) {
	mutex.lock();
	work_queue.push_back(item);
	mutex.unlock();
}

bool Signal_input::connect(Node* source) {
	if (source->output_type=="signal") {
		connection=source;
		return true;
	}
	else return false;
};

bool Signal_output::render(const float duration, const float framerate,string &xml_out){
	cerr << "Rotor: Signal_output rendering " << duration << " seconds at " << framerate << " frames per second" << endl;
	float step=1.0f/framerate;
	float v=0.0f;
	for (float f=0.0f;f<duration;f+=step) {
		float u=get_output(f);
		cerr << "Rotor: Signal_output got " << u << "as output" << endl;
		if (!fequal(u,v)) {
			xml_out+=("<signal time='"+ofToString(f)+"'>"+ofToString(u)+"</signal>\n");
			v=u;
		}
	}
	return true;
}

Command_response Render_context::session_command(const std::vector<std::string>& command){
										//method,id,command1,{command2,}{body}
										//here we allow the controlling server to communicate with running tasks
	Command_response response;
	response.status=HTTPResponse::HTTP_BAD_REQUEST;
	if (command[2]=="audio") {
	    if (command[0]=="PUT") {                                    	//get audio file location and initiate analysis
		if (command.size()>2) {
		    if (state==IDLE) {
												//check file exists
			Poco::File f=Poco::File(command[3]);
			//std::auto_ptr<std::istream> pStr(URIStreamOpener::defaultOpener().open(command[3]));
			
			
			if (f.exists()) {
												//pass to worker thread ??if engine is ready?? ??what if engine has finished but results aren't read??
			    audio_filename=command[3]; 			//for now, store session variables in memory
			    add_queue(ANALYSE_AUDIO);
			    response.description="<status context='"+command[1]+"'>Starting audio analysis: "+command[3]+"</status>\n";
			}
			else {
			    response.status=HTTPResponse::HTTP_NOT_FOUND;
			    response.description="<status context='"+command[1]+"'>File "+command[3]+" not found</status>\n";
			}
			
		    }
		    else {
			response.status=HTTPResponse::HTTP_BAD_REQUEST;
			response.description="<status context='"+command[1]+"'>Rotor: session busy</status>\n";
		    }
		}
	    }
	     if (command[0]=="GET") {
		     if (state==ANALYSING_AUDIO) {
			     response.status=HTTPResponse::HTTP_OK;
			     response.description="<status context='"+command[1]+"'>Rotor: analysing audio</status>\n";
			     char c[20];
			     sprintf(c,"%02f",audio_analyser.get_progress());
			     response.description+="<progress>"+string(c)+"</progress>\n";
		     }
		     if (state==AUDIO_READY) {
			     //not sure about this-- should this state be retained?
			     //can the data  only be read once?
			     //for now
			     response.status=HTTPResponse::HTTP_OK;
			     response.description="<status context='"+command[1]+"'>Rotor: audio ready</status>\n";
			      response.description+="<beats>";
			     for (auto& i: audio_analyser.beats) { //is actually giving no data?
				     char c[20];
				     sprintf(c,"%02f",i);
				     response.description+="<beat>"+string(c)+"</beat>";
				}     
			      response.description+="\n</beats>";
			     state=IDLE;
		     }
	     }
	     if (command[0]=="DELETE") {
		     //for now
			audio_filename="";
			response.description="<status>1</status>\n";
			response.status=HTTPResponse::HTTP_OK;
	     }
	}
	if (command[2]=="graph") {
		if (command[0]=="GET") {
			if (xml.bDocLoaded) {
				response.status=HTTPResponse::HTTP_OK;
				xml.copyXmlToString(response.description);
			}
			else {
				response.description="<status>Rotor: graph not loaded</status>\n";
			}
		}
		if (command[0]=="PUT") {                                    	//get new graph from file
			if (command.size()>2) {
												//should interrupt whatever is happening?
												//before begining to load from xml
				if (state==IDLE) {					//eventually not like this
					Poco::File f=Poco::File(command[3]);
					if (f.exists()) {
						string graph_filename=command[3]; 
						if (load_graph(graph_filename)) {
							response.status=HTTPResponse::HTTP_OK;
							//response.description="<status context='"+command[1]+"'>Rotor: loaded graph "+command[3]+"</status>\n";
							string xmlstring;
							xml.copyXmlToString(xmlstring);
							response.description=xmlstring;
							//the graph could actually contain an xml object and we could just print it here?
							//or could our nodes even be subclassed from xml nodes?
						}
						else {
							response.status=HTTPResponse::HTTP_INTERNAL_SERVER_ERROR; //~/sources/poco-1.4.6-all/Net/include/Poco/Net/HTTPResponse.h
							response.description="<status context='"+command[1]+"'>Rotor: could not load graph "+command[3]+"</status>\n";
						}
					}
					else {
					    response.status=HTTPResponse::HTTP_NOT_FOUND;
					    response.description="<status context='"+command[1]+"'>File "+command[3]+" not found</status>\n";
					}
				}
			}
		}
		if (command[0]=="DELETE") {
			 //for now
			graph=Graph();
			response.description="<status>1</status>\n";
			response.status=HTTPResponse::HTTP_OK;
		}
	}
	if (command[2]=="signal") {
		if (command[0]=="GET") {                                    	//generate xml from 1st signal output
			if (state==IDLE) {
				//direct call for testing
					float framerate=0.0f;
					if (command.size()>2) {
						framerate=ofToFloat(command[3]);
					}
					string signal_xml;
					if (graph.signal_render(framerate,signal_xml)){
						response.status=HTTPResponse::HTTP_OK;
						response.description=signal_xml;
					}
					else {
						response.status=HTTPResponse::HTTP_INTERNAL_SERVER_ERROR;
						response.description="<status context='"+command[1]+"'>Rotor: could not render output signal</status>\n";
					}
				}
				else {
					response.status=HTTPResponse::HTTP_NOT_FOUND;
					response.description="<status context='"+command[1]+"'>Signal output not found</status>\n";
				}
			}
			else {
				response.status=HTTPResponse::HTTP_SERVICE_UNAVAILABLE;
				response.description="<status context='"+command[1]+"'>Rotor: context busy</status>\n";
			}
		}
	if (command[2]=="video") {
		if (command[0]=="GET") {
													//DUMMY RESPONSE
			response.status=HTTPResponse::HTTP_OK;
			response.description="<status context='"+command[1]+"'>DUMMY RESPONSE Rotor: analysing video</status>\n";
			response.description+="<progress>45.2</progress>\n";
		}
		if (command[0]=="PUT") {                                    		//get vide file location and initiate analysis
			if (command.size()>2) {
			    if (state==IDLE) {
													//check file exists
				Poco::File f=Poco::File(command[3]);
				if (f.exists()) {
													//pass to worker thread ??if engine is ready?? ??what if engine has finished but results aren't read??
													//DUMMY RESPONSE
					response.description="<status context='"+command[1]+"'>DUMMY RESPONSE Starting video analysis: "+command[3]+"</status>\n";
				}
				else {
				    response.status=HTTPResponse::HTTP_NOT_FOUND;
				    response.description="<status context='"+command[1]+"'>File "+command[3]+" not found</status>\n";
				}
			    }
			    else {
				response.status=HTTPResponse::HTTP_BAD_REQUEST;
				response.description="<status context='"+command[1]+"'>Rotor: session busy</status>\n";
			    }
			}
		}
		if (command[0]=="DELETE") {
		     //DUMMY RESPONSE
			response.description="<status>DUMMY RESPONSE 1</status>\n";
			response.status=HTTPResponse::HTTP_OK;
	     }
		
	}
	if (command[2]=="render") {
		if (command[0]=="GET") {
													//DUMMY RESPONSE
			response.status=HTTPResponse::HTTP_OK;
			response.description="<status context='"+command[1]+"'>DUMMY RESPONSE Rotor: rendering video</status>\n";
			response.description+="<progress>25.2</progress>\n";
		}
		if (command[0]=="PUT") {
													//DUMMY RESPONSE
													//SHOULD CHECK REQUIREMENTS
			response.status=HTTPResponse::HTTP_OK;
			response.description="<status context='"+command[1]+"'>DUMMY RESPONSE Rotor: starting render</status>\n";
		}
		if (command[0]=="DELETE") {
													//DUMMY RESPONSE
													//SHOULD CHECK REQUIREMENTS
			response.status=HTTPResponse::HTTP_OK;
			response.description="<status context='"+command[1]+"'>DUMMY RESPONSE Rotor: cancelling render</status>\n";
		}
	}
	return response;
}

//how to do this?
//aim - load nodes from xml
//easily maintain the xml tree
//be able to save it or print it
//--if the list of nodes is a flat vector - don't need to store ID with the node - just refer to the index # of the node while loading?
//--if instead it refers to the index# in the unordered map - can handle deletion etc - have to check if a node exists when linking
//--also can a node link to one 'later' ? it may have to? in which case there's a 2 step process - 1 load the nodes - 2 link them
//maybe 


// a generic way to create a named node- each node is an object- will be loadable from .so
// eventually need to figure out to load .sos and enumerate classes
// in the short term either 
// - hand logic that recognises nodes and creates inputs etc
// - not sure how else?

//its a factory?
//http://stackoverflow.com/questions/4007382/how-to-create-class-objects-dynamically
//http://www.codeproject.com/Articles/3734/Different-ways-of-implementing-factories
//http://stackoverflow.com/questions/13292856/create-derived-class-in-base-class-based-on-parameter
//http://en.wikipedia.org/wiki/Factory_method_pattern

//what is a good way to pass parameters to objects?
//get all attributes of node and pass them as creation parameters?
//could just pass them all as strings, let the object choose what to do itself?
//YES

bool Render_context::load_graph(string filename){
	printf("loading %s\n",filename.c_str());
	if(xml.loadFile(filename) ){
		graph=Graph(xml.getAttribute("patchbay","ID","",0),xml.getValue("patchbay","",0));
		if(xml.pushTag("patchbay")) {
			int n1=xml.getNumTags("node");
			for (int i1=0;i1<n1;i1++){
				map<string,string> settings;
				vector<string> attrs;
				xml.getAttributeNames("node",attrs,i1);
				for (auto& attr: attrs) {
					settings[attr]=xml.getAttribute("node",attr,"",i1);
					//cerr << "Got attribute: " << attr << ":" << xml.getAttribute("node",attr,"",i1) << endl;
				}
				settings["description"]=xml.getValue("node","",i1);
				Node* node=factory.create(settings);
				if (node) {
					cerr << "Rotor: created '" << xml.getAttribute("node","type","",i1) << "'" << endl;
					string nodeID=xml.getAttribute("node","ID","",i1);
					graph.nodes[nodeID]=node;
					if(xml.pushTag("node",i1)) {
						int n2=xml.getNumTags("signal_input");
						for (int i2=0;i2<n2;i2++){
							graph.nodes[nodeID]->create_signal_input(xml.getValue("signal_input","",i2));
							string fromID=xml.getAttribute("signal_input","from","",i2);
							if (graph.nodes.find(fromID)!=graph.nodes.end()) {
								if (!graph.nodes[nodeID]->inputs[i2]->connect(graph.nodes[fromID])){
									cerr << "Rotor: graph loader cannot connect input " << i2 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									return false;
								}
								else cerr << "Rotor: linked input " << i2 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
							}
							else cerr << "Rotor: linking input " << i2 << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;							
						}
						xml.popTag();
					}
				}
				else {
					cerr << "Rotor: graph loader cannot find node '" << xml.getAttribute("node","type","",i1) << "'" << endl;
					return false;
				}
			}
			xml.popTag();
		}
		/*
		model_name=XML.getAttribute("map4","model","none",0);
		model_x=ofToFloat(XML.getAttribute("map4","x","none",0));
		model_y=ofToFloat(XML.getAttribute("map4","y","none",0));
		model_z=ofToFloat(XML.getAttribute("map4","z","none",0));
		if(XML.pushTag("map4")) {
		numViews=XML.getNumTags("view");
		if(numViews) {
		views=new viewpoint[numViews];
		for (int i=0;i<numViews;i++){
		    XML.pushTag("view",i);
			vector<string>keys;
			XML.getAttributeNames("settings", keys, 0);
			map<string,string>settings;
			for (int k=0;k<keys.size();k++) {
			    settings[keys[k]]=XML.getAttribute("settings",keys[k],"none",0);
			}
			views[i].setup(settings);
		    XML.popTag();
		}
		}

		numClips=XML.getNumTags("clip");
		if (numClips) {
		clips=new string[numClips];
		for (int i=0;i< numClips;i++) {
		    XML.pushTag("clip",i);
			clips[i]=XML.getAttribute("settings","file","none",0);
		    XML.popTag();
		}
		}

		XML.popTag();
		for (int i=0;i< numClips;i++) {
		printf("clip: %s\n",clips[i].c_str());
		}
		}
		*/
		return true;
	}
	else return false;
}

Node_factory::Node_factory(){
	//for now, statically load prototype map in constructor
	add_type("audio_analysis",new Audio_analysis());
	add_type("==",new Is_new_integer());
	add_type("signal_output",new Signal_output());
}