#include "testApp.h"

//next. 
//the real project

//texture binding with normalised coords
void bindTexture(ofBaseHasTexture &t) {
    ofTexture &tex = t.getTextureReference();
    tex.bind();

    glMatrixMode(GL_TEXTURE);
    glPushMatrix();
    glLoadIdentity();

    ofTextureData texData = tex.getTextureData();
    if(texData.textureTarget == GL_TEXTURE_RECTANGLE_ARB) {
        glScalef(tex.getWidth(), tex.getHeight(), 1.0f);
    } else {
        glScalef(tex.getWidth() / texData.tex_w, tex.getHeight() / texData.tex_h, 1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
}
void unbindTexture(ofBaseHasTexture &t) {
    t.getTextureReference().unbind();

    glMatrixMode(GL_TEXTURE);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
}
//--------------------------------------------------------------
void testApp::setup() {

    ofSetLogLevel(OF_LOG_NOTICE);

    verdana.loadFont(ofToDataPath("verdana.ttf"), 10);

    playing=0;
    numDevices=1;

    string filename="TRSS_nesbitt_recordings.xml";

    if( !XML.loadFile(filename) ){
        printf("unable to load recordings, check data/ folder\n");
    }else{
        if(XML.pushTag("TRSS")) {
            int num=XML.getNumTags("rec");
            if(num) {
                for (int i=0;i<num;i++) {
                    record rec;
                    rec.data.push_back(XML.getAttribute("rec","left","",i));
                    rec.data.push_back(XML.getAttribute("rec","right","",i));
                    rec.audio=XML.getAttribute("rec","audio","",i);
                    recs.push_back(rec);
                }
            }
            else printf("no recordings!\n");
        }
    }
    for (int deviceID = 0; deviceID < numDevices; deviceID++){

        //openNIPlayers[deviceID].stop();
        openNIPlayers[deviceID].setup(true);
        openNIPlayers[deviceID].start();
        //openNIPlayers[deviceID].startPlayer(ofToDataPath(recs[playing][deviceID]));
    }
    soundplayer.setLoop(false);
    startPlayers();

    //ofSetFrameRate(25.0f);
    offset=0.0f;
    drawmovies=false;drawcloud=true;
    frame=0;

    target.setPosition(0,0,0);
    camera.setPosition(0,0,-500);
    camera.lookAt(target,ofVec3f(0,1,0));

    //point_texture.loadImage("spriteA.png");

}

void testApp::startPlayers(){
    for (int deviceID = 0; deviceID < numDevices; deviceID++){
        //openNIPlayers[deviceID].stop();
        openNIPlayers[deviceID].setup(true);
        usleep(100000);
        openNIPlayers[deviceID].setMirror(true); //?
        openNIPlayers[deviceID].start();
        openNIPlayers[deviceID].startPlayer(ofToDataPath(recs[playing].data[deviceID]));
        //openNIPlayers[deviceID].setSpeed(0.01f);
        //openNIPlayers[deviceID].setPaused(true);
    
    
        soundplayer.stop();
        
        if (recs[playing].audio!=""){
            soundplayer.loadSound(recs[playing].audio);
            soundplayer.play();
            soundplayer.setPosition(offset);
        }
    }
}

//--------------------------------------------------------------
void testApp::update(){
    for (int deviceID = 0; deviceID < numDevices; deviceID++){
            //openNIPlayers[deviceID].setFrame(frame);
            openNIPlayers[deviceID].update();
    }
}

//--------------------------------------------------------------
void testApp::draw(){
    ofBackground(0,0,0);
	ofSetColor(255, 255, 255);

    
/*
    glEnable(GL_PROGRAM_POINT_SIZE);
    glEnable(GL_POINT_SMOOTH);
    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);

    glPointSize(12.0f);
 */

    glEnable( GL_POINT_SPRITE ); // GL_POINT_SPRITE_ARB if you're
                                 // using the functionality as an extension.

    glEnable( GL_POINT_SMOOTH );
    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glPointSize( 2.0 );

    

    //glActiveTexture(GL_TEXTURE0);
    //glEnable( GL_TEXTURE_2D );
    //glTexEnv(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
    //glTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    //glBindTexture(GL_TEXTURE_2D, texture_name);
    //bindTexture(point_texture);
    //ofEnablePointSprites();

    for (int deviceID = 0; deviceID < numDevices; deviceID++){

       if (drawmovies) {
            ofTranslate(0, deviceID * 400);
            //openNIPlayers[deviceID].drawDebug();
            openNIPlayers[deviceID].drawDepth(50, 0,520,390);
            openNIPlayers[deviceID].drawImage(600, 0,520,390);
        }

        //construct points
        //glBegin(GL_POINTS);
        //how to find buffer size?
        /*
        XnStatus xn::DepthGenerator::ConvertProjectiveToRealWorld   (   XnUInt32    nCount,
        const XnPoint3D     aProjective[],
        XnPoint3D   aRealWorld[]     
        )  
        */ 

        if (drawcloud) {

            camera.begin();

            ofPushMatrix();
            
            ofRotateY(ofGetElapsedTimef()*2.0f);
            ofTranslate(0,0,-1100);
            

            
            
            ofDrawAxis(100);

            int count;
            const XnDepthPixel* depthmap=openNIPlayers[deviceID].getDepthGenerator().GetDepthMap();
            const ofPixels& pixels=openNIPlayers[deviceID].getImagePixels();
            int range=1500;

            int step=pixels.getWidth()/openNIPlayers[deviceID].getWidth();

            int dmw=openNIPlayers[deviceID].getWidth();

                //for (int i=0;i<openNIPlayers[deviceID].getWidth();i+=20) {

                    

                    //for (int j=0;j<openNIPlayers[deviceID].getHeight();j+=20) {

                        for (int o=0;o<100;o++) { //100 new points per frame

                        int i=ofRandom(openNIPlayers[deviceID].getWidth());
                        int j=ofRandom(openNIPlayers[deviceID].getHeight());

                        ofPoint p= openNIPlayers[deviceID].projectiveToWorld(ofPoint(i,j,(float)depthmap[j*dmw+i]));
                        //ofPoint p= projectiveToWorld(ofPoint(i,j,(float)depthmap[j*dmw+i]));
                        
                        if (p.z <100 || p.z>range) continue;    // gets rid of background -> still a bit weird if userID > 0... //&& isCPBkgnd
                        //ofColor color = kinect->getColorAt(x,y); //userID);
                        //if (col) glColor4ub((unsigned char)color.r, (unsigned char)color.g, (unsigned char)color.b, (unsigned char)color.a);
                       // else 

                        points.push_back(fpoint(p.x, p.y, p.z,pixels[((j*step*dmw)+(i*step))*3],pixels[((j*step*dmw)+(i*step))*3]+1,pixels[((j*step*dmw)+(i*step))*3]+2,20,0.5));


                        //glColor4ub((unsigned char)255, (unsigned char)255, (unsigned char)255, (unsigned char)255);
                        //glColor4ub(pixels[((j*step*dmw)+(i*step))*3],pixels[((j*step*dmw)+(i*step))*3]+1,pixels[((j*step*dmw)+(i*step))*3]+2, (unsigned char)255);
                        //glVertex3f(p.x, p.y, p.z);
                        //if (i==320&&j==160) cerr<<"world point: "<<p.x<<","<<p.y<<","<<p.z<<endl;

                    }
                    //}
                    
                //}

                glBegin(GL_POINTS);
            
            int p=0;
                    while (p < points.size()) {
                        if (points[p].draw()) {
                            points.erase( points.begin() + p );
                        } else {
                            ++p;
                        }
                    }

                    glEnd();

            //export for fast/ switchable playback
            //figure out how to line up (could be one off)
                //export frame and find matching coords
                //manually find positions
                //calculate offset
            //audio sync
            //gui
            //audio analysis
            //sfx for point cloud

            //

            ofPopMatrix();

            camera.end();

            glDisable(GL_PROGRAM_POINT_SIZE);

        }
    }

    //ofDisablePointSprites();
    //unbindTexture(point_texture);

	ofSetColor(255, 255, 255);
	string msg = "MILLIS: " + ofToString(ofGetElapsedTimeMillis());
    msg += "\nFPS: " + ofToString(ofGetFrameRate());
	msg += "\noffset: "+ofToString(offset);
    verdana.drawString(msg, 10, 10);
}

//--------------------------------------------------------------
void testApp::exit(){
    for (int deviceID = 0; deviceID < numDevices; deviceID++){
        openNIPlayers[deviceID].stop();
    }
}

//--------------------------------------------------------------
void testApp::keyPressed(int key){
    bool changed=false;
    switch (key) {
        case ',':
            if (playing==0) playing=recs.size();
            playing--;
            changed=true;
            break;
        case '.':
            playing=(playing+1)%recs.size();
            changed=true;
            break;
        case 'z':
            offset+=.025;
            break;
        case 'x':
            offset-=.025;
            break;
        case 'q':
            drawmovies=!drawmovies;
            break;
        case 'w':
            drawcloud=!drawcloud;
            break;
        case 'a':
            frame--;
            if (frame<0) frame=openNIPlayers[0].getTotalNumFrames()-1;
            break;
        case 's':
            frame=((frame+1)%openNIPlayers[0].getTotalNumFrames());
            break;
    }
    if (changed) startPlayers();

    /* why do this?
    switch (key) {
        case 't':
            for (int deviceID = 0; deviceID < numDevices; deviceID++){
                openNIRecorders[deviceID].toggleRegister();
            }
            break;
        case 'x':
            for (int deviceID = 0; deviceID < numDevices; deviceID++){
                openNIRecorders[deviceID].stop();
            }
            break;
        default:
            break;
    }
    */
}

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

}

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

}