//#include <Arduino.h>
#include <FastLED.h>

#define nLEDS 109
#define dataPIN 4

#define R 255
#define G 0
#define B 0

#define animLEDS 20
#define gradAMP 8

#define DELAY 100

CRGB leds[nLEDS];

int cnt = 0;

String command = "0";

int Grad[nLEDS][3];
int Start[2*nLEDS][3];


#define ez24L 5
#define ekfanL 9
#define pumpL 13
#define fanL 16



#define ez24S 0

void ez24(int LED[][3]) {
  for (int i=ez24S; i<ez24S+ez24L; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define fan1S (ez24S+ez24L)

void fan1(int LED[][3]) {
  for (int i=fan1S; i<fan1S+fanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define fan2S (fan1S+fanL)

void fan2(int LED[][3]) {
  for (int i=fan2S; i<fan2S+fanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define fan3S (fan2S+fanL)

void fan3(int LED[][3]) {
  for (int i=fan3S; i<fan3S+fanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define ekfan1S (fan3S+fanL)

void ekfan1(int LED[][3]) {
  for (int i=ekfan1S; i<ekfan1S+ekfanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define ekfan2S (ekfan1S+ekfanL)

void ekfan2(int LED[][3]) {
  for (int i=ekfan2S; i<ekfan2S+ekfanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define ekfan3S (ekfan2S+ekfanL)

void ekfan3(int LED[][3]) {
  for (int i=ekfan3S; i<ekfan3S+ekfanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define fan4S (ekfan3S+ekfanL)

void fan4(int LED[][3]) {
  for (int i=fan4S; i<fan4S+fanL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}

#define pumpS (fan4S+fanL)

void pump(int LED[][3]) {
  //EK logo static color
  leds[pumpS].setRGB(R,G,B);
  //Tutti gli altri led
  for (int i=pumpS+1; i<pumpS+pumpL; i++) {
    leds[i].setRGB(LED[i][0], LED[i][1], LED[i][2]);
  }
}


void setup()
{
  Serial.begin(115200);
  FastLED.addLeds<NEOPIXEL, dataPIN>(leds, nLEDS);

  //creo gli array di valori;
  for (int i=0; i<nLEDS; i++) {
    if (i >= nLEDS - animLEDS) {
      if (i < gradAMP + (nLEDS - animLEDS)) {
        Grad[i][0] = R*(gradAMP + (nLEDS - animLEDS) -i)/gradAMP;
        Grad[i][1] = G*(gradAMP + (nLEDS - animLEDS) -i)/gradAMP;
        Grad[i][2] = B*(gradAMP + (nLEDS - animLEDS) -i)/gradAMP;
      }
      if (i >= gradAMP + (nLEDS - animLEDS) && i < (nLEDS-gradAMP)) {
        Grad[i][0] = 0;
        Grad[i][1] = 0;
        Grad[i][2] = 0;
      }
      if (i >= (nLEDS-gradAMP)) {
        Grad[i][0] = R*(gradAMP-(nLEDS-i))/gradAMP;
        Grad[i][1] = G*(gradAMP-(nLEDS-i))/gradAMP;
        Grad[i][2] = B*(gradAMP-(nLEDS-i))/gradAMP;
      }
    }
    else {
      Grad[i][0] = R;
      Grad[i][1] = G;
      Grad[i][2] = B;
    }
  }

  for (int j=0; j<2*nLEDS; j++) {
    if (j >= nLEDS - animLEDS + gradAMP) {
      if (j < 2*gradAMP + (nLEDS - animLEDS)) {
        Start[j][0] = R*(gradAMP - j +(nLEDS - animLEDS + gradAMP))/gradAMP;
        Start[j][1] = G*(gradAMP - j +(nLEDS - animLEDS + gradAMP))/gradAMP;
        Start[j][2] = B*(gradAMP - j +(nLEDS - animLEDS + gradAMP))/gradAMP;
      }
      if (j >= 2*gradAMP + (nLEDS - animLEDS)) {
        Start[j][0] = 0;
        Start[j][1] = 0;
        Start[j][2] = 0;
      }
    }
    else {
      Start[j][0] = R;
      Start[j][1] = G;
      Start[j][2] = B;
    }
  }
  
  /*
  for (int i=0; i<2*nLEDS; i++) {
    Serial.println(Start[i][0]);
  }
  */

  //startup();
  //delay(DELAY);

}

void loop() {
  
  if (command == "0") {
    standard();
  }

  if (command == "1") {
    startup();
  }

  if (command == "2") {
    while (cnt!=animLEDS-gradAMP) {
      standard();
      delay(DELAY);
    }
    shutdown();
  }

  if (command == "3") {
    fill_solid(leds, nLEDS, CRGB::Black);  // Spegni tutti i LED
    FastLED.show();
    cnt=0;
  }

  if (Serial.available() > 0) {
    command = Serial.readString();
    command.trim();
  }

  delay(DELAY);
}


void standard() {
  //Serial.println("...");
  int GradShift[nLEDS][3];

  for (int i=0; i<nLEDS; i++) {
    GradShift[i][0]=Grad[(nLEDS+i-cnt)%nLEDS][0];
    GradShift[i][1]=Grad[(nLEDS+i-cnt)%nLEDS][1];
    GradShift[i][2]=Grad[(nLEDS+i-cnt)%nLEDS][2];
  }

  ez24(GradShift);
  fan1(GradShift);
  fan2(GradShift);
  fan3(GradShift);
  ekfan1(GradShift);
  ekfan2(GradShift);
  ekfan3(GradShift);
  fan4(GradShift);
  pump(GradShift);
  
  FastLED.show();  // Aggiorna la striscia LED
  cnt = (cnt + 1) % nLEDS;  // Incrementa il contatore e lo riporta a 0 se supera NUM_LEDS
}


void startup() {
  //Serial.println("inizializzazione...");
  int StartShift[nLEDS][3];

  while (cnt<nLEDS-gradAMP){

    for (int i=0; i<nLEDS; i++) {
      StartShift[i][0]=Start[(nLEDS+i-cnt)][0];
      StartShift[i][1]=Start[(nLEDS+i-cnt)][1];
      StartShift[i][2]=Start[(nLEDS+i-cnt)][2];
    }
    ez24(StartShift);
    fan1(StartShift);
    fan2(StartShift);
    fan3(StartShift);
    ekfan1(StartShift);
    ekfan2(StartShift);
    ekfan3(StartShift);
    fan4(StartShift);
    pump(StartShift);

    FastLED.show();
    cnt = (cnt + 1);
    delay(DELAY);
  }
    
  cnt=0;
  command="0";
}

void shutdown() {
  cnt=0;
  //Serial.println("...Spegnimento");
  int revStart[2*nLEDS][3];
  for (int i=0; i<2*nLEDS; i++) {
    revStart[i][0]=Start[2*nLEDS-i][0];
    revStart[i][1]=Start[2*nLEDS-i][1];
    revStart[i][2]=Start[2*nLEDS-i][2];
  }
  int EndShift[nLEDS][3];

  while (cnt<nLEDS){

    for (int i=0; i<nLEDS; i++) {
      EndShift[i][0]=revStart[(nLEDS+(i)-cnt)][0];
      EndShift[i][1]=revStart[(nLEDS+(i)-cnt)][1];
      EndShift[i][2]=revStart[(nLEDS+(i)-cnt)][2];
    }
    ez24(EndShift);
    fan1(EndShift);
    fan2(EndShift);
    fan3(EndShift);
    ekfan1(EndShift);
    ekfan2(EndShift);
    ekfan3(EndShift);
    fan4(EndShift);
    pump(EndShift);

    FastLED.show();
    cnt = (cnt + 1);
    delay(DELAY);
  }

  cnt=0;
  command="3";
}