#pragma once

#include "ofMain.h"
#include "ofxGui.h"
#include "ofxSVG.h"
#include "ofxClipper.h"
#include "ofxPONK.h"
#include "lineTransformer.h"
#include "lineSegmenter.h"
#include "lineClipper.h"
#include "vectorText.h"

static ofVec2f DISPLAYSIZE(200,200);

class vectorPanel {
	public:
		vectorPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5))
			{
			size=_size;
			position=_pos;
			panel.setup(_title,"",_pos.x,_pos.y+size.y+5);
	
			
			float f1=-1.0;
			float f2=1.0;

			frame.addVertex(f1,f1);
			frame.addVertex(f2,f1);
			frame.addVertex(f2,f2);
			frame.addVertex(f1,f2);
			frame.close();

		}
		void draw(){	
			panel.draw();
			ofPushMatrix();
			ofTranslate(position);
			ofSetColor(255);
			ofNoFill();
			ofDrawRectangle(0,0,size.x,size.y);
			ofPushMatrix();
			ofTranslate(size/2);
			ofScale(DISPLAYSIZE.x/2.0f);
			vector<colourPolyline> lines=clipOutput();
			for (auto& line:lines){
				line.draw();
			}
			ofPopMatrix();
			ofPopMatrix();
		}
		vector<colourPolyline> clipOutput() {
			//ofLog()<<"frame has "<<frame.size()<<" paths";
			return lineClipper::clip(getOutput(),frame);
		};
		virtual vector<colourPolyline> getOutput()=0;
		//vector<colourPolyline> getOutput(){return getLines();}
		virtual vector<colourPolyline> getLines()=0;
		virtual void update()=0;

	protected:
		ofVec2f size;
		ofPoint position;
		ofxPanel panel;
		ofPolyline frame;
};

class defaultPanel: public vectorPanel{
	//the minimum panel that can be instanced
	public:
		defaultPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5)
			) : vectorPanel(_title,_size,_pos){}
		vector<colourPolyline> getOutput(){
			return getLines();
		}
		vector<colourPolyline> getLines(){
			vector<colourPolyline> output;
			return output;
		}
		void update(){};
};

class transformPanel: public vectorPanel{
	//a base class which supports transformation
	public:
		transformPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5)
			) : vectorPanel(_title,_size,_pos){
			origin=ofPoint(0,0);
			rotation=0;
			scale_time=0;
			panel.add(transform.set("transform",false));
			panel.add(use_rotate.set("rotate enable",false));
			panel.add(rotation_delta.set("rotation",0.1,-2.0,2.0));
			panel.add(use_scale.set("scale enable",false));
			panel.add(scale_factor.set("scale factor",0.1,0.0,10.0));
			panel.add(scale_osc_freq.set("scale osc freq",0.1,0.01,2.0));
			panel.add(scale_osc_scale.set("scale osc scale",0.0,0.0,10.0));
			panel.add(randomise.setup("randomise"));
			randomise.addListener(this,&transformPanel::randomiseScale);
		}
		void randomiseScale(){
			scale_time=ofRandom(6.3f);
		}
		void update(){
			timedelta=ofGetElapsedTimef()-last_frame_time;
			last_frame_time=ofGetElapsedTimef();
			if (use_rotate) rotation+=rotation_delta*timedelta;
			if (use_scale) {
				scale_time+=timedelta*scale_osc_freq;
				scale=scale_factor+((sin(scale_time)+1.0)*scale_osc_scale);
			}
		};
		vector<colourPolyline> getOutput(){
			vector<colourPolyline> lines=getLines();
			if (transform){
				ofMatrix4x4 rm = ofMatrix4x4::newIdentityMatrix();
				rm.rotateRad(rotation,0,0,1);

				if(use_scale){
					rm.scale(scale,scale,scale);
				}
				
				//}
				//rm.translate(outputWindowSize.x/2,outputWindowSize.y/2,0);
				vector<colourPolyline> transformedLines;
				for (auto& line:lines){
					transformedLines.push_back(lineTransformer::polyLineTransform(rm,line));
				}
				return transformedLines;
			}
			return lines;
		};
	protected:
		ofPoint origin;
		float rotation;
		float scale;
		float scale_time;
		ofParameter<bool> transform;
		ofParameter<bool> use_rotate;
		ofParameter<float> rotation_delta;
		ofParameter<bool> use_scale;
		ofParameter<float> scale_factor;
		ofParameter<float> scale_osc_freq;
		ofParameter<float> scale_osc_scale;
		ofxButton randomise;
		float last_frame_time, timedelta;
};

/*
next- enable transform offsets
crop for display
transformers
easy midi
*/

class svgPanel: public transformPanel{
	public:
		svgPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5)
			) : transformPanel(_title,_size,_pos){
			panel.add(shapeslabel.setup("SHAPES",""));
			panel.add(colourise.set("colourise",false));
			panel.add(shapes_randomise.set("randomise",false));
			//panel.add(shapes_generate.setup("generate"));
			panel.add(shapes_amount.set("amount",0.2,0.0,1.0));
			panel.add(shapes_duration.set("duration",5.0,0,10.0));
			panel.add(segmenterlabel.setup("SEGMENTER",""));
			panel.add(use_segmenter.set("enable",false));
			panel.add(segmenter_speed.set("speed",0.2,-1.0,1.0));
			panel.add(segmenter_length.set("length",0.2,0.0,1.0));
			panel.add(segmenter_number.set("number",1,1,8));
		
			//shapes_generate.addListener(this,&svgPanel::generate_shapes);
		}
		void load(string filename);
		void select_random_shapes();
		void update_random_shapes(bool generate);
		vector<colourPolyline> getAllLines();
		vector<colourPolyline> getLines();
		void update(){
			transformPanel::update();
			phase=fmod(phase+(timedelta*segmenter_speed),1);
			while(phase<0) phase+=1.0f;
		}

	private:
		//ofxFloatSlider contour_simplify;

		ofxLabel shapeslabel;
		ofParameter<bool> colourise;
		ofParameter<bool> shapes_randomise;
		ofxButton shapes_generate;
		ofParameter<float> shapes_amount;
		ofParameter<float> shapes_duration;
		//ofxToggle use_mask;
		//ofxToggle invert_mask;

		//segmenter
		ofxLabel segmenterlabel;

		ofParameter<bool> use_segmenter;
		//ofxToggle colour_segmenter;
		ofParameter<float> segmenter_speed;
		ofParameter<float> segmenter_length;
		ofParameter<int> segmenter_number;

		
		vector <colourLineSegmenter> segmenters;
		vector <float> shape_selection_durations;
		set <int> shape_selection;
		int framecounter;
		float phase; //,prev_time; //to calculate phase
		//float rotate_amt;
		//float scale_phase,scale_amt;

};

class textPanel: public transformPanel{
	public:
		textPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5)
			) : transformPanel(_title,_size,_pos){
			styles={"Style: Words","Style: Overlapping","Style: Sentence"};
			panel.add(use_beat.set("use beat", false));
        	panel.add(beat_duration.set("duration factor", 0.5f, 0.0f, 1.0f));
        	panel.add(text_speed.set("speed", 5.0f, 0.0f, 100.0f));
    		panel.add(text_scale.set("scale", 0.001f, 0.0f, 0.01f));
    		panel.add(enable_anim.set("animate", true));
    		panel.add(anim_style.set(styles[0], 0,0,styles.size()-1));
    		panel.add(anim_rev.set("reverse", false));
    		panel.add(vert_pos.set("vert_pos", 0.0f, -0.3f, 0.3f));
    		panel.add(vert_spread.set("vert_spread", 0.0f, -0.3f, 0.3f));
			text.loadFont("fonts/EMSOsmotron.svg");
			anim_style.addListener(this,&textPanel::styleChanged);
		}
		void update(){
			transformPanel::update();
			text.update();
		}
		void styleChanged(int &style){
			anim_style.setName(styles[style]);
		}
		vector<colourPolyline> getLines(){	
			vector<colourPolyline> shapes=text.getOutlines(
				text_scale,
				anim_style,
				0,0,
				enable_anim,
				anim_rev,
				vert_spread,
				use_beat,
				beat_duration
				);
			//ofLog()<<"text returned "<<shapes.size()<<" lines";
			return shapes;
		}
        void loadText(const string & f){
        	text.load(f);
        }
        void loadPalette(const string & f){
        	text.loadPalette(f);
        }
        void loadFont(const string & f){
        	text.loadFont(f);
        }
	protected:
		ofParameter<bool> use_beat;
		ofParameter<float> beat_duration;
		ofParameter<float> text_speed;
        ofParameter<float> text_scale;
        ofParameter<bool> enable_anim;
        ofParameter<int> anim_style;
        ofParameter<bool> anim_rev;
        ofParameter<float> vert_pos;
        ofParameter<float> vert_spread;
        glyphbanner text;
        vector<string> styles;
};
/*
class textgui : public ofxPanel{
	public:
		ofParameter<bool> use_beat;
		ofParameter<float> beat_duration;
		ofParameter<float> text_speed;
        ofParameter<float> text_scale;
        ofParameter<bool> enable_anim;
        ofParameter<bool> anim_rev;
        ofParameter<float> vert_pos;
        ofParameter<float> vert_spread;
        glyphbanner text;
        int onset_frame;
        void loadfile(const string & f){
        	if (!strcmp(strchr(f.c_str(), '\0') - 4, ".plt")){
				text.loadPalette(f);
        	}
        	else {
        		text.load(f);
        	}
        }
        void setup(int x, int y){
        	//text.loadFont("fonts/EMSSpaceRocks.svg");
    		text.loadFont("fonts/EMSOsmotron.svg"); 	

        	ofxPanel::setup("text","",x,y);
        	ofxPanel::add(use_beat.set("use beat", false));
        	ofxPanel::add(beat_duration.set("duration factor", 0.5f, 0.0f, 1.0f));
        	ofxPanel::add(text_speed.set("speed", 5.0f, 0.0f, 25.0f));
    		ofxPanel::add(text_scale.set("scale", 0.1f, 0.0f, 0.5f));
    		ofxPanel::add(enable_anim.set("animate", false));
    		ofxPanel::add(anim_rev.set("reverse", false));
    		ofxPanel::add(vert_pos.set("vert_pos", 0.0f, -0.3f, 0.3f));
    		ofxPanel::add(vert_spread.set("vert_spread", 0.0f, -0.3f, 0.3f));

        }
        void update(int oframe=0){
        	onset_frame=oframe;
        	text.update(text_speed,true);
        }
        void drawgui(int oframe=0){
        	onset_frame=oframe;
        	ofxPanel::draw();
        }
        void createWords(string t){
        	text.createWords(t);
        }
        vector<colourPolyline>& getOutlines(float x=0, float y=0){
        	return text.getOutlines(text_scale,STYLE_OVERLAPPING,x,y+(ofGetHeight()*vert_pos),enable_anim,anim_rev,vert_spread,use_beat,beat_duration);
        }

};
*/