#include "chainImage.h"

#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))

float distance(ofPoint p1,ofPoint p2){
	return pow(pow(p1.x-p2.x,2)+pow(p1.y-p2.y,2),0.5);
}

void chainImage::init(ofPoint _linkPos,float _linkScale,float _linkRot){
	linkPos=_linkPos;
	linkScale=_linkScale;
	linkRot=_linkRot;
	setAnchorPercent(0.5,0.5);
}

void chainImage::start(){
	transition=0.0f;
	time=ofGetElapsedTimef();
	setUseTexture(true);
	scale=linkScale;
}

bool chainImage::update(float decayRatio){

	scale*=decayRatio;

	transition=-(scale-linkScale)/(linkScale-(linkScale*link->linkScale));

	if (scale>linkScale*link->linkScale) return false;
	else {
		transition = 1.0f;
		return true;
	}
}
ofVec3f chainImage::getTransform(){

	ofVec3f _scaledTarget = link->linkPos * linkScale;
	
	return linkPos + ( _scaledTarget * transition );
}
float chainImage::getScale(){

	return scale;
	
}
void chainImage::makeThumbnail(){
	thumbnail=(const ofImage)*this; //copy the ofImage itself

	float thumbheight=ofGetHeight()*THUMB_BORDER_RATIO;
	float thumbwidth=(thumbnail.getWidth()/thumbnail.getHeight())*thumbheight;

	float borderwidth=ofGetHeight()*(1.0-THUMB_BORDER_RATIO)*0.5;

	printf("Rescaling: %fx%f to %fx%f for screen %fx%f, border %f\n",
		thumbnail.getWidth(),thumbnail.getHeight(),
		thumbwidth,thumbheight,
		(float)ofGetWidth(),(float)ofGetHeight(),
		borderwidth);

	thumbnail.resize(thumbwidth,thumbheight);

	thumbnail.setAnchorPoint(thumbnail.getWidth()/2,thumbnail.getHeight()/2);
}

void chainImage::drawChain(float fadeIn){	

	glPushMatrix();

	ofDisableAlphaBlending(); 

	ofSetColor(255,255,255,255);

	draw(0,0,getWidth(),getHeight());

	glTranslatef(linkPos.x,linkPos.y,0);

	glScalef(linkScale,linkScale,linkScale);

	ofEnableAlphaBlending(); 
	 
	ofSetColor(255,255,255,255*min(1.0,transition/fadeIn));

	link->draw(0,0,link->getWidth(),link->getHeight());

	glPopMatrix();
}

Json::Value chainImage::toJson(){
	Json::Value json=Json::Value(Json::objectValue);
	json["linkPos"]=Json::Value(Json::arrayValue);
	json["linkPos"].append(linkPos.x);
	json["linkPos"].append(linkPos.y);
	json["linkScale"]=linkScale;
	json["linkRot"]=linkRot;
	json["filename"]=filename;
	return json;
}

bool chainImage::fromJson(Json::Value json){
	if (load(json["filename"].asString())){
		linkPos=ofPoint(json["linkPos"][0].asDouble(),json["linkPos"][1].asDouble());
		linkScale=json["linkScale"].asDouble();
		linkRot=json["linkRot"].asDouble();
		return true;
	}
	return false;
}

void chainImageSet::drawGui(){
	float t_xoffs=0.0;
	float borderwidth=ofGetHeight()*(1.0-THUMB_BORDER_RATIO)*0.5;

	//draw each image, outlined

	for(std::list<chainImage>::iterator ii=images.begin(); ii != images.end(); ii++){
		
		ofSetColor(255,255,255);

		float thumbx=ii->thumbnail.getWidth()/2;
		float thumby=ii->thumbnail.getHeight()/2;
		float thumbscale=ii->thumbnail.getWidth()/ii->getWidth();


		//why do I have to set this every time??
		ii->thumbnail.setAnchorPercent(0.5,0.5);
		
		ii->thumbnail.draw(
			t_xoffs+borderwidth+thumbx,
			borderwidth+thumby,
			ii->thumbnail.getWidth(),
			ii->thumbnail.getHeight()
			);

		if (ii==selected) ofSetColor(255,0,0);
		else ofSetColor(255,255,255);

		ofDrawLine(t_xoffs+borderwidth,borderwidth,
			t_xoffs+borderwidth+ii->thumbnail.getWidth(),borderwidth);
		ofDrawLine(t_xoffs+borderwidth+ii->thumbnail.getWidth(),borderwidth,
			t_xoffs+borderwidth+ii->thumbnail.getWidth(),borderwidth+ii->thumbnail.getHeight());
		ofDrawLine(t_xoffs+borderwidth+ii->thumbnail.getWidth(),borderwidth+ii->thumbnail.getHeight(),
			t_xoffs+borderwidth,borderwidth+ii->thumbnail.getHeight());
		ofDrawLine(t_xoffs+borderwidth,borderwidth+ii->thumbnail.getHeight(),
			t_xoffs+borderwidth,borderwidth);

		ofSetColor(255,255,255);
		
		if (ii->link){
			ofPoint lp=ii->linkPos;
			if (ii==selected){
				lp+=dragPoint;
			}

			float subpictx=t_xoffs+borderwidth+thumbx+(lp.x*thumbscale);
			float subpicty=borderwidth+thumby+(lp.y*thumbscale);

			ofDrawLine(
				subpictx,
				subpicty,
				t_xoffs+(borderwidth*3)+ii->thumbnail.getWidth(),
				borderwidth+thumby

			);

			glPushMatrix();

				glTranslatef(subpictx,subpicty,0);
			
				float r=ii->linkRot;
				if (ii==selected) r+=dragRotate;
				glRotatef(r,0,0,1);

				//printf("Sub image: centre at %f,%f \n",ii->link->thumbnail.getAnchorPoint().x,ii->link->thumbnail.getAnchorPoint().y);
				
				ii->link->thumbnail.setAnchorPercent(0.5,0.5);

				float thescale=ii->linkScale;
				if (ii==selected){
					thescale*=(1.0f+dragScale);
				}

				ii->link->thumbnail.draw(
					0,
					0,
					ii->link->thumbnail.getWidth()*thescale,
					ii->link->thumbnail.getHeight()*thescale
				);

				ofPoint p1=ofPoint(
					-(ii->link->thumbnail.getWidth()*thescale*0.5),
					-(ii->link->thumbnail.getHeight()*thescale*0.5));
				ofPoint p2=ofPoint(
					(ii->link->thumbnail.getWidth()*thescale*0.5),
					-(ii->link->thumbnail.getHeight()*thescale*0.5));
				ofPoint p3=ofPoint(
					(ii->link->thumbnail.getWidth()*thescale*0.5),
					(ii->link->thumbnail.getHeight()*thescale*0.5));
				ofPoint p4=ofPoint(
					-(ii->link->thumbnail.getWidth()*thescale*0.5),
					(ii->link->thumbnail.getHeight()*thescale*0.5));

				ofDrawLine(p1,p2);
				ofDrawLine(p2,p3);
				ofDrawLine(p3,p4);
				ofDrawLine(p4,p1);

			glPopMatrix();

		}
		
		
		t_xoffs+=ii->thumbnail.getWidth()+(borderwidth*2)		;
	}

}

bool chainImageSet::add(std::string filename,glm::vec2 pos){
	printf("Dropped file: %s at %f,%f \n",filename.c_str(),pos.x,pos.y);
/*
attempt to add file to chain.
find if file exists in data folder
if not make a symbolic link
*/
	chainImage image;
	if (image.load(filename)){
		
		image.init(ofPoint(0,0),
			currentDefaultImageRatio,
			0 //default rotation
		);

		printf("Loaded file: %s at %f,%f \n",filename.c_str(),pos.x,pos.y);


		images.push_back(image);
		(*images.rbegin()).link=&(*images.begin());

		printf("Linked: %s to %s\n",
			images.rbegin()->filename.c_str(),
			images.begin()->filename.c_str());


		if (images.size()>1){
			(++images.rbegin())->link=&(*(images.rbegin()));
			printf("Linked: %s to %s\n",
				(++images.rbegin())->filename.c_str(),
				images.rbegin()->filename.c_str());
		}
		else {
			selected=images.begin();
		}
		

		
		return true;
	}
	printf("Could not load file: %s \n",filename.c_str());

	return false;
}

void chainImageSet::keyPressed(ofKeyEventArgs &keyargs){
	//printf("Got key %i, modifiers:%i\n",keyargs.key,keyargs.modifiers);
	switch(keyargs.key){
		case '[':
			if (selected==images.begin()){
				selected=--images.end();
			}
			else --selected;
			break;
		case ']':
			++selected;
			if (selected==images.end()){
				selected=images.begin();
			}
			break;
		case OF_KEY_UP:
			selected->linkPos.y--;
			break;
		case OF_KEY_DOWN:
			selected->linkPos.y++;
			break;
		case OF_KEY_LEFT:
			selected->linkPos.x--;
			break;
		case OF_KEY_RIGHT:
			selected->linkPos.x++;
			break;
		case 's':
		case 83: {
			//printf("Saving... keyargs modifiers:%i\n",keyargs.modifiers);
			//saves over last filename or use control to choose a new one
			if (!filename.length()||keyargs.hasModifier(OF_KEY_CONTROL)){
				ofFileDialogResult saveFileResult = ofSystemSaveDialog(ofGetTimestampString() + ".json" , "Save your file");
				if (saveFileResult.bSuccess){
					filename=saveFileResult.filePath;	
					//printf("Got filename: %s\n",filename.c_str());
				}
				//else printf("ofSystemSaveDialog failed.\n");
			}
			if (filename.length()){
				//printf("Saving %s\n",filename.c_str());
				saveJson(filename);
			}
			
			break;
		}
		case 'l':{
			//load_chain();
			ofFileDialogResult openFileResult= ofSystemLoadDialog("Select a json preset"); 
		
			//Check if the user opened a file
			if (openFileResult.bSuccess){
				
				
				bool success=loadJson(openFileResult.fileName);

				ofLogVerbose("Load %s %s\n",
					openFileResult.filePath.c_str(),
					success?"succeeded":"failed");
				
				
			}else {
				ofLogVerbose("User hit cancel");
			}
			break;

		}
	}
}

//--------------------------------------------------------------
void chainImageSet::mouseDragged(int x, int y, int button){
	switch (button){
		case OF_MOUSE_BUTTON_1:
			dragPoint=ofPoint(x-clickPoint.x,y-clickPoint.y)*(selected->getHeight()/ofGetHeight());
			break;
		case OF_MOUSE_BUTTON_2:
			//alt-click
			dragRotate=((clickPoint.x-x)/(selected->thumbnail.getWidth()))*180.0f;
			break;
		case OF_MOUSE_BUTTON_3:
			//control-click
			dragScale=(y-clickPoint.y)/(selected->thumbnail.getHeight());
			break;
	}
	}

//--------------------------------------------------------------
void chainImageSet::mousePressed(int x, int y, int button){
	//todo: select
	clickPoint=ofPoint(x,y);
}

//--------------------------------------------------------------
void chainImageSet::mouseReleased(int x, int y, int button){
	if (images.size()){
		selected->linkPos+=dragPoint;
		dragPoint=ofPoint(0,0);
		selected->linkScale*=(1.0f+dragScale);
		dragScale=0.0f;
		selected->linkRot+=dragRotate;
		dragRotate=0.0f;
	}
}

bool chainImageSet::saveJson(std::string filename){
	ofxJSON json;

	json["images"] = Json::Value(Json::arrayValue);

	for(std::list<chainImage>::iterator ii=images.begin(); ii != images.end(); ii++){
		json["images"].append(ii->toJson());
	}


	json.save(filename, true);

}
bool chainImageSet::loadJson(std::string _filename){
	ofxJSON json;
	bool parsingSuccessful = json.open(_filename);

    if (parsingSuccessful)
    {
    	images.clear();

    	for (int i=0;i<json["images"].size();i++){
    		chainImage image;
    		if (image.fromJson(json["images"][i])){
    			images.push_back(image);	
    		} 
    	}
    	for (std::list<chainImage>::iterator ii=images.begin(); ii != images.end(); ii++){
			auto li=ii;
			li++;
			if (li==images.end()) {
				li=images.begin();
			}
			ii->link=&(*li);

		}
		selected=images.begin();
		filename=_filename;
		return true;


    }
    ofLogVerbose("JSON load: parsing unsuccesful\n");
    return false;
}