/*******************************************************************************************************************************************************

Projekt:          Konzept eines möglichen Processing-MP3-Players mit Spektrumsanalyse und Visualisierung derselben mittels eines Feldes von
                  3-Dimensionalen Kuben

Beteiligte:       Marc Haemmerle u. Thomas Goethe

Bemerkung:        Die Methoden zur Anzeige der Gesamtdauer und der bereits gespielten Dauer eines Musikstückes sind vorhanden, aber durch
                  die jetzige Version von ESS noch nicht anwendbar =/
                
Verbesserungs-
möglichkeiten:    * Komplette gewohnte Playersteuerung andenken
                  * Titel aus den ID3-Tags auslesen
                  * Menue zur Ansicht der verfügbaren Steuerungsmöglichkeiten
                  * Alben abspielen / unterschiedliche Playlisten -> neuer Navigations"ring" mit offenen "Enden"

*******************************************************************************************************************************************************/


// Benoetigte Bibliotheken importieren
import processing.opengl.*;
import krister.Ess.*;
import proxml.*;

import gestalt.p5.Ge;
import gestalt.shape.Cube;

import java.util.Iterator;
import java.util.LinkedList;

/*****************************************************************************************************************************************/

// Globale Variablen fuer das Interface
int play = -1;
int songToPlay = -1; //startmarkierung
float dauer=3.30,gelaufen=0.00;
PlayerInterface myInterface;
int outerRadius = 60; //Aussmass des Interface
int innerRadius = 30;  //Inneregrenze des Interface

/*****************************************************************************************************************************************/

// Arrayposition des gerade abgespielten MP3s
int currentPlaylistPosition;
int playlistLength;

// ++++++++++++++++

boolean isStarted = false;

// ++++++++++++++++


// XML-Dokument
XMLInOut xmlIO;

// Positionsvariablen fuer die 3D-Navigation
float xmag, ymag = 0;
float newXmag, newYmag = 0;

/*****************************************************************************************************************************************/

// ESS Variable - Stream
AudioStream myStream;
// ESS Variable - Datei, die *gerade* gestreamt wird
AudioFile myFile;

// Globale Lautstaerkeeinstellung
float myVolume = 1.0;

// ESS Variable - Objekt fuer FFT-Berechnungen
FFT myFFT;

/*****************************************************************************************************************************************/

// Fontvariable der Menueueberschriften
PFont menuHeaderFont;

// Anzahl angezeigter Frequenzbaender
int xCount = 50;
// Breite der Frequenzbaender
int yCount = 32;
// Array zur Speicherung des Visualisierungsrasters
float[][] stageArray = new float[xCount][yCount];

float x,y;

// Array zur Verwaltung der Cube-Geometrien
Cube[] myCube = new Cube[xCount*yCount];

// Serveradresse auf der die MP3's und die Playlist liegen
String serverAdress = "http://www.no7hing.com/dev/processing/p5mp3/";
//String serverAdress = "http://localhost/gc/";

// Playliste fuer ausgelesene MP3's
LinkedList mp3Playlist = new LinkedList();

// Instanzvariable fuer Visualizer
Visualizer viz;

// Horizontale Korrekturdistanz zum Ausgleich des POI
float horizontalCorrection;

/*****************************************************************************************************************************************/

void setup() {
  // Sketchgroesse einstellen und OPENGL verwenden
  size(1200,780,OPENGL);
  
  frameRate(24);
  background(30);
  
  // Wir fangen bei der ersten Position an
  currentPlaylistPosition = 0;
    
  // Schriftart Menueueberschrift
  menuHeaderFont = loadFont("CenturyGothic-Italic-11.vlw");
  
  // Visualisierungsarray mit 0-en fuellen
  for(int x=0;x<stageArray.length;x++){
    for(int y=0;y<stageArray[0].length;y++){
      stageArray[x][y] = 0.0;
    }
  }
  
  // XML-Bibliothek initialisieren
  xmlIO = new XMLInOut(this);
  
  // XML-Datei vom Server laden
  xmlIO.loadElement(serverAdress + "getPlaylist.php");
    
  // Gestalt initialisieren
  Ge.setup(this);
  
  // Kuben erzeugen - die Borg lassen gruessen und Picard bekommt Angst ;)
  for(int i=0;i<myCube.length;i++){
    myCube[i] = Ge.cube();
  }
  
  // Gestalt-Kamera einstellen - Einstellungen von einem Tutorial übernommen
  Ge.camera().setMode(Ge.CAMERA_MODE_LOOK_AT);
  
  horizontalCorrection = (width - xCount*20)/2;
  
  Ge.camera().position().set(width / 2 - horizontalCorrection, height, 0);
  Ge.camera().lookat.set(width/2 - horizontalCorrection, 0, 0);
  Ge.camera().upvector.set(0, 0, 1);
}

/*****************************************************************************************************************************************/

// Wird aufgerufen, wenn die Playliste geladen wurde
void startSound(){
  // Visualizerklasse instanzieren
  viz = new Visualizer();
  
  play = songToPlay = 0;

  // ESS Soundbibliothek starten
  Ess.start(this);
   
  // abzuspielende Datei zuweisen
  myFile = new AudioFile( mp3Playlist.get(currentPlaylistPosition).toString(),0,Ess.READ);

  // neuen Audiostream zuweisen
  myStream = new AudioStream();
  
  // holt sich die Samplerate automatisch aus dem MP3
  myStream.sampleRate(myFile.sampleRate);
  
  // Falls einzelne Samples zu laut sind werden sie sanft abgedreht
  myStream.softClip = true;

  // Beginnt mit der Wiedergabe
  myStream.start();
  
  // Lautstaerke einstellen
  Ess.masterVolume(1);
  
  // FFT mit 512 Stufen initialisieren
  myFFT = new FFT(512);
  // FFT-Daten normalisieren
  myFFT.limits();
  // FFT-Daten mittels Durchschnitt(-sberechnung) auf 32 Baender reduzieren
  myFFT.averages(32);
  
  // Ja, jetzt laeuft das Teil
  isStarted = true;
}

/*****************************************************************************************************************************************/

void draw() {
  // nur Ausfuehren, wenn die Applikation gestartet ist - also momentan nach laden des XML's
  if(isStarted){  
    // Screen mit Farbe ueberzeichnen
    background(30);

    // Visualisierung zeichnen
    viz.update();

    // Navigation zeichnen
    // navigation wird hier spaeter gezeichnet
    myInterface.zeichnen(songToPlay);
    //gelaufen=gelaufen+0.08; //uhr hochzaehlen
    //myInterface.zeigeDauer(dauer, gelaufen); //Uhr mit daueranzeige geht nur mit einstelligen minuten 
  }
}

/*****************************************************************************************************************************************/

// Klasse zur Darstellung des momentanen Spektrums als Feld von animierten 3D-Kuben
class Visualizer{
  
  // Konstruktor
  Visualizer(){
    // Keine Initialisierung noetig
  }
  
  // Methoden
  void update() {
    noStroke();
    
    // Funktion zum Loeschen der ersten Arrayposition wird aufgerufen
    deleteIndex(0);
    // gleich im Anschluss wird neuer Arrayteil mit neuen Spektrumsdaten angehaengt
    appendIndex();  
   
    // allgemeinen Lichtlevel einstellen 
    ambientLight(255, 255, 255);
    // ein direktionales Licht definieren
    directionalLight(204, 204, 204, 0, 1, -1);
  
    // Faktor für Kamerarotation in Abhaengigkeit von horizontaler Mausposition
    newXmag = mouseX/float(width*3) * TWO_PI;
    // Faktor für Kamerarotation in Abhaengigkeit von vertikaler Mausposition
    newYmag = mouseY/float(height*3) * TWO_PI;
    
    // Faktor schrittweise bis zum Erreichen der ausgerechneten Position erhoehen
    float diff = xmag - newXmag;
    if (abs(diff) > 0.01){
      xmag -= diff/4.0;
    }
    
    // Faktor schrittweise bis zum Erreichen der ausgerechneten Position erhoehen
    diff = ymag - newYmag;
    if (abs(diff) > 0.01){
      ymag -= diff / 4.0;
    }

    // Kameraposition wird mit obigen Faktoren eingestellt
    Ge.camera().position().set((width / 2 - horizontalCorrection)*xmag, height * 1.5, height * 0.5 * ymag);

    // simple Zaehlvariable für den Array mit den Kuben
    int countCube = 0;

    // Rekursiver Array zum Positionieren, Skalieren und einfaerben der Spektrumskuben
    for(int x=0;x<stageArray.length;x++){
      for(int y=0;y<stageArray[0].length;y++){	        

        // Multiplikator zum uebergreifenderen Einstellen der Farben
        float myMultiplier = 256.0 / 100.0;
        // Rotton ausrechnen
        float myR = 40/myMultiplier/80;
        // Gruenton ausrechnen
        float myG = (x+1)*(y+2)/5/myMultiplier/80;
        // Blauton ausrechnen
        float myB = (y+6)*15/myMultiplier/80;
        // Alphawert ausrechnen
        float myA = (x+6)*(stageArray[0].length-y+1)/3/myMultiplier/70;
        
        // Kuben skalieren          
        myCube[countCube].scale().set(20, 20, max(1.0,stageArray[x][y]));
        // Kuben einfaerben
        myCube[countCube].material().getColor().set(myR, myG, myB, myA);
        // Kuben positionieren          
        myCube[countCube].position().set(x*20,y*20);
        
        // Variable zuruecksetzen       
        countCube++;
      }
    }

    //hint(DISABLE_DEPTH_TEST);
  }

  // Methode zum Loeschen eines Arrayindizes
  void deleteIndex(int id) {
    int length1 = stageArray.length;
    int length2 = stageArray[0].length;
	   
    float tmp[][] = new float[length1-1][length2];
    int cnt = 0;
    for(int i=0; i<length1; i++) {
      if(i != id){
        for(int j=0; j<length2; j++){
          tmp[cnt][j] = stageArray[i][j];
        }
        cnt++;
      }
    }
    stageArray=tmp;
  } 

  // Methode zum Anhaengen eines Arrayindizes
  void appendIndex() {
    int length1 = stageArray.length;
    int length2 = stageArray[0].length;
	   
    float tmp[][] = new float[length1+1][length2];
	  
    int cnt = 0;
    for(int i=0; i<tmp.length; i++) {
      if(cnt != length1){
        for(int j=0; j<length2; j++){
          tmp[i][j] = stageArray[cnt][j];
        }
      } else {
        // Spektrum des aktuellen Samplepuffers auslesen
        myFFT.getSpectrum(myStream);
        for(int k=0; k<length2; k++){
          // FFT des aktuellen Spektrumpuffers ausrechnen und Durchschnitte berechnen
          float temp=max(0,myFFT.averages[k]*1000);
	  tmp[i][k] = temp;
        }
      }
      cnt++;
    }
    stageArray=tmp;
  } 
}

/*****************************************************************************************************************************************/

void keyReleased(){
  // Lautstaerke senken
  if(keyCode == 521 || keyCode == 107){
    if(myVolume < 2.8){
      myVolume += 0.2;
      Ess.masterVolume(myVolume);
    }
  }
  
  // Lautstaerke erhoehen
  if(keyCode == 109 || keyCode == 45){
    if(myVolume >= 0.2){
      myVolume -= 0.2;
      Ess.masterVolume(myVolume);
    }
  }
  
  // Auswahl durch Enter
  if (keyCode == ENTER){
    play = songToPlay;
    
    currentPlaylistPosition = play;
    
    myFile.close();
    myFile.open(mp3Playlist.get(currentPlaylistPosition).toString(),0,Ess.READ);
  }
  
  //println(keyCode);
}

/*****************************************************************************************************************************************/

// temporaeres Zeuchs fuer das skippen von Liedern
void keyPressed() {
  // Steuerung des Interfaces mit Cursortasten und Enter
  if (keyCode == RIGHT) {    
    if(songToPlay == (playlistLength-1)){
      songToPlay = 0;
    } else {
      songToPlay++;
    }
  } else if (keyCode == LEFT){
    if(songToPlay == 0){
      songToPlay = playlistLength-1;
    } else {
      songToPlay--;
    }
  }
}

/*****************************************************************************************************************************************/

// wird anscheinend aus der ESS Klasse heraus aufgerufen ...
void audioStreamWrite(AudioStream theStream) {
  
  // ... und wenns folgendes weg ist gibt's keine Musik - aus dem ESS Tutorial entnommen
  int samplesRead=myFile.read(myStream);

  if (samplesRead==0) {
    
    isStarted = false;
    
    if(currentPlaylistPosition == (playlistLength-1)){
      currentPlaylistPosition = 0;
    } else {
      currentPlaylistPosition++;
    }
       
    play = songToPlay = currentPlaylistPosition;

    myFile.close();
    myFile.open(mp3Playlist.get(currentPlaylistPosition).toString(),0,Ess.READ);
    samplesRead = myFile.read(myStream);

    isStarted = true;
  }
}

/*****************************************************************************************************************************************/

// Listener fuer Events der XML-Klasse
void xmlEvent(XMLElement element){
 
  XMLElement mp3Node;
  playlistLength = element.countChildren();
  
  for(int i=0; i < element.countChildren(); i++){
    mp3Node = element.getChild(i);
    String[] testAttr = mp3Node.getAttributes();
    String mp3FullPath = serverAdress + mp3Node.getAttribute(testAttr[2]) + mp3Node.getAttribute(testAttr[0]);
    mp3Playlist.add(mp3FullPath);
  }
  
  myInterface = new PlayerInterface(playlistLength, 60, 30, width-60-20, height-60-20);
  startSound();  
}

/*****************************************************************************************************************************************/

// we are done, clean up Ess
public void stop() {
  Ess.stop();
  super.stop();
}

/*****************************************************************************************************************************************/

// Zeichenklasse fuer Kreissegmente
class PlayerInterface {
  // Variablen
  int r; //aeusserer Radius
  int r2; //innerer Radius
  int anzK; //segmentanzahl
  int posX; //XPosition
  int posY; //YPosition
  int faktor = 2; //Teilung des einzelnen Segmentes in X elemente (so wirkt es runder)
  float a,winkel,num; //uebergabevariablen
  
  // Konstruktor
  PlayerInterface (int mp3, int radius1, int radius2, int positionX, int positionY){
    anzK = mp3;
    r = radius1;
    r2 = radius2;
    posX = positionX;
    posY = positionY;
    PFont font; //Schrift
    font = loadFont("ArialMT-16.vlw");
    textFont(font, 16);
  }

  // Methoden

  //Punkte fuer die Segmente
  float pointX(float winkelM){
    return cos(radians(winkelM))*r;
  }
  float pointY(float winkelM){
    return sin(radians(winkelM))*r;
  }
  float pointX1(float winkelM){
    return cos(radians(winkelM))*(r-r2);
  }
  float pointY1(float winkelM){
    return sin(radians(winkelM))*(r-r2);
  }

  //Segment wird erstellt
  void zeichneSegment(int segmentNum){
    // winkelausmass des elements
    winkel = 360.0 / anzK;  

    // abstand der segmente im element
    a = winkel / faktor;

    num = winkel * segmentNum;

    beginShape();
    vertex(pointX(num)+posX,pointY(num)+posY);
    vertex(pointX(num+a)+posX,pointY(num+a)+posY);

    for(int i=1;i<=faktor;i++){
      vertex(pointX(num+a*i)+posX,pointY(num+a*i)+posY);
    }

    for(int i=faktor;i>0;i--){
      vertex(pointX1(num+a*i)+posX,pointY1(num+a*i)+posY);
    }

    vertex(pointX1(num+a)+posX,pointY1(num+a)+posY);
    vertex(pointX1(num)+posX,pointY1(num)+posY);
    endShape(CLOSE);    
  }

  void zeichnen(int auswahlId){
    textAlign(RIGHT);
    for (int i=0;i<anzK;i++){
      if(auswahlId!=i){
        fill(255,255,255, 200);
      } else{
        fill(0,0,255, 200);
        text(mp3Playlist.get(i).toString(), posX-100, posY+r-25);
      }
      if(play==i){
        fill(100,0,0, 200);
        text(mp3Playlist.get(i).toString(), posX-100, posY+r-5);
      }
      myInterface.zeichneSegment(i);
    }
  }

  void zeigeDauer(float dauer,float aktPosition){
    float a;  //uebergabevariable
    text(aktPosition,posX-30,posY+5); //uhr
    fill(0,130,150,170);
    
    //umrechnen der aktPosition in winkelgroesse
    a=dauer/aktPosition;
    winkel=360/a;
    arc(posX, posY, r, r, 0, radians(winkel));
  }
}