#include "testApp.h"

previewWindow::~previewWindow(){
	cout << "preview window destroyed" << endl;
}
void previewWindow::setup(){}
void previewWindow::setBuffer(ofFbo *buffer){
	rb=buffer;
}
void previewWindow::draw(){

	rb->draw(0,0,ofGetWidth(),ofGetHeight()); //why crash?

	ofSetColor(255,255,255);
	ofDrawBitmapString(ofToString(ofGetFrameRate(), 2),20,20);

}
//--------------------------------------------------------------
guiWindow::~guiWindow(){
	cout << "gui window destroyed" << endl;
}
void guiWindow::setup(){}
void guiWindow::setParent(testApp *p){
	parent=p;
}
void guiWindow::draw(){

	parent->gui.draw();
}

void guiWindow::dragEvent(ofDragInfo dragInfo, ofxFenster* win){
    parent->dragEvent(dragInfo);
}
void guiWindow::windowMoved(int x,int y){
    //printf("window moved!\n");
}

//----------------------------------------------------------------------

kinectWindow::~kinectWindow(){
	cout << "kinect window destroyed" << endl;
}
void kinectWindow::setup(){
	ofSetBackgroundAuto(false);
}
void kinectWindow::setParent(testApp *p){
	parent=p;
}
void kinectWindow::draw(){
	parent->kinect.drawDepth(0,0,ofGetWidth(),ofGetHeight());
}
void kinectWindow::mousePressed( int x, int y, int button ){
	ofVec3f w=parent->kinect.getWorldCoordinateAt(x*2, y*2);
	printf("world coord at %i,%i : %02f,%02f,%02f\n",x*2,y*2,w.x,w.y,w.z);
}


//--------------------------------------------------------------
void testApp::setup(){
	int midiPort=0;
	midiChannel=0;
	useKinect=true;
	kinectWin=new kinectWindow();
	ofxFenster* kw=ofxFensterManager::get()->createFenster(0, 0,  320, 240, OF_WINDOW);
	kw->setWindowTitle("kinect");
	kw->addListener(kinectWin);
	kinectWin->setup();
	kinectWin->setParent(this);

	// enable depth->video image calibration
	kinect.setRegistration(true); //true);

	kinect.init(true);
	//kinect.init(true); // shows infrared instead of RGB video image
	//kinect.init(false, false); // disable video image (faster fps)

	kinect.open();		// opens first available kinect
	//kinect.open(1);	// open a kinect by id, starting with 0 (sorted by serial # lexicographically))
	//kinect.open("A00362A08602047A");	// open a kinect using it's unique serial #


	if( !XML.loadFile("settings.xml") ){
		printf("unable to load settings.xml check data/ folder\n");
	}else{
		printf("settings loaded!\n");
		midiPort=ofToInt(XML.getAttribute("liveEngine", "port", "0")); //default to 0/all
		midiChannel=ofToInt(XML.getAttribute("liveEngine", "channel", "0"));
		if (midiChannel) printf("listening on port %d, midi channel %d\n",midiPort,midiChannel);
		else printf("listening on port %d, all midi channels\n",midiPort);
		if(XML.pushTag("liveEngine")) {
		    int numViews=XML.getNumTags("viewport");
		    if(numViews) {
			for (int i=0;i<numViews;i++) {
				int w=XML.getAttribute("viewport", "w",0,i);
				int h=XML.getAttribute("viewport", "h",0,i);
				int x=XML.getAttribute("viewport", "x",0,i);
				int y=XML.getAttribute("viewport", "y",0,i);
				int rot=XML.getAttribute("viewport", "rot",0,i);
				int ox=XML.getAttribute("viewport", "ox",0,i);
				int oy=XML.getAttribute("viewport", "oy",0,i);
				printf("viewport %i: %ix%i\n",i,w,h);
				viewports.push_back(new viewport(w,h,x,y,rot,ox,oy));
				viewports[i]->setKinect(&kinect);
				XML.pushTag("viewport",i);
					vector<string>keys;
					XML.getAttributeNames("settings", keys, 0);
					map<string,float>settings;
					for (int k=0;k<keys.size();k++) {
						settings[keys[k]]=XML.getAttribute("settings",keys[k],0.0f,0);
					}
					viewports[i]->setcam(settings);
				XML.popTag();
			    }
		    }
		    else printf("no viewports!\n");

		    XML.popTag();

		}

	}



	activeView=-1;

	midiIn.listPorts();
	midiIn.openPort(midiPort);
	midiIn.addListener(this);


	showFPS=false;
	ofBackground(0,0,0);

	ofSetBackgroundAuto(false);

	ofSetFrameRate(60);


	//preview window stuff
	prevWin=new previewWindow();
	win=ofxFensterManager::get()->createFenster(0, 0,  512,384, OF_WINDOW);
	ofAddListener(win->events.mouseDragged, this, &testApp::mousePressedEvent);
	ofAddListener(win->events.mousePressed, this, &testApp::mousePressedEvent);
	ofAddListener(win->events.keyPressed, this, &testApp::keyPressedEvent);
	win->setWindowTitle("preview");
	win->addListener(prevWin);
	prevWin->setup();
	prevWin->setBuffer(&viewports[0]->rb2);

	fullscreenoutput=false;

	guiWin=new guiWindow();
	gui.setup("","panel.xml",0,0);
	/*
	gui.add(reversemain.setup("reverse main", false));
	gui.add(controlColours.setup("control colours", false));
	gui.add(noteRandomiseColours.setup("randomise note colours", false));
	gui.add(transparentBlack.setup("transparent black", false));
	gui.add(resetDrawscale.setup("reset draw scale"));
	gui.add(resetFBscale.setup("reset FB scale"));
	gui.add(drawCloud.setup("draw pointCloud",false));
	*/

	gui.add(logo.setup("logo",false));
	gui.add(add.setup("add",false));
	gui.add(usecolour.setup("add",false));


	fade=255;
	gui.add(fadectl.setup("fade level",fade,0,255,255));
	decimate=1.0f;
	gui.add(decimatectl.setup("decimate",decimate,0,1.0f,255));

	featuresize=1.0f;
	gui.add(featurectl.setup("featuresize",featuresize,0,16.0f,255));

	gui.add(pointsMode.setup("points",true));
	gui.add(linesMode.setup("lines",false));
	gui.add(polysMode.setup("polys",false));
	drawMode=POINTS;

	pointsMode.addListener(this,&testApp::pointsModeSet);
	linesMode.addListener(this,&testApp::linesModeSet);
	polysMode.addListener(this,&testApp::polysModeSet);

	range=5000;
	gui.add(rangectl.setup("max range",range,0,5000,255));
	xrot=0.0f;
	gui.add(xrotctl.setup("x rotate",xrot,-1.0f,1.0f,255));
	yrot=0.0f;
	gui.add(yrotctl.setup("y rotate",yrot,-1.0f,1.0f,255));
	zrot=0.0f;
	gui.add(zrotctl.setup("z rotate",zrot,-1.0f,1.0f,255));

	gui.add(resetDrawscale.setup("resetdraw"));
	gui.add(resetFBscale.setup("resetFB"));
	gui.add(resetSlide.setup("resetSlide"));

	resetDrawscale.addListener(this,&testApp::resetDrawscalePressed);
	resetFBscale.addListener(this,&testApp::resetFBscalePressed);
    resetSlide.addListener(this,&testApp::resetSlidePressed);

	//gui window stuff
	ofxFenster* win2=ofxFensterManager::get()->createFenster(0, 0,  200, 400, OF_WINDOW);

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

	win2->setWindowTitle("config");
	win2->addListener(guiWin);
	guiWin->setup();
	guiWin->setParent(this);

int values[2];
glGetIntegerv(GL_POINT_SIZE_RANGE, values);
for (int i=0; i<3; i++){
printf("GLPOINTSIZE = %d\n", values[i]);
}
}

void testApp::resetDrawscalePressed(bool & set) {
    for (int i=0;i<viewports.size();i++) viewports[i]->scale=1.0f;
}
void testApp::resetFBscalePressed(bool & set) {
    for (int i=0;i<viewports.size();i++) viewports[i]->fscale=1.0f;
}
void testApp::resetSlidePressed(bool & set) {
    for (int i=0;i<viewports.size();i++) {
        viewports[i]->xshift=0;
        viewports[i]->yshift=0;
    }
}

void testApp::pointsModeSet(bool & set){
	drawMode=POINTS;
	//pointsMode=true; //segfaults!?
	//linesMode=false;
	//polysMode=false;
}
void testApp::linesModeSet(bool & set){
	drawMode=LINES;
	//pointsMode=true;
	//linesMode=true;
	//polysMode=false;
}
void testApp::polysModeSet(bool & set){
	drawMode=POLYS;
	//pointsMode=false;
	//linesMode=false;
	//polysMode=true;
}

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

	kinect.update();
}
void testApp::saveSettings(string filename){

    if(XML.pushTag("liveEngine")) {
        for (int i=0;i<viewports.size();i++){
	XML.pushTag("viewport",i);
	    vector<string>keys;
	    XML.getAttributeNames("settings", keys, 0);
	    for (int k=0;k<keys.size();k++) {
		XML.setAttribute("settings", keys[k], viewports[i]->getSetting(keys[k]),0);
	    }
	XML.popTag();
        }
        XML.popTag();
    }
    XML.saveFile(filename);
    printf("saved %s\n",filename.c_str());
}
//--------------------------------------------------------------
void testApp::draw(){

	for (int i=0;i<viewports.size();i++) {
		viewports[i]->draw(drawMode,fade,decimate,featuresize,xrot,yrot,zrot,range,add,logo,usecolour);
	}

}

//--------------------------------------------------------------
void testApp::keyPressed(int key, ofxFenster* win){
	if(key == ' '){
			fullscreenoutput=!fullscreenoutput;
			win->setFullscreen(fullscreenoutput);
			printf("resolution: %ix%i %s\n",win->getWidth(),win->getHeight(),fullscreenoutput?"fullscreen":"windowed");
	}
	else keyPressed(key);
}
void testApp::keyPressed(int key){

    	//if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->keyPressed(key);
        //else if (activeView<viewports.size()) viewports[activeView]->keyPressed(key);


        if (key>='0' && key <='5'){
            activeView=min(key-'2',(int)viewports.size());
            switch (activeView){
                case -2:
                    printf("deactivating viewport adjustment\n");
                    break;
                case -1:
                    printf("adjusting all viewports\n");
                    break;
                case 0:
                case 1:
                case 2:
                case 3:
                    printf("adjusting viewport %i\n",activeView );
                    break;
            }
        }

		if(key == 'p'){
		    saveSettings("settings.xml");
			printf("settings saved!\n");
		}
		if(key == 'f'){
			toggleFPS();
		}

		if(key == 'z'){
		    if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->camera.enableAllInput();
		    else if (activeView<viewports.size()) viewports[activeView]->camera.enableAllInput();
		}
		if(key == 'x'){
			if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->camera.disableAllInput();
		    else if (activeView<viewports.size()) viewports[activeView]->camera.disableAllInput();
		}
		if(key == 'q'){
		    if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->xrot=0;
		    else if (activeView<viewports.size()) viewports[activeView]->xrot=0;
		}
		if(key == 'w'){
		    if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->yrot=0;
		    else if (activeView<viewports.size()) viewports[activeView]->yrot=0;
		}
		if(key == 'e'){
		    if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->zrot=0;
		    else if (activeView<viewports.size()) viewports[activeView]->zrot=0;
		}
}

//--------------------------------------------------------------
void testApp::keyReleased(int key){
	//if (activeView<0) for (int i=0;i<viewports.size();i++) viewports[i]->keyReleased(key);
	//else if (activeView<viewports.size()) viewports[activeView]->keyReleased(key);
}

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

}

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

}

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


}
void testApp::mousePressed(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){
    if (DEBUG) printf("got draginfo: %s\n",dragInfo.files[0].c_str());
    int sta=dragInfo.files[0].find_last_of("\\/")+1;
    int len=(dragInfo.files[0].find_last_of(".")+4)-sta;
	string filename=dragInfo.files[0].substr(sta,len);
	printf("loading %s\n",filename.c_str());

	//list.load(filename);
}
void testApp::windowEvent(ofResizeEventArgs &args){
	printf("window event\n");
}

void testApp::mousePressedEvent(ofMouseEventArgs &args) {

	int xs=0;
	int ys=0;
	float sc=1.0f;
	float fs=1.0f;

	switch (args.button) {
		case 0:
			xs=args.x-(win->getWidth()/2);
			ys=args.y-(win->getHeight()/2);
			break;
		case 1:
			sc=pow(pow(args.x-(win->getWidth()/2),2)+pow(args.y-(win->getHeight()/2),2),0.5)/(win->getWidth()*.1);
			break;
		case 2:
			fs=(pow(pow(args.x-(win->getWidth()/2),2)+pow(args.y-(win->getHeight()/2),2),0.5)/(win->getWidth()))+0.5;
			break;
	}



	for (int i=0;i<viewports.size();i++) viewports[i]->mousePressedEvent(xs,ys,sc,fs);
}

void testApp::keyPressedEvent(ofKeyEventArgs &args) {
	//printf("window key pressed: %i (%c)\n",args.key,args.key);
	keyPressed(args.key);
}

void testApp::toggleFPS(){
	showFPS=!showFPS;
}

void testApp::newMidiMessage(ofxMidiEventArgs& eventArgs){

    //newMessage(eventArgs.port, eventArgs.channel, eventArgs.byteTwo, eventArgs.timestamp);

//byteOne : message type

    /*
    int 	port;
	int		channel;
	int 	status;
	int 	byteOne;
	int 	byteTwo;
	double 	timestamp;
	*/

    //printf("%d %d %d %d %d\n",eventArgs.port,eventArgs.channel,eventArgs.status,eventArgs.byteOne,eventArgs.byteTwo);

    bool noteOn; //this old thing!

    if ((midiChannel==0)||(eventArgs.channel==midiChannel)) {
        switch(eventArgs.status) {
            case 144: //noteon-off channel 0
                noteOn=(eventArgs.byteTwo==0?false:true);
                //for (int i=0;i<numLayers;i++){
                //    if (layers[i]->note==eventArgs.byteOne) layers[i]->setActive(noteOn);
                //}
                if (DEBUG) printf("note: %i %i\n",eventArgs.byteOne,eventArgs.byteTwo);

                break;
            case 176: //control change channel 0
                //for (int i=0;i<numLayers;i++){
                //    if (layers[i]->mix==eventArgs.byteOne) layers[i]->setMixAmt(((float)eventArgs.byteTwo)/127.0f);
                //}
                if (DEBUG)  printf("cc: %i %i\n",eventArgs.byteOne,eventArgs.byteTwo);

        }
    }
}