import themidibus.*;
import processing.video.*;

MidiBus myBus; // The MidiBus

boolean weiter = true;

Capture cam;

//ArrayList, in der Durchschnittswerte der Pixel gespeichert werden
ArrayList<Pixel> pixelList = new ArrayList<Pixel>();

//Variablen zum Errechnen von Durchschnittswerten bei getAverage()
float farbe = 0;
float helligkeit = 0;
float averageFarbe = 0;
float averageHelligkeit = 0;
boolean transkribiert = false;

//Pixelobjekt, welche in ArrayList 'pixelList' gespeichert wird
Pixel myPixel;

//Zeigt an, ob Durchschnittswerte berechnet wurden
boolean gotAverage = false;

//Startpunkte zum Durchlaufen des Bildes bei getAverage()
int averageStartX1 = 0;
int averageStartY1 = 0;

//Varible, in der Frameshot gespeichert wird
PImage average;

void setup() {
  //Konfiguration Midi In/Out
  MidiBus.list();
  myBus = new MidiBus(this, "ProcessingIn", "LiveIn");



  size(640, 480);
  String[] cameras = Capture.list();

  //neues Pixelobjekt wird erstellt
  myPixel = new Pixel();

  if (cameras.length == 0) {
    println("There are no cameras available for capture.");
    exit();
  } else {
    println("Available cameras:");
    for (int i = 0; i < cameras.length; i++) {
      println(cameras[i]);
    }

    // The camera can be initialized directly using an
    // element from the array returned by list():
    cam = new Capture(this, cameras[0]);
    cam.start();
  }
}

void draw() {
  //Colormode wird auf HSB gesetzt, damit Helligkeit und Farbwert genutzt werden können
  colorMode(HSB, 100);

  if (cam.available() == true) {
    cam.read();
  }

  image(cam, 0, 0);
  // The following does the same, and is faster when just drawing the image
  // without any additional resizing, transformations, or tint.
  //set(0, 0, cam);


  if (keyPressed == true)
  {
    cam.stop();
    saveFrame("average.png");
    average = loadImage("average.png");
    transkribiert = true;
  }


  if (transkribiert == true)
  {
    getAverage();
  }
}

void getAverage()
{
  //Es soll immer ein Quadrat von 20x20 Pixeln analysiert werden und jeder
  //Durchschnittswert eines Feldes in die ArrayList 'pixelList' in
  //einem Pixelobjekt gespeichert werden.
  //Die erste For-Schleife sorgt dafür, dass der X-Wert beim Durchlaufen
  //nach jeden Quadrat um 20 Pixelstellen verschoben werden soll.
  for (int x = averageStartX1; x < average.width; x+=20)
  {
    //Hier wird überprüft, ob der Startwert zum Auswerten der Quadrate
    //schon am Bildschirmrand angelangt ist
    if (averageStartX1 <= (average.width-20) && weiter ==true)
    {
      //Pixel des Bildes 'average' werden geladen
      loadPixels();
      average.loadPixels();
      //Diese Schleife ist zum Durchlaufen jedes einzelnen 20x20 Quadrats zuständig
      for (int i = averageStartX1; i < averageStartX1+20; i++) {
        for (int j = averageStartY1; j < averageStartY1+20; j++) {
          int loc = i + j * width;
          //Alternative zur Pixelanalyse von pixels[loc]
          //color pixel = average.get(averageStartX1+i, averageStartY1+j);
          color pixel = pixels[loc];
          //Farbewert und Helligkeit des Pixels werden in Variablen überschrieben
          farbe = hue(pixel);
          //println(farbe +"FARBE");
          helligkeit = brightness(pixel);
          //println("HELLIGKEIT"+helligkeit);

          //Farbe und Helligkeit jedes Pixels werden den Durchschnittsvariblen hinzugefügt
          averageFarbe += farbe;
          averageHelligkeit += helligkeit;
        }
      }

      //Ein neues Pixelobjekt wird erstellt.
      //Es erhält die Parameter Farbe und Helligkeit, die vorher durch die
      //Anzahl der Pixel, die durchlaufen wurden, geteilt wird.
      //Die Farb- und Helligkeitswerten werden auf die Anzahl der Halbtonschritte
      //gemappt, die diese vo Grundton entfernt sind.
      //Anschließend wird das Objekt der ArrayList hinzugefügt.
      myPixel = new Pixel(selectTune(averageFarbe/400), findOctave(averageHelligkeit/400));
      pixelList.add(myPixel);

      //Farbe und Helligkeit werden wieder auf 0 gesetzt, damit sie im nächsten
      //Durchgang neu verwendet werden können.
      averageFarbe = 0;
      averageHelligkeit = 0;

      weiter = false;
      //Es wird überprüft, ob der X-Wert kurz vor dem Rand des Bildes ist
    } else if (averageStartX1 > (average.width - 20))
    {
      //In diesem Fall wird der Y-Wert um eine Reihe nach unten verschoben
      //und der X-Wert wieder auf 0 gesetzt, damit die nächste Reihe
      //von vorne an durchgelaufen werden kann
      averageStartY1 += 20;
      averageStartX1 = 0;
      //
      if (averageStartY1 > (average.height-20))
      {
        averageStartX1 = average.width;
        gotAverage = true;
      }
    }
    updatePixels();
    weiter = false;
  }
}

//Der Helligkeitswert wird auf eine der 4 Oktaven gemapt
int findOctave(float brightnessOctave)
{
  int octave = int(map(brightnessOctave, 0, 100, 1, 4));
  return octave;
}

//Der Farbwert wird auf einen der 7 möglich Töne gemapt
int selectTune(float farbeTune)
{
  int newTune = int(map(farbeTune, 0, 100, 1, 7));
  return newTune;
}

//Die Töne werden auf Halbtonschritte Entfernung vom Grundton umgeschrieben
int schrittTune(int tempHue)
{
  if (tempHue == 1)
  {
    return 0;
  } else if (tempHue == 2)
  {
    return 2;
  } else if (tempHue == 3)
  {
    return 4;
  } else if (tempHue == 4)
  {
    return 5;
  } else if (tempHue == 5)
  {
    return 7;
  } else if (tempHue == 6)
  {
    return 9;
  } else if (tempHue == 7)
  {
    return 11;
  } else
  {
    return 0;
  }
}

//Die Oktaven werden auf Halbtonschritte Entfernung vom Grundton umgeschrieben
int schrittOctave(int tempBrightness)
{
  if (tempBrightness == 1)
  {
    return 0;
  } else if (tempBrightness == 2)
  {
    return 12;
  } else if (tempBrightness == 3)
  {
    return 24;
  } else if (tempBrightness == 4)
  {
    return 36;
  } else {
    return 0;
  }
}

void liveTrigger(int channel, int pitch)
{


  for (int i =0; i < pixelList.size(); i++)
  {
    //Durch das Input Signal pitch wird der Rhythmus bestimmt, dabei steht jeder Pitch für einen anderen Rhythmus
    if (pixelList.get(i).getHelligkeit() <=2  && pitch == 55)
    {
      int tune = schrittTune(int(pixelList.get(i).getFarbe()));
      println(tune);
      int oktave=schrittOctave(int(pixelList.get(i).getHelligkeit()));
      println(oktave);
     //Der Ton welcher an Live gesendet wird. Zusammengesetzt aus Grundton + Oktave plus Abstand vom Grundton innerhalb der Tonart, hier GisDur
      int ton = 32+tune+oktave;
      myBus.sendNoteOn(0, ton, 127);
      weiter = true;
    }
  }



  for (int i =0; i < pixelList.size(); i++)
  {
    if (pixelList.get(i).getHelligkeit() >=3  && pitch == 62)
    {
      int oktave = schrittOctave(int(pixelList.get(i).getHelligkeit()));
      int tune = schrittTune(int(pixelList.get(i).getFarbe()));
      int ton = 32+tune+oktave;
      myBus.sendNoteOn(0, ton, 127);
      if (pitch >= 0)
        weiter = true;
    }
  }
}

//themidiBus Speziefischer Inhalt




void noteOn(int channel, int pitch, int velocity) {
  // Receive a noteOn
  // println();
  //println("Note On:");
  // println("--------");
  //  println("Channel:"+channel);
  // println("Pitch:"+pitch);
  //println("Velocity:"+velocity);

  liveTrigger(channel, pitch);
}

void noteOff(int channel, int pitch, int velocity) {
  // Receive a noteOff
  //println();
  //println("Note Off:");
  //println("--------");
  //println("Channel:"+channel);
  //println("Pitch:"+pitch);
  //println("Velocity:"+velocity);
}