#include "testApp.h"
//--------------------------------------------------------------
testApp::~testApp(){
    saveSettings("settings.xml");
}
//--------------------------------------------------------------
void testApp::setup(){

    loadSettings("settings.xml");

	ofBackground(0,0,0);

	///ofSetVerticalSync(true);

    //some model / light stuff
    glEnable (GL_DEPTH_TEST);
    glShadeModel (GL_SMOOTH);
    glColorMaterial (GL_FRONT_AND_BACK, GL_DIFFUSE);
    glEnable (GL_COLOR_MATERIAL);

    printf("loading %s at %f,%f,%f",model_name.c_str(),model_x,model_y,model_z);

    //load the bottle model - the 3ds and the texture file need to be in the same folder

    model.loadModel(model_name, 1);
    model.setRotation(0, 180, 1, 0, 0);
    //model.setRotation(0, 90, 0, 1, 0);
    model.setPosition(model_x, model_y, model_z);


    //ofDisableArbTex();

   mode=DISPLAY;



   whichClip=0;
   texture.loadMovie(clips[whichClip]);
   texture.setLoopState(OF_LOOP_NORMAL);
   texture.play();

   light=true;

	camWidth 		= 320;	// try to grab at this size.
	camHeight 		= 240;

	vidGrabber.setVerbose(true);
	vidGrabber.listDevices();


	vidGrabber.setDeviceID(0);
	grabberAvailable=vidGrabber.initGrabber(camWidth,camHeight);
	//printf("asked for 320 by 240 - actual size is %i by %i\n", vidGrabber.width, vidGrabber.height);

	videoInverted 	= new unsigned char[camWidth*camHeight*3];
	videoTexture.allocate(camWidth,camHeight, GL_RGB);

	ard.connect("/dev/ttyUSB0", 57600);
	ofAddListener(ard.EInitialized, this, &testApp::setupArduino);
	bSetupArduino	= false;
	bSwitchArduino	= false;

}

//--------------------------------------------------------------
void testApp::update(){
    texture.idleMovie();

    if (mode==GRAB) {
        vidGrabber.grabFrame();

        if (vidGrabber.isFrameNew()){
            int totalPixels = camWidth*camHeight*3;
            unsigned char * pixels = vidGrabber.getPixels();
            for (int i = 0; i < totalPixels; i+=3){
                unsigned int bright= (pixels[i]>>2)+ (pixels[i+1]>>1)+(pixels[i+1]>>2);  //(0.2126*R) + (0.7152*G) + (0.0722*B)
                videoInverted[i] = (unsigned char)((226*bright)>>8);
                videoInverted[i+1] = (unsigned char)((200*bright)>>8);
                videoInverted[i+2] = (unsigned char)((20*bright)>>8);
            }
            videoTexture.loadData(videoInverted, camWidth,camHeight, GL_RGB);
        }
    }

    updateArduino();
}

//--------------------------------------------------------------
void testApp::setupArduino(const int & version) {

	// remove listener because we don't need it anymore
	ofRemoveListener(ard.EInitialized, this, &testApp::setupArduino);

	// this is where you setup all the pins and pin modes, etc
	for (int i = 0; i < 13; i++){
		ard.sendDigitalPinMode(i, ARD_OUTPUT);
	}
	ard.sendDigitalPinMode(7, ARD_INPUT);

	bSetupArduino = true;
	printf("arduino ready\n");
}

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

	// update the arduino, get any data or messages.
	ard.update();

	// do not send anything until the arduino has been set up
	if (bSetupArduino) {
		if (bSwitchArduino!=ard.getDigital(7)) {
			bSwitchArduino=ard.getDigital(7);
			printf("pin 7 %i\n",bSwitchArduino);
		}
	}
}

//--------------------------------------------------------------
void testApp::draw(){
	if (mode!=CALIBRATE&&bSetupArduino&!bSwitchArduino) return;
	for (int i=0;i<numViews;i++) {
	views[i].setLight();
	}
	if (light) glEnable(GL_LIGHTING);
	else glDisable(GL_LIGHTING);
	for (int i=0;i<numViews;i++) {
		views[i].begin();
        ofSetColor(255, 255, 255, 255);
        ofFill();
        switch(mode) {
            case CALIBRATE:
                drawBoard(0,225,0);
                ofPushMatrix();
                    ofRotate(90,0,1,0);
                    model.draw();
                ofPopMatrix();
                break;
            case DISPLAY:
                bindTexture(texture);
                ofPushMatrix();
                    ofRotate(90,0,1,0);
                    model.draw();
                ofPopMatrix();
                unbindTexture(texture);
                break;
            case GRAB:
                bindTex(videoTexture);
                ofPushMatrix();
                    ofRotate(90,0,1,0);
                    model.draw();
                ofPopMatrix();
                unbindTex(videoTexture);
                break;
			case NOTHING:
                bindTexture(texture);
				glPushMatrix();
                drawBox(50.0f);
                unbindTexture(texture);
				glPopMatrix();
                break;
        }
    views[i].end(mode==CALIBRATE);
	}
	if (mode==CALIBRATE) {
		ofSetHexColor(0xFFFFFF);
		ofDrawBitmapString("fps: "+ofToString(ofGetFrameRate(), 2), 10, 15);
	}
}

//--------------------------------------------------------------
void testApp::keyPressed(int key){
	if (activeView<0) for (int i=0;i<numViews;i++) views[i].keyPressed(key);
	else if (activeView<numViews) views[activeView].keyPressed(key);
    switch (key) {
       case '8':
            mode=CALIBRATE;
            break;
       case '9':
            mode=DISPLAY;
            break;
       case '0':
            mode=GRAB;
            break;
		case '1':
            activeView=-1;
            break;
		case '2':
            activeView=0;
            break;
		case '3':
            activeView=1;
            break;
		case 'p':
            saveSettings("settings.xml");
            break;
        case 'z':
            loadSettings("defaults.xml");
            break;
        case ',':
        case '<':
            whichClip--;
            if (whichClip<0) whichClip+=numClips;
            texture.stop();
            texture.loadMovie(clips[whichClip]);
            texture.play();
            break;
       case '.':
       case '>':
            whichClip=(whichClip+1)%numClips;
            texture.stop();
            texture.loadMovie(clips[whichClip]);
            texture.play();
            break;
        case '/':
            light=!light;
            printf(light?"LIGHT ON\n":"LIGHT OFF\n");
            break;
    }
}
//--------------------------------------------------------------
void testApp::keyReleased(int key){
	if (activeView<0) for (int i=0;i<numViews;i++) views[i].keyReleased(key);
	else if (activeView<numViews) views[activeView].keyReleased(key);
}

void testApp::loadSettings(string filename){
    //viewport settings are float/ normalised to 0..1
    if( !XML.loadFile(filename) ){
		printf("unable to load %s check data/ folder\n",filename.c_str());
	}else{
	    model_name=XML.getAttribute("map4","model","none",0);
	    model_x=ofToFloat(XML.getAttribute("map4","x","none",0));
	    model_y=ofToFloat(XML.getAttribute("map4","y","none",0));
	    model_z=ofToFloat(XML.getAttribute("map4","z","none",0));
        if(XML.pushTag("map4")) {
            numViews=XML.getNumTags("view");
            if(numViews) {
                views=new viewpoint[numViews];
                for (int i=0;i<numViews;i++){
                    XML.pushTag("view",i);
                        vector<string>keys;
                        XML.getAttributeNames("settings", keys, 0);
                        map<string,string>settings;
                        for (int k=0;k<keys.size();k++) {
                            settings[keys[k]]=XML.getAttribute("settings",keys[k],"none",0);
                        }
                        views[i].setup(settings);
                    XML.popTag();
                }
            }

            numClips=XML.getNumTags("clip");
            if (numClips) {
                clips=new string[numClips];
                for (int i=0;i< numClips;i++) {
                    XML.pushTag("clip",i);
                        clips[i]=XML.getAttribute("settings","file","none",0);
                    XML.popTag();
                }
            }

            XML.popTag();
            for (int i=0;i< numClips;i++) {
                printf("clip: %s\n",clips[i].c_str());
            }
        }
        printf("loaded settings: %i views\n",numViews);
	}

    //numViews=2;
    //views[0].setup(ofGetWidth()/2,ofGetHeight(),0,0);
    //views[1].setup(ofGetWidth()/2,ofGetHeight(),ofGetWidth()/2,0);
    //activeView=0;
}
//--------------------------------------------------------------
void testApp::saveSettings(string filename){
    //either re-navigate the whole thing OR
    //save the number to the vp OR
    //send a pointer to the vp

    //renavigate? easiest way to get the settings back out
    XML.setAttribute("map4","model",model_name,0);
	XML.setAttribute("map4","x",ofToString(model_x),0);
	XML.setAttribute("map4","y",ofToString(model_y),0);
	XML.setAttribute("map4","z",ofToString(model_z),0);
    if(XML.pushTag("map4")) {
        for (int i=0;i<numViews;i++){
            XML.pushTag("view",i);
                vector<string>keys;
                XML.getAttributeNames("settings", keys, 0);
                for (int k=0;k<keys.size();k++) {
                    XML.setAttribute("settings", keys[k], views[i].getSetting(keys[k]),0);
                }
            XML.popTag();
        }
        XML.popTag();
    }
    XML.saveFile(filename);
    printf("saved %s\n",filename.c_str());
}

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

}

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

}

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

}

//--------------------------------------------------------------
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){

}