#include "vectorPlugin.h"

void svgPanel::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); //?necessary	
				//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){
					//if there appears to be no fill colour resort to stroke
					colour=c1;
				};

				segmenters.push_back(
					colourLineSegmenter(
						xformed,
						colour
						)
					);
				shape_selection_durations.push_back(0.0f);
			}

			//strm << " , ";	
		}

		//std::stringstream strom;

		
		//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();
		
		ofLog()<<"loaded SVG "<<filename<<", "<<segmenters.size()<<" paths";

	}
	else {
		ofLog()<<"could not load SVG "<<filename;
	}
}

void svgPanel::select_random_shapes(){

	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<<" ";
	}

}

void svgPanel::update_random_shapes(bool generate=true){

	shape_selection.clear();

	//track how long each shape has been selected and recreate the selection
	for (int i=0;i<shape_selection_durations.size();i++){
		if (shape_selection_durations[i]>timedelta){
			shape_selection_durations[i]-=timedelta;
			shape_selection.insert(i);
		}
	}

	//

	/*
	std::stringstream strom;
	for (auto& s:shape_selection){
		strom << s <<":"<<shape_selection_durations[s]<<" ";
	}

	cout << timedelta <<": decay selection: "<<shape_selection.size()<<" shapes (" << strom.str() <<") \n";
	*/

	if (generate){
		while (shape_selection.size()<(segmenters.size()*shapes_amount)){
			int selection=rand()%segmenters.size();
			if (shape_selection.find(selection)==shape_selection.end()){
				shape_selection_durations[selection]=shapes_duration+ofRandom(1.0f);
				shape_selection.insert(selection);
			}
		}
		/*
		std::stringstream strm;
		for (auto& s:shape_selection){
			strm << s <<":"<<shape_selection_durations[s]<<" ";
		}
		cout << "random selection: "<<shape_selection.size()<<" shapes (" << strm.str() <<") \n";
		*/
	}
}


vector<colourPolyline> svgPanel::getAllLines(){
	vector<colourPolyline> output;
	for (auto& shape:segmenters){
		output.push_back(shape.getPoly());
	}
	return output;
}

vector<colourPolyline> svgPanel::getLines(){
	vector<colourPolyline> output;

	//if (!use_onset||onset_frame<onset_duration||shapes_randomise){
	if (shapes_randomise){
		//if (framecounter==0){
		//	select_random_shapes();
		//	framecounter=shapes_duration;
		//}
		update_random_shapes(true); //from audio !use_onset||onset_frame<onset_duration);
		for (auto s:shape_selection){
			if (use_segmenter){
				auto segments=segmenters[s].getSegments(segmenter_number,segmenter_length,phase);
				for (auto segment=segments.begin();segment!=segments.end();segment++){
					//output.push_back(colourPolyline(*segment,ofColor(laser_R,laser_G,laser_B)));
					output.push_back(*segment);
				}
			}
			else {
				//output.push_back(colourPolyline(segmenters[s].getPoly(),ofColor(laser_R,laser_G,laser_B)));
				output.push_back(segmenters[s].getPoly());
			}
		}
		framecounter--;
	}
	else {
		for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
			if (use_segmenter){
				auto segments=shape->getSegments(segmenter_number,segmenter_length,phase);
				for (auto segment=segments.begin();segment!=segments.end();segment++){
					//output.push_back(colourPolyline(*segment,ofColor(laser_R,laser_G,laser_B)));
					output.push_back(*segment);
				}
			}
			else {
				//output.push_back(colourPolyline(shape->getPoly(),ofColor(laser_R,laser_G,laser_B)));
				output.push_back(shape->getPoly());
			}
		}
	}

	//this should happen at output stage?

	if (colourise){
		for (auto p=output.begin();p!=output.end();p++){
			p->setColour(ofColor(255,255,255));
		}
	}

//}
	return output;
}