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

//--------------------------------------------------------------
void ofApp::setup() {
	loadSettings("settings.xml");

	ofBackground(0,0,0);

	///ofSetVerticalSync(true);



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

    ofDisableLighting();
    //ofSetGlobalAmbientColor(ofColor(255,255,255));
    */

    fullscreen=false;
   	activeView=0;

    checkers=new ofImage[3];

    checkers[0].loadImage("checker_blue.png");
    checkers[1].loadImage("checker_green.png");
    checkers[2].loadImage("checker_red.png");

    int bufferSize= beat.getBufferSize(); //should be based on the size of glitch buffer

    soundStream.listDevices();
    //nb all you have to do to make audio work is to turn off pulseaudio in configuration
    soundStream.setup(this, 0, 1, 44100, bufferSize, 4);
    
    samples.resize(bufferSize);

    glitch1.setup(512,384,&samples);
    glitch2.setup(512,384,&samples);
    glitch3.setup(512,384,&samples);

    mode=MODE_RUN;

    kick=snare=hihat=false;

}

//--------------------------------------------------------------
void ofApp::update() {
	ofSetWindowTitle(ofToString(ofGetFrameRate()));

    if (mode==MODE_RUN){

        beat.update(ofGetElapsedTimeMillis());


        //if (ofRandom(10000)<3) glitch1.set_interp(ofRandom(18)+2,ofRandom(14)+2);
        //if (ofRandom(10000)<8) glitch2.set_interp(ofRandom(18)+2,ofRandom(14)+2);
        //if (ofRandom(10000)<20) glitch3.set_interp(ofRandom(18)+2,ofRandom(14)+2);
        if (beat.kick()>0.9){
            if (!kick){
                int which=ofRandom(3);
                switch (which) {
                    case 0:
                        glitch1.set_interp(ofRandom(18)+2,ofRandom(14)+2);
                        break;
                    case 1:
                        glitch2.set_interp(ofRandom(18)+2,ofRandom(14)+2);
                        break;
                    case 2:
                        glitch3.set_interp(ofRandom(18)+2,ofRandom(14)+2);
                        break;
                }
                kick=true;
            }
        }
        else {
            if (kick) kick=false;
        }

        if (beat.snare()>0.9){
            if (!snare){
                int which=ofRandom(3);
                switch (which) {
                    case 0:
                        glitch1.set_scale((ofRandom(100)*.002)+1.0);
                        break;
                    case 1:
                        glitch2.set_scale((ofRandom(100)*.002)+1.0);
                        break;
                    case 2:
                        glitch3.set_scale((ofRandom(100)*.002)+1.0);
                        break;
                }
                snare=true;
            }
        }
        else {
            if (snare) snare=false;
        }

        glitch1.update();
        glitch2.update();
        glitch3.update();
    }
}

void ofApp::audioIn(float * input, int bufferSize, int nChannels){
    for (int i=0;i<bufferSize/nChannels;i+=nChannels){
        samples[i]=input[i*nChannels];
    }
    beat.audioReceived(input, bufferSize, nChannels);
}

//--------------------------------------------------------------
void ofApp::draw() {
     //ofSetColor(255,255, 255);
     //glitch.draw(0,0);

    ofBaseHasTexture *texts[3];

    switch(mode) {
        case MODE_RUN:
            texts[0]=&glitch1.renderFBO;
            texts[1]=&glitch2.renderFBO;
            texts[2]=&glitch3.renderFBO;
            break;
        case MODE_CALIB:
            texts[0]=&checkers[0];
            texts[1]=&checkers[1];
            texts[2]=&checkers[2];
            break;
    }

	for (int i=0;i<views.size();i++) {
		views[i].setLight();
	}
	for (int i=0;i<views.size();i++) {
		//views[i].begin2d();
        views[i].begin();
       

        ofFill();
       
        bindTexture(*texts[0]);
        ofDrawSphere(0,0,0,145);
        unbindTexture(*texts[0]);

        bindTexture(*texts[1]);
        ofDrawSphere(200,290,0,75);
        unbindTexture(*texts[1]);

        bindTexture(*texts[2]);
        ofDrawSphere(-70,340,175,44);
        unbindTexture(*texts[2]);
        ofSetColor(255, 255,255);

        views[i].end();
	}
    
}

//--------------------------------------------------------------
void ofApp::exit() {
	
}

//--------------------------------------------------------------
void ofApp::keyPressed(int key){
	if (activeView<0) for (int i=0;i<views.size();i++) views[i].keyPressed(key);
	else if (activeView<views.size()) views[activeView].keyPressed(key);
    switch (key) {
    	case ' ':
			fullscreen=!fullscreen;
			ofSetFullscreen(fullscreen);
			break;
       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 '4':
            activeView=2;
            break;
		case 'p':
            saveSettings("settings.xml");
            break;
        case 'z':
            loadSettings("defaults.xml");
            break;
        case OF_KEY_LEFT:
            mode=mode-1;
            if (mode<0) mode=NUM_MODES-1;
            break;
       case OF_KEY_RIGHT:
            mode=(mode+1)%NUM_MODES;
            break;
        case '/':
            //light=!light;
            //printf(light?"LIGHT ON\n":"LIGHT OFF\n");
            break;
    }
    if (mode==MODE_RUN) glDisable (GL_DEPTH_TEST);
    else glEnable (GL_DEPTH_TEST);
}

void ofApp::keyReleased(int key){
	if (activeView<0) for (int i=0;i<views.size();i++) views[i].keyReleased(key);
	else if (activeView<views.size()) views[activeView].keyReleased(key);
}

void ofApp::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{
        if(XML.pushTag("map4")) {
            int numViews=XML.getNumTags("view");
            if(numViews) {
                views.resize(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();
                }
            }
            XML.popTag();
        }
        printf("loaded settings: %i views\n",views.size());
	}

    //numViews=2;
    //views[0].setup(ofGetScreenWidth()/2,ofGetScreenHeight(),0,0);
    //views[1].setup(ofGetScreenWidth()/2,ofGetScreenHeight(),ofGetScreenWidth()/2,0);
    //activeView=0;
}
//--------------------------------------------------------------
void ofApp::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
    if(XML.pushTag("map4")) {
        for (int i=0;i<views.size();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());
}

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