#include "testApp.h"
string urlDecode(string &SRC) {
    string ret;
    char ch;
    int i, ii;
    for (i=0; i<SRC.length(); i++) {
        if (int(SRC[i])==37) {
            sscanf(SRC.substr(i+1,2).c_str(), "%x", &ii);
            ch=static_cast<char>(ii);
            ret+=ch;
            i=i+2;
        } else {
            ret+=SRC[i];
        }
    }
    return (ret);
}
//--------------------------------------------------------------
guiWindow::~guiWindow(){
	cout << "gui window destroyed" << endl;
}
void guiWindow::setup(){}
void guiWindow::setParent(testApp *p){
	parent=p;
}
void guiWindow::draw(){
	parent->gui.draw();
}
//--------------------------------------------------------------
void testApp::setup(){
	loadSettings("settings.xml");

	gw=720;
	gh=576;

	vidGrabber.setVerbose(true);
	bGrab=vidGrabber.initGrabber(gw,gh); //base grab size

	learningRate = 0.001f;

	colorImg.allocate(gw,gh);
	grayImage.allocate(gw,gh);
	grayBg.allocate(gw,gh);
	grayDiff.allocate(gw,gh);

	mode=DISPLAY_FG;

	bLearnBakground = true;

	if (boundaries.size()==0) {
		boundaries.push_back(boundary());
	}
	selectedBoundary=0;
	selectedPoint=-1;

	guiWin=new guiWindow();
	ofxFenster* win=ofxFensterManager::get()->createFenster(0, 0,  200, 200, OF_WINDOW);

	//ofAddListener(win2->events.windowResized, this, &testApp::windowEvent);

	//volume is set in loadSettings
	gui.setup("","panel.xml",0,0);
	gui.add(vol.setup("volume",volume,0,1.0,255));
	vol.addListener(this,&testApp::volumeChanged);
	gui.add(bFlip.setup("flip grab", flip));
	bFlip.addListener(this,&testApp::resetBG);
	gui.add(bInvert.setup("invert grab", invert));
	bInvert.addListener(this,&testApp::resetBG);
	gui.add(thresh.setup("threshold",threshold,0,255,255));
	win->setWindowTitle("config");
	win->addListener(guiWin);
	guiWin->setup();
	guiWin->setParent(this);
}

//--------------------------------------------------------------
void testApp::update(){
	if (bGrab) {
	    vidGrabber.grabFrame();
		bool bNewFrame = vidGrabber.isFrameNew();
		if (bNewFrame){
			colorImg.setFromPixels(vidGrabber.getPixels(), gw,gh);
			if (bFlip) colorImg.mirror(false,true);
			grayImage = colorImg;
			if (bInvert) grayImage.invert();
			switch(method) {
				case METHOD_SIMPLE:
					if (bLearnBakground){
						grayBg = grayImage;
						bLearnBakground = false;
					}
					break;
				case METHOD_ACCUM:
					cv::Mat img = grayImage.getCvImage();
					//printf("img: %ix%i %i ch x %i bits\n",img.size().width,img.size().height,img.channels(),img.depth());
					if (bLearnBakground) {
						img.convertTo(accumulator, CV_32FC1);
						startTime=ofGetElapsedTimef();
						bLearnBakground=false;
					}
					cv::Mat im3;
					img.convertTo(im3, CV_32FC1);
					//printf("accumulator: %ix%i %i ch x %i bits\n",accumulator.size().width,accumulator.size().height,accumulator.channels(),accumulator.depth());
					//printf("im3: %ix%i %i ch x %i bits\n",im3.size().width,im3.size().height,im3.channels(),im3.depth());
					accumulateWeighted(im3, accumulator, max(1.0f/((ofGetElapsedTimef()-startTime)*30.0f),learningRate));
					accumulator.convertTo(outmat,CV_8UC1);
					grayBg=new IplImage(outmat);
			}
			grayDiff.absDiff(grayBg, grayImage);
			grayDiff.threshold(threshold);
			contourFinder.findContours(grayDiff, 20, (gw*gh)/3, 10, true);	// find holes
		}
		//generate events
		for (int i = 0; i < contourFinder.nBlobs; i++){
		    for (int j=0;j<boundaries.size();j++) {
			if (boundaries[j].checkClick(contourFinder.blobs[i].centroid)) {
			    //printf("playing %i: %s\n",boundaries[j].filename.c_str(),j);
			}
		    }
		}
	}

}

//--------------------------------------------------------------
void testApp::draw(){
    //ofBackground(0,0,0);
	ofSetColor(255,255,255);
	if (bGrab) {
		switch(mode){
		    case DISPLAY_FG:
			grayImage.draw(0,0,gw,gh); //(ofGetHeight()-gh)/2,gw,ofGetHeight()+((gh-ofGetHeight())/2));
			break;
		    case DISPLAY_BG:
			grayBg.draw(0,0,gw,gh); //(ofGetHeight()-gh)/2,gw,ofGetHeight()+((gh-ofGetHeight())/2));
			break;
		    case DISPLAY_DIFF:
			grayDiff.draw(0,0,gw,gh); //(ofGetHeight()-gh)/2,gw,ofGetHeight()+((gh-ofGetHeight())/2));
			break;
		}

		for (int i = 0; i < contourFinder.nBlobs; i++){
			contourFinder.blobs[i].draw(0,0); //(ofGetHeight()-gh)/2);
		}
	}

	for (int i=0;i<boundaries.size();i++) {
	    int b=selectedBoundary==i?255:180;
		if (boundaries[i].sound.getIsPlaying()) {
		    int r=b*boundaries[i].sound.getPosition();
		    ofSetColor(r,0,b-r);
		}
		else ofSetColor(b,0,0);
		boundaries[i].draw();
	}
	/*
	for (int i=0;i<clicks.size();i++) {
	    ofSetColor(0,0,255);
	    ofLine(clicks[i].x-2,clicks[i].y,clicks[i].x+2,clicks[i].y);
	    ofLine(clicks[i].x,clicks[i].y-2,clicks[i].x,clicks[i].y+2);
	}
    */
}

//--------------------------------------------------------------
void testApp::keyPressed(int key){

    //make in fenster, drag/drop support
    //drag sound file onto a sound area, its name becomes name of area
    //keys to play/stop (test)
    //overall sound level control
    //fine tune image detection
	bool T=true;
	switch (key){
		case ' ':
			resetBG(T);
			break;
		case '+':
			threshold ++;
			if (threshold > 255) threshold = 255;
			break;
		case '-':
			threshold --;
			if (threshold < 0) threshold = 0;
			break;
		case 'i':
			bInvert=!bInvert;
			resetBG(T);
			break;
		case 'f':
			bFlip=!bFlip;
			resetBG(T);
			break;
		case 's':
			saveSettings("settings.xml");
			break;
		case 'a':
			boundaries.push_back(boundary());
			selectedBoundary=boundaries.size()-1;
			break;
		case 'z':
			boundaries[selectedBoundary].undo();
			break;
		case 'q':
			boundaries.erase(boundaries.begin()+selectedBoundary);
			if (selectedBoundary==boundaries.size()) selectedBoundary=0;
			break;
		case OF_KEY_PAGE_UP:
			selectedBoundary--;
			if (selectedBoundary<0) selectedBoundary=boundaries.size()-1;
			break;
		case OF_KEY_PAGE_DOWN:
			selectedBoundary=(selectedBoundary+1)%boundaries.size();
			break;
		/*
		case OF_KEY_LEFT:
			boundaries[selectedBoundary].note--;
			break;
		case OF_KEY_RIGHT:
			boundaries[selectedBoundary].note++;
			break;
		*/
		case '1':
		case '2':
		case '3':
			mode=key-48;
			break;
		case '4':
		case '5':
			method=key-48;
			bLearnBakground=true;
			break;

	}
}
void testApp::resetBG(bool &chg){
	bLearnBakground = true;
}
void testApp::volumeChanged(float &v){
	for (int i=0;i<boundaries.size();i++) boundaries[i].setVolume(v);
}
//--------------------------------------------------------------
void testApp::keyReleased(int key){

}

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

}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
    if (selectedPoint>-1) boundaries[selectedBoundary].points[selectedPoint]=ofPoint(x,y,0);
}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
    ofPoint p=ofPoint(x,y,0);
    switch (button) {
        case 0:
            selectedPoint=boundaries[selectedBoundary].findPoint(p);
            if (selectedPoint<0) {
                boundaries[selectedBoundary].add(p);
            }
            else boundaries[selectedBoundary].points[selectedPoint]=p;
            break;
        case 1:
            for (int i=0;i<boundaries.size();i++) {
                if (boundaries[i].checkClick(p)) printf("playing %i: %s\n",i,boundaries[i].filename.c_str());
            }
            break;
        case 2:
            for (int i=0;i<boundaries.size();i++) {
                if (boundaries[i].contains(p)) selectedBoundary=i;
            }
            break;
	}
}

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

}

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

}

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

}

//--------------------------------------------------------------
void testApp::dragEvent(ofDragInfo dragInfo, ofxFenster* win){
    dragEvent(dragInfo);
}
void testApp::dragEvent(ofDragInfo dragInfo) {
    printf("got draginfo: %f,%f,%f\n",dragInfo.position.x,dragInfo.position.y,dragInfo.position.z);
    int sta=dragInfo.files[0].find_last_of("\\/")+1;
    int len=(dragInfo.files[0].find_last_of(".")+4)-sta;
	string f=dragInfo.files[0].substr(sta,len);
	string filename=urlDecode(f);
	for (int i=0;i<boundaries.size();i++) {
		if (boundaries[i].checkFile(dragInfo.position,filename)) printf("loaded %s into shape %i\n",filename.c_str(),i);
	}
	//clicks.push_back(ofPoint(dragInfo.position.x,dragInfo.position.y,0));
}
void testApp::loadSettings(string filename){
	if( !XML.loadFile(filename) ){
		printf("unable to load %s check data/ folder\n",filename.c_str());
	}else{
		flip=(XML.getAttribute("figgis","flip",0,0)==1);
		invert=(XML.getAttribute("figgis","invert",0,0)==1);
		threshold = XML.getAttribute("figgis","threshold",80,0);
		volume = XML.getAttribute("figgis","volume",1.0,0);
		method= XML.getAttribute("figgis","method",4,0);
		 if(XML.pushTag("boundaries")) {
			 for (int i=0;i<XML.getNumTags("boundary");i++){
				boundaries.push_back(boundary(XML.getAttribute("boundary","filename","",i)));
				selectedBoundary=boundaries.size()-1;
				XML.pushTag("boundary",i);
				for (int j=0;j<XML.getNumTags("point");j++){
					boundaries[selectedBoundary].add(ofPoint(XML.getAttribute("point","x",0.0,j),XML.getAttribute("point","y",0.0,j),0.0));
				}
				XML.popTag();
			 }
			 XML.popTag();
		 }
		printf("loaded %s\n",filename.c_str());
	}
}
void testApp::saveSettings(string filename){
	XML.setAttribute("figgis","invert",bInvert,0);
	XML.setAttribute("figgis","flip",bFlip,0);
	XML.setAttribute("figgis","threshold",threshold,0);
	XML.setAttribute("figgis","volume",volume,0);
	XML.setAttribute("figgis","method",method,0);
	if (XML.tagExists("boundaries")) XML.removeTag("boundaries");
	XML.addTag("boundaries");
	if(XML.pushTag("boundaries")) {
		for (int i=0;i<boundaries.size();i++){
			XML.addTag("boundary");
			XML.setAttribute("boundary","filename",boundaries[i].filename,i);
			if(XML.pushTag("boundary",i)) {
				for (int j=0;j<boundaries[i].points.size();j++){
					XML.addTag("point");
					XML.setAttribute("point","x",boundaries[i].points[j].x,j);
					XML.setAttribute("point","y",boundaries[i].points[j].y,j);
				}
				XML.popTag();
			}
		}
		XML.popTag();
	}
	XML.saveFile(filename);
	printf("saved %s\n",filename.c_str());
}
void testApp::exit(){
}