#include <MIDI.h>
MIDI_CREATE_DEFAULT_INSTANCE();

/////////////////////////////////////////////

const int NButtons = 1; // *coloque aqui o numero de entradas digitais utilizadas
const int button[NButtons] = {22}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
int buttonCState[NButtons] = {0}; // estado atual da porta digital
int buttonPState[NButtons] = {0}; // estado previo da porta digital
/////////////////////////////////////////////////////////////////////////////////
const int ledVUr = 7; // *coloque aqui o numero de entradas digitais utilizadas
const int VUr[ledVUr] = {2,3,4,5,6,7,8}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
int ledCState[ledVUr] = {0}; // estado atual da porta digital
int ledPState[ledVUr] = {0}; // estado previo da porta digital
int green=200;
int yellow=150;
int red=100;

/////////////////////////////////////////////

const int NPots = 1; // *coloque aqui o numero de entradas analogicas utilizadas
const int pot[NPots] = {A0}; // *neste array coloque na ordem desejada os pinos das portas analogicas utilizadas
int potCState[NPots] = {0}; // estado atual da porta analogica
int potPState[NPots] = {0}; // estado previo da porta analogica
int potVar = 0; // variacao entre o valor do estado previo e o atual da porta analogica

/////////////////////////////////////////////

byte midiCh = 1; // *Canal midi a ser utilizado
byte note = 36; // *Nota mais grave que sera utilizada
byte cc = 1; // *CC mais baixo que sera utilizado

/////////////////////////////////////////////

int TIMEOUT = 300; //quantidade de tempo em que o potenciometro sera lido apos ultrapassar o varThreshold
int varThreshold = 4; //threshold para a variacao no sinal do potenciometro
boolean potMoving = true; // se o potenciometro esta se movendo
unsigned long pTime[NPots] = {0}; // tempo armazenado anteriormente
unsigned long timer[NPots] = {0}; // armazena o tempo que passou desde que o timer foi zerado

/////////////////////////////////////////////

void setup () {

  //Start midi connection
  MIDI.begin();
  //Serial Connection
  Serial.begin(115200);

   MIDI.setHandleControlChange(handleControlChange);




  //Inicialize os botões(ENTRADAS DIGITAIS)
  for (int i=0; i<NButtons; i++){
    pinMode(button[i], INPUT_PULLUP);
  }
  for (int i=0; i<ledVUr; i++){
    pinMode(VUr[i], OUTPUT );
  }
  //nicialize as entradas analogicas
  for (int i=0; i<NPots; i++){
    pinMode(pot[i], INPUT);
  }

}

void loop () {

  //Le todos os botoes (entradas digitais) utilizadas
  for (int i=0; i<NButtons; i++) {
    buttonCState[i] = digitalRead(button[i]);
  }

  //Le o estado dos botoes e manda NoteOns para cada um que estiver ativo
  for (int i=0; i<NButtons; i++) {

    if (buttonCState[i] != buttonPState[i]) {

      if(buttonCState[i] == LOW) {
        MIDI.sendNoteOn(note+i, 127, midiCh); // envia NoteOn(nota, velocity, canal midi)
        buttonPState[i] = buttonCState[i];
      }
      else {
        MIDI.sendNoteOn(note+i, 0, midiCh);
        buttonPState[i] = buttonCState[i];
      }
    }

  }
 ////////////////////////////////////////////////////////////////////////////////////////

  for (int i=0; i<NPots; i++) { // le todas entradas analogicas utilizadas
    potCState[i] = analogRead(pot[i]);
  }
  //////////////////////////////////////////////////////////////////////////////////////////////////////////
  //"Portão"
  for (int i=0; i<NPots; i++) {

    potVar = abs(potCState[i] - potPState[i]); // calcula a variacao da porta analogica

    if (potVar >= varThreshold) {  //sets a threshold for the variance in the pot state, if it varies more than x it sends the cc message
      pTime[i] = millis(); // armazena o tempo previo
    }
    timer[i] = millis() - pTime[i]; // reseta o timer
    if (timer[i] < TIMEOUT) { // se o timer for menor que o tempo maximo permitido significa que o potenciometro ainda esta se movendo
      potMoving = true;
    }
    else {
      potMoving = false;
    }

    if (potMoving == true) { // se o potenciometro ainda esta se movendo, mande o control change
      MIDI.sendControlChange(cc+i, map(potCState[i], 0, 1023, 0, 127), midiCh); // envia Control Change (numero do CC, valor do CC, canal midi)
      potPState[i] = potCState[i]; // armazena a leitura atual do potenciometro para comparar com a proxima
    }
  }

}
void handleControlChange(byte channel, byte number, byte value) {

  int value_ = value;
  int ccLastValue = 0;
  if (value_ != ccLastValue) {

    // Left VU
    if (number == 1) {

      switch (value_) {
        case 0:
          for (int i = 0; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          break;
        case 1:
          for (int i = 1; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
         analogWrite(VUr[0], green);
          break;
        case 2:
          for (int i = 2; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 2; i++) {
            analogWrite(VUr[i], green);
          }
          break;
        case 3:
          for (int i = 3; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 3; i++) {
            analogWrite(VUr[i], green);
          }
          break;
        case 4:
          for (int i = 4; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 4; i++) {
            analogWrite(VUr[i], green);
          }
          break;
        case 5:
          for (int i = 5; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 5; i++) {
            analogWrite(VUr[i], green);
          }
          break;
        case 6:
          for (int i = 6; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 5; i++) {
            analogWrite(VUr[i], green);
          }
            analogWrite(VUr[5], yellow);
          break;
        case 7:
          for (int i = 6; i < 7; i++) {
            analogWrite(VUr[i], LOW);
          }
          for (int i = 0; i < 5; i++) {
            analogWrite(VUr[i], green);
          }
          analogWrite(VUr[5], yellow);
          analogWrite(VUr[6], red);
          break;

      }
    }
  }
}