#ifndef ROTOR_MATHS
#define ROTOR_MATHS

#include "rotor.h"
#include <libnoise/noise.h>
#include <libnoise/mathconsts.h>
#include "Poco/Logger.h"

namespace Rotor {
#define COMPARISON_Equal 1
#define COMPARISON_Not_equal 2
#define COMPARISON_Greater 3
#define COMPARISON_Less 4
#define COMPARISON_Greater_or_equal 5
#define COMPARISON_Less_or_equal 6
	class Comparison: public Signal_node {
		public:
			Comparison(){
				create_signal_input("signal","Signal");
				create_parameter("value","number","Value or signal for operation","Value",0.0f);
				create_attribute("operator","Operator for comparison","operator","==",{"==","!=",">","<",">=","<="});
				description="Compares the signal with a value or signal according to the operator";
			};
			Comparison(map<string,string> &settings):Comparison() {
				base_settings(settings);
			}
			Comparison* clone(map<string,string> &_settings) { return new Comparison(_settings);};
			const float output(const Time_spec &time) {	
                switch (attributes["operator"]->intVal) {
                	case COMPARISON_Equal:
                		return fequal(parameters["value"]->value,inputs[0]->get(time))?1.0f:0.0f;
                		break;
					case COMPARISON_Not_equal:
						return fequal(parameters["value"]->value,inputs[0]->get(time))?0.0f:1.0f;
                		break;
					case COMPARISON_Greater:
						return fgreater(parameters["value"]->value,inputs[0]->get(time))?1.0f:0.0f;
                		break;
					case COMPARISON_Less:
						return fless(parameters["value"]->value,inputs[0]->get(time))?1.0f:0.0f;
                		break;
					case COMPARISON_Greater_or_equal:
						return fgreater_or_equal(parameters["value"]->value,inputs[0]->get(time))?1.0f:0.0f;
                		break;
					case COMPARISON_Less_or_equal:
						return fless_or_equal(parameters["value"]->value,inputs[0]->get(time))?1.0f:0.0f;
                		break;
                }
                
				return 0.0f;
			}
	};
#define ARITHMETIC_plus 1
#define ARITHMETIC_minus 2
#define ARITHMETIC_multiply 3
#define ARITHMETIC_divide 4
#define ARITHMETIC_modulo 5
#define ARITHMETIC_pow 6
#define ARITHMETIC_sin 7
#define ARITHMETIC_cos 8
#define ARITHMETIC_ease 9
#define ARITHMETIC_jolt 10
	class Arithmetic: public Signal_node {
		public:
			Arithmetic(){
				create_signal_input("signal","Signal");
				create_parameter("value","number","Value or signal for operation","Value",1.0f);
				create_attribute("operator","operator for image","Operator","+",{"+","-","*","/","%","^","sin","cos","ease","jolt"});
				title="Arithmetic";
				description="Performs arithmetic on a signal with a signal or value";
			};
			Arithmetic(map<string,string> &settings):Arithmetic() {
				base_settings(settings);
			};
			Arithmetic* clone(map<string,string> &_settings) { return new Arithmetic(_settings);};
			const float output(const Time_spec &time) {
				if (attributes["operator"]->intVal==ARITHMETIC_divide||attributes["operator"]->intVal==ARITHMETIC_modulo){
					if (value==0.0f) {
						Poco::Logger& logger = Poco::Logger::get("Rotor");
						logger.error("Arithmetic node: caught division by zero, frame "+time.frame());
						return 0.0f;
					}
				}
				if (inputs.size()) { //there should there be a way to specify number of inputs in the code rather than in xml
                    if (inputs[0]->connection) {
                        float in= inputs[0]->get(time);
                        switch (attributes["operator"]->intVal) {
                        	case ARITHMETIC_plus:
                        		return in+parameters["value"]->value;
                        		break;
							case ARITHMETIC_minus:
								return in-parameters["value"]->value;
                        		break;
							case ARITHMETIC_multiply:
								return in*parameters["value"]->value;
                        		break;
							case ARITHMETIC_divide:
								return in/parameters["value"]->value;
                        		break;
							case ARITHMETIC_modulo:
								return fmod(in,parameters["value"]->value);
                        		break;
                        	case ARITHMETIC_pow:
								return pow(in,parameters["value"]->value);
                        		break;
                        	case ARITHMETIC_sin:
								return sin(in)*parameters["value"]->value;
                        		break;
                        	case ARITHMETIC_cos:
								return cos(in)*parameters["value"]->value;
                        		break;
                        	case ARITHMETIC_ease:
								return ((1.0-parameters["value"]->value)*in)+(parameters["value"]->value*(0.5f+((cos((fmod(in,1.0f)+1.0f)*M_PI))*0.5f)));
                        		break;
                        	case ARITHMETIC_jolt:
								return ((1.0-parameters["value"]->value)*in)+(parameters["value"]->value*(0.5f+((sin((fmod(in,1.0f)+1.0f)*M_PI))*0.5f)));
                        		break;
                        }
                    }
			    }
				return 0.0f;
			}
			int op;
			float value;
	};
	class Is_new_integer: public Signal_node {
		public:
			Is_new_integer(){
				title="New integer";
				description="Outputs 1 on the frame that a signal becomes a new integer";
				create_signal_input("signal","Signal");
			};
			Is_new_integer(map<string,string> &settings):Is_new_integer() {
				base_settings(settings);
			};
			Is_new_integer* clone(map<string,string> &_settings) { return new Is_new_integer(_settings);};
			const float output(const Time_spec &time) {
				if (((int)inputs[0]->get(time))>((int)inputs[0]->get(time.lastframe()))) {
					return 1.0f;
				}
				return 0.0f;
			}
	};
	class On_off: public Signal_node {
		public:
			On_off(){
				title="On off";
				description="Outputs 1 if the integer floor of the signal is even";
				create_signal_input("signal","Signal");
			};
			On_off(map<string,string> &settings):On_off() {
				base_settings(settings);
			};
			On_off* clone(map<string,string> &_settings) { return new On_off(_settings);};
			const float output(const Time_spec &time) {
				if (inputs[0]->connection) {
					float s1=(((Signal_node*)(inputs[0]->connection))->get_output(time));
					if ((int)s1%2) return 1.0f;
				}
				return 0.0f;
			}
	};
	//pseudo random hash function
	//http://create.stephan-brumme.com/fnv-hash/
	const uint32_t Prime = 0x01000193; //   16777619
	const uint32_t Seed  = 0x811C9DC5; // 2166136261
	/// hash a byte
	inline uint32_t fnv1a(unsigned char oneByte, uint32_t hash = Seed)
	{
	  return (oneByte ^ hash) * Prime;
	}
	/// hash a short (two bytes)
	inline uint32_t fnv1a(unsigned short twoBytes, uint32_t hash = Seed)
	{
	  const unsigned char* ptr = (const unsigned char*) &twoBytes;
	  hash = fnv1a(*ptr++, hash);
	  return fnv1a(*ptr  , hash);
	}
	/// hash a 32 bit integer (four bytes)
	inline uint32_t fnv1a(uint32_t fourBytes, uint32_t hash = Seed)
	{
	  const unsigned char* ptr = (const unsigned char*) &fourBytes;
	  hash = fnv1a(*ptr++, hash);
	  hash = fnv1a(*ptr++, hash);
	  hash = fnv1a(*ptr++, hash);
	  return fnv1a(*ptr  , hash);
	}
	class Random: public Signal_node {
		public:
			Random(){
				title="Random";
				description="Randomises integer part of signal (seedable)";
				create_signal_input("signal","Signal");
				create_parameter("seed","number","Seed value","Seed",1.0f);
			};
			Random(map<string,string> &settings) {
				base_settings(settings);
			};
			Random* clone(map<string,string> &_settings) { return new Random(_settings);};
			const float output(const Time_spec &time) {
				uint32_t seed=Seed+parameters["seed"]->value;
            	//hash the integer part and add the fractional part back on
            	float o=inputs[0]->get(time);
            	uint32_t m=(int)o;
                return ((float)(fnv1a(m,seed)%((uint32_t)time.duration)))+(o-m);
			}
	};
	class Noise: public Signal_node {
		//fractal noise
		public:
			Noise(){
				title="Noise";
				description="Fractal noise (seedable)";
				create_signal_input("signal","Signal");
				create_parameter("seed","number","Seed value","Seed",1.0f);
			};
			Noise(map<string,string> &settings) {
				base_settings(settings);
				seed=find_setting(settings,"seed",0);
			};
			Noise* clone(map<string,string> &_settings) { return new Noise(_settings);};
			const float output(const Time_spec &time) {
				uint32_t seed=Seed+parameters["seed"]->value;
            	//hash the integer part and add the fractional part back on
            	float o=inputs[0]->get(time);
            	uint32_t m=(int)o;
                return ((float)(fnv1a(m,seed)%((uint32_t)time.duration)))+(o-m);
			}
			uint32_t seed;
		private:
	};
}

#endif