#pragma once

#include "ofMain.h"


#include "ofxGui.h"
#include "ofxXmlSettings.h"
#include "ofxSVG.h"
#include "ofxClipper.h"
#include "ofxMidi.h"	
#include "ofxPONK.h"

#include "lineTransformer.h"
#include "lineSegmenter.h"

static ofVec2f DISPLAYSIZE(200,200);
static int panelnum=1;

class vectorPanel {
	public:
		vectorPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5))
			{
			size=_size;
			position=_pos;
			panel.setup(_title,"",0,size.y+5);
		}
		void draw(){
			ofPushMatrix();
			ofTranslate(position);
			ofSetColor(255);
			ofNoFill();
			ofDrawRectangle(0,0,size.x,size.y);
			panel.draw();
			ofPushMatrix();
			ofTranslate(size/2);
			ofScale(DISPLAYSIZE.x/2.0f);
			vector<colourPolyline> lines=getLines();
			for (auto& line:lines){
				line.draw();
			}
			ofPopMatrix();
			ofPopMatrix();
		}
		virtual vector<colourPolyline> getLines() {};

	private:
		ofVec2f size;
		ofPoint position;
		ofxPanel panel;
};

class svgPanel: public vectorPanel{
	public:
		svgPanel(
			string _title="",
			ofVec2f _size=DISPLAYSIZE,
			ofVec2f _pos=ofPoint(5,5)
			) : vectorPanel(_title,_size,_pos){}
		void load(string filename){
			
			ofxSVG svg;
			svg.load(filename);

			//normalise the SVG paths to a square format

			float dimension=max(svg.getWidth(),svg.getHeight());

			glm::vec2 src[]={
		    	glm::vec2(0,0),
		    	glm::vec2(dimension,0),
		    	glm::vec2(dimension,dimension),
		    	glm::vec2(0,dimension)
		    };

		    glm::vec2 dst[]={ //PONK coords
		    	glm::vec2(-1,-1),
		    	glm::vec2(1,-1),
		    	glm::vec2(1,1),
		    	glm::vec2(-1,1)
		    };

			ofMatrix4x4 xform=lineTransformer::getPerspectiveTransformMatrix(src,dst);
			
			vector <ofPath> imagepaths= svg.getPaths();

			std::stringstream strm;

			if (imagepaths.size()){
				segmenters.clear();
				//shape_selection_durations.clear();
				for (auto& path:imagepaths){
					path.setPolyWindingMode(OF_POLY_WINDING_ODD);

					vector <ofPolyline> outlines= path.getOutline();
					for (auto& outline:outlines){
						//strm << outline.size() << "->";
						//outline.simplify(contour_simplify);
						//strm << outline.size() << " ";
						ofPolyline xformed=lineTransformer::polyLineTransform(xform,outline);
						ofColor c1=path.getStrokeColor();
						ofColor colour=path.getFillColor();
						if (colour.r==colour.g&&colour.g==colour.b){
							colour=c1;
						}

						segmenters.push_back(
							colourLineSegmenter(
								xformed,
								path.getStrokeColor()
								)
							);
						//shape_selection_durations.push_back(0.0f);
					}
		
					//strm << " , ";	
				}

				//std::stringstream strom;

				//shape_selection.clear();
				//while (shape_selection.size()<(segmenters.size()*shapes_amount)){
				//	int selection=(int)ofRandom(0,segmenters.size());
				//	shape_selection.insert(selection);
				//}
				//for (auto s:shape_selection){
				//	float spawn=(ofRandom(0,(float)shapes_duration));
				//	shape_selection_durations[s]=spawn;
				//	strom << s << ":"<<spawn<<" ";
				//}
				//last_frame_time=ofGetElapsedTimef();
				//cout << "SVG: selected paths [ "<<strom.str() << " ]" <<std::endl;
				//cout << "SVG: found " << imagepaths.size() << " paths with " << segmenters.size() << " shapes [ " << strm.str() << " ]" <<std::endl;
				//select_random_shapes(shapes_duration);
			ofLog()<<"loaded SVG "<<filename<<", "<<segmenters.size()<<" paths";

			}
			else {
				ofLog()<<"could not load SVG "<<filename;
			}
		}
		vector<colourPolyline> getLines(){
			vector<colourPolyline> output;
			for (auto& shape:segmenters){
				output.push_back(shape.getPoly());
			}
			//ofLog()<<"svg found "<<output.size()<<" lines";
			return output;
		}

	private:
		//ofxFloatSlider contour_simplify;

		//svg gui
		//ofxToggle	 shapes_randomise;
		//ofxFloatSlider shapes_amount;
		//ofxFloatSlider shapes_duration;
		//ofxToggle use_mask;
		//ofxToggle invert_mask;

		//segmenter
		//ofxToggle use_segmenter;
		//ofxToggle colour_segmenter;
		//ofxFloatSlider segmenter_speed;
		//ofxFloatSlider segmenter_length;
		//ofxIntSlider 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 ofApp: public ofBaseApp, public ofxMidiListener {

	public:

		ofApp() : 
			networkinput("network",DISPLAYSIZE,ofPoint(5,5)),
			svginput("svg",DISPLAYSIZE,ofPoint(210,5)),
			textinput("text",DISPLAYSIZE,ofPoint(415,5)) {}

		void setup();
		void update();
		void draw();
		void exit();

		void keyPressed(ofKeyEventArgs &keyargs);
		void keyReleased(ofKeyEventArgs & args);
		void mouseMoved(int x, int y );
		void mouseDragged(int x, int y, int button);
		void mousePressed(int x, int y, int button);
		void mouseReleased(int x, int y, int button);
		void mouseEntered(int x, int y);
		void mouseExited(int x, int y);
		void windowResized(int w, int h);
		void dragEvent(ofDragInfo dragInfo);

		void newMidiMessage(ofxMidiMessage& eventArgs);

		//======================================= //MIDI

		ofxMidiIn midiIn;
		ofxMidiMessage midiMessage;
		
		//======================================= //saving settings

		ofxXmlSettings XML;

		void default_settings();
		void save_settings();
		void load_settings();

		//======================================= //inputs

		svgPanel networkinput;
		svgPanel svginput;
		svgPanel textinput;

		//======================================= //output

		ofxPONKSenderPanel madlaser;

};