#include "ofApp.h"
#include "glew.h"


vector<std::string> cmdnames={"moveTo","lineTo","curveTo","bezierTo","quadBezierTo","arc","arcNegative","close"};

//--------------------------------------------------------------
void ofApp::setup(){
	ofxSVG svg;
	svg.load("bars.svg");
	imagepaths= svg.getPaths();

	for (int i=0;i<imagepaths.size();i++){
		vector <ofPolyline> outlines= imagepaths[i].getOutline();
		for (int j=0;j<outlines.size();j++){
			segmenters.push_back(lineSegmenter(outlines[j]));
		}	
	}

	cout << "Drawing: found " << maskpaths.size() << " paths with " << segmenters.size() << " shapes" <<std::endl;

	svg.load("lorenzo.svg");
	maskpaths= svg.getPaths();

	for (auto& path:maskpaths){
		//paths[i].setMode(ofPath::COMMANDS);
		path.setPolyWindingMode(OF_POLY_WINDING_ODD);
		
		vector <ofPolyline> outlines= path.getOutline();
		for (auto& outline:outlines){
			mask.push_back(outline);
		}
		/*
		vector<ofPath::Command> cmds=paths[i].getCommands();

		std::stringstream strm;
		strm << "Mask: found " << cmds.size() << " commands (";
		for (auto& cmd:cmds){
			strm << cmdnames[cmd.type] <<",";
		}

		strm << ")" << std::endl;
		cout << strm.str();
		*/

	}

	cout << "Mask: found " << maskpaths.size() << " paths with " << mask.size() << " shapes" <<std::endl;

	numsegments=1;
	coverage=0.5;

	mode=0;
    
	ofSetFrameRate(30); 

	movie.load("clouds_flythrough.mp4");
	movie.setLoopState(OF_LOOP_NORMAL);
	movie.play();

	threshold=128;
}

//--------------------------------------------------------------
void ofApp::update(){

	clipper.Clear();
	
	clipper.addPolylines(mask, ClipperLib::ptClip);

	
}

ofPolyline ofApp::polyLineTransform(const ofPolyline& poly, ofMatrix4x4 xform){
	ofPolyline tempPoly;
	for (auto& p:poly){
		tempPoly.addVertex(ofVec3f(p)*xform);
	}
	return tempPoly;
}



//--------------------------------------------------------------	
void ofApp::draw(){
	ofBackground(0,0,0);
	ofSetColor(255,255,255);

	int segmentsdrawn=0;
	int pointsdrawn=0;

	float phase=fmod(ofGetElapsedTimef()/2,1);

	//movie.draw(0,0,ofGetWidth(),ofGetHeight());

	//transform points of segmenter before intersecting with mask

	switch (mode){
		case 0:{
			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
				auto segments=shape->getSegments(numsegments,coverage,phase);
				for (auto segment=segments.begin();segment!=segments.end();segment++){
					segment->draw();
					segmentsdrawn+=1;
					pointsdrawn+=segment->size();
				}
			}
			break;
		}
		case 1:{
			vector <ofPolyline> shapes;
			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
				auto segments=shape->getSegments(numsegments,coverage,phase);
				for (auto segment=segments.begin();segment!=segments.end();segment++){
					shapes.push_back(*segment);
				}
			}
			clipper.addPolylines(shapes,ClipperLib::ptSubject);
			vector<ofPolyline> clipped = clipper.getClippedLines(ClipperLib::ctIntersection);
			for (auto& clip: clipped)
		    {
		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }
		    break;
		}
		case 2:{
			vector <ofPolyline> shapes;
			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
				auto segments=shape->getSegments(numsegments,coverage,phase);
				for (auto segment=segments.begin();segment!=segments.end();segment++){
					shapes.push_back(*segment);
				}
			}
			clipper.addPolylines(shapes,ClipperLib::ptSubject);
			vector<ofPolyline> clipped = clipper.getClippedLines(ClipperLib::ctDifference);
			for (auto& clip: clipped)
		    {
		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }
		    break;
		}
		case 3:{
			vector <ofPolyline> shapes;
			ofMatrix4x4 rm = ofMatrix4x4::newIdentityMatrix();
			rm.translate(-600,-450,0);
			rm.rotateRad(ofGetElapsedTimef(),0,0,1);
			rm.translate(600,450,0);
			for (auto& segment:segmenters){
				shapes.push_back(polyLineTransform(segment.getPoly(),rm));
			}
			clipper.addPolylines(shapes,ClipperLib::ptSubject);
			vector<ofPolyline> clipped = clipper.getClippedLines(ClipperLib::ctIntersection);
			for (auto& clip: clipped)
		    {
		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }
			break;
		}
		case 4:{
			vector<ofPolyline> clipped = clipper.getOffsets(maskpaths,((sin(ofGetElapsedTimef())+1)*5)+1,true);
	    	for (auto& clip: clipped)
		    {
		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }
			break;
		}
		case 5:{
			//the N only fucks up when the other shapes are drawn!
			vector<ofPolyline> clipped;
			for (auto & maskpath:maskpaths){
				auto clips=clipper.getOffsets(maskpath,-((phase*20)+1),true);
				clipped.insert(clipped.end(),clips.begin(),clips.end());
			}
			
			vector<ofPolyline> simplified = clipper.simplifyPolylines(clipped);

			ofSetColor(255*(1.0f-phase),255*(1.0f-phase),255*(1.0f-phase));

	    	for (auto& clip: simplified)
		    {

		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }

/*
		   	float phase1=fmod(phase+0.5f,1.0f);

		   	clipped.clear();

		    clipped = clipper.getOffsets(maskpaths,-((phase*20)+1),true);

		    simplified.clear();
			
			simplified = clipper.simplifyPolylines(clipped);

			ofSetColor(255*(1.0f-phase1),255*(1.0f-phase1),255*(1.0f-phase1));

	    	for (auto& clip: simplified)
		    {

		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }

*/
			break;
		}
		case 6:{

			vector <ofPolyline> shapes;
			for (auto& shape: mask)
		    {
		    	shape.close();
		    	shapes.push_back(shape);
		    }
			vector<ofPolyline> clipped = clipper.getOffsets(shapes,((sin(ofGetElapsedTimef())+1)*5)+1);
			
			
			vector<ofPolyline> simplified = clipper.simplifyPolylines(clipped);

	    	for (auto& clip: simplified)
		    {
		        clip.draw();
		        segmentsdrawn++;
		        pointsdrawn+=clip.size();
		    }


			break;
		}
		case 7: {
			movie.update();
			if (movie.isFrameNew()){
				colorImg.setFromPixels(movie.getPixels());
				grayImage = colorImg;
				grayImage.threshold(threshold);
				contourFinder.findContours(grayImage, 20, (340*240)/3, 10, true);
			}
			vector <ofPolyline> shapes;
			for (int i = 0; i < contourFinder.nBlobs; i++){
				ofPolyline shape;
				for (auto& point:contourFinder.blobs[i].pts){
					shape.addVertex(point);
				}
		        shapes.push_back(shape);
		        segmentsdrawn++;
		        pointsdrawn+=shape.size();
		        contourFinder.blobs[i].draw(0,0);
		    }
		    break;
		}
		case 8:{
			int w=ofRandom(1000);
			segmenters[w%segmenters.size()].draw();
			segmentsdrawn=1;
			pointsdrawn+=segmenters[w%segmenters.size()].size();
			break;
		}
	}
	/*
	ofxSVG svg;
	svg.load("lorenzos.svg");
	vector <ofPath> paths= svg.getPaths();
	for (auto& l:paths) l.draw();
	*/
	

	std::stringstream strm;
	strm << "mode: " << mode << " segments: "<<segmentsdrawn<< " points: "<<pointsdrawn;
	ofSetWindowTitle(strm.str());

	mainOutputSyphonServer.publishScreen();

}


//--------------------------------------------------------------
void ofApp::exit() {
	
}



//--------------------------------------------------------------
void ofApp::keyPressed(ofKeyEventArgs &args){



}



//--------------------------------------------------------------
void ofApp::keyReleased(int key){
	switch(key){
		case '[':{
			numsegments=max(0,numsegments-1);
			break;
		}
		case ']':{
			numsegments++;
			break;
		}	
		case '{':{
			coverage=coverage*0.9f;
			break;
		}
		case '}':{
			coverage=min(coverage/0.9f,1.0f);
			break;
		}
		case 'p':{
			mode=(mode+1)%9;
			break;
		}
		case '-':{
			threshold=max(threshold-1,0);
			break;
		}
		case '=':{
			threshold=min(threshold+1,255);
			break;
		}
	}
	
}

//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){

}

//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
	
}

//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
	
}

//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y){

}

//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y){

}

//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){

}

void ofApp::outputWindowResized(ofResizeEventArgs &resizeargs){

}

//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){ 

	
}