#ifndef ROTOR_NODES_SIGNALS
#define ROTOR_NODES_SIGNALS

#include "rotor.h"

namespace Rotor {
	class Time: public Signal_node {
		public:
			Time(){
				title="Time";
				description="Outputs the time in seconds as a signal";
				NODEID="432b0d1e-2d09-11e3-a8b9-e3affcfd2b31";
			};
			Time(map<string,string> &settings): Time() {
				base_settings(settings);
			};
			Time* clone(map<string,string> &_settings) { return new Time(_settings);};
			const double output(const Time_spec &time) {
				return time.time;
			}
	};
	class Track_time: public Signal_node {
		public:
			Track_time(){
				title="Track time";
				description="Outputs the fraction of the track as a signal";
				NODEID="5892933e-2d09-11e3-8f2e-47c1defdb1d7";
			};
			Track_time(map<string,string> &settings): Track_time() {
				base_settings(settings);
			};
			Track_time* clone(map<string,string> &_settings) { return new Track_time(_settings);};
			const double output(const Time_spec &time) {
				return time.time/time.duration;
			}
	};
	class At_track_time: public Signal_node {
		public:
			At_track_time(){
				create_signal_input("signal","Signal Input");
				create_parameter("time","number","Track time to evaluate","Time",0.0);
				title="@Track time";
				description="Gets input from a different point in the track";
				NODEID="6a3edb9c-2d09-11e3-975c-df9df6d19f0a";
			};
			At_track_time(map<string,string> &settings): At_track_time() {
				base_settings(settings);
			};
			At_track_time* clone(map<string,string> &_settings) { return new At_track_time(_settings);};
			const double output(const Time_spec &time) {
				Time_spec t=Time_spec(parameters["time"]->value*time.duration,time.framerate,time.duration);
				return inputs[0]->get(t);
			}
	};
	class Signal_output: public Signal_node {
		public:
			Signal_output(){
				create_signal_input("signal","Signal Input");
				title="Signal output";
				description="Outputs a signal to xml for testing";
				NODEID="74773190-2d09-11e3-ae26-7f2bb9af632c";
			};
			Signal_output(map<string,string> &settings): Signal_output() {
				base_settings(settings);
			};
			Signal_output* clone(map<string,string> &_settings) { return new Signal_output(_settings);};
			bool render(const double duration, const double framerate,string &xml_out){
				//lost this somewhere
				return true;
			}
			const double output(const Time_spec &time) {
					return inputs[0]->get(time);
			}
	};
	class Testcard: public Image_node {
		public:
			Testcard(){
				//internal testing node only
			};
			Testcard(map<string,string> &settings): Testcard() {
				base_settings(settings);
			};
			~Testcard(){};
			Testcard* clone(map<string,string> &_settings) { return new Testcard(_settings);};
			Image *output(const Frame_spec &frame){
				double hs=(255.0/frame.h);
				for (int i=0;i<frame.h;i++){
					for (int j=0;j<frame.w;j++){
						image.RGBdata[(i*frame.w+j)*3]=(uint8_t)((int)((i+(frame.time*25.0)*hs))%255);
						image.RGBdata[((i*frame.w+j)*3)+1]=(uint8_t)((int)((j+(frame.time*100.0)*hs))%255);
						image.RGBdata[((i*frame.w+j)*3)+2]=(uint8_t)(0);
						//image->Adata[i*frame.w+j]=(uint8_t)255;
						//image->Zdata[i*frame.w+j]=(uint16_t)512; //1.0 in fixed point 8.8 bits
					}
				}
				return &image;
			}
		private:

	};
}

#endif