#include <NeoPixelAnimator.h>
#include <NeoPixelBrightnessBus.h>
#include <NeoPixelBus.h>


//Setup der Panel
const uint16_t PixelPerPanelCount = 9;
const uint16_t PanelCount = 5;
const uint8_t PixelPin = 6;  // der Pin an dem der 330Ohm Widerstand mit dem Datapin der ersten LED hängt,
const uint16_t PixelCount = PixelPerPanelCount*PanelCount;




//Setup der Schalter
const int rubikTopPlus = 9;
const int rubikTopMinus = 10;
const int rubikBottomPlus = 4;
const int rubikBottomMinus = 5;
const int rubikRightPlus = 8;
const int rubikRightMinus = 7;
const int rubikLeftPlus = 15;
const int rubikLeftMinus = 14;
const int rubikFrontPlus = 16;
const int rubikFrontMinus = 17;
const int rubikBackPlus = 18;
const int rubikBackMinus = 19;

//interupt für den Programmwechsel und Dauerlicht
const int programmChange = 3;
const int fullLight = 2;

//Die Grundfarben für die Seiten des Rubix Cube
const RgbwColor PanelC1 = RgbwColor(255,128,0,0);
const RgbwColor PanelC2 = RgbwColor(0,255,0,0);
const RgbwColor PanelC3 = RgbwColor(255,0,0,0);
const RgbwColor PanelC4 = RgbwColor(0,0,255,0);
const RgbwColor PanelC5 = RgbwColor(255,255,255,0);
const RgbwColor PanelC6 = RgbwColor(255,255,0,0);

//setup der arrays für die LED'S

RgbwColor Panel1[9] = {PanelC1,PanelC1,PanelC1,PanelC1,PanelC1,PanelC1,PanelC1,PanelC1,PanelC1};
RgbwColor Panel2[9] = {PanelC2,PanelC2,PanelC2,PanelC2,PanelC2,PanelC2,PanelC2,PanelC2,PanelC2};
RgbwColor Panel3[9] = {PanelC3,PanelC3,PanelC3,PanelC3,PanelC3,PanelC3,PanelC3,PanelC3,PanelC3};
RgbwColor Panel4[9] = {PanelC4,PanelC4,PanelC4,PanelC4,PanelC4,PanelC4,PanelC4,PanelC4,PanelC4};
RgbwColor Panel5[9] = {PanelC5,PanelC5,PanelC5,PanelC5,PanelC5,PanelC5,PanelC5,PanelC5,PanelC5};
RgbwColor Panel6[9] = {PanelC6,PanelC6,PanelC6,PanelC6,PanelC6,PanelC6,PanelC6,PanelC6,PanelC6};
RgbwColor PanelStore[9] = {RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0),RgbwColor(0)};

//start Farbe für die Lichtfunktion
      int R = 255;
      int G = 100;
      int B = 0;
      int W = 0;
      int lightness =255;
      long wait = 50; //General waiting time to make all animation faster or slower
      int flackern=50;

//setup strip
NeoPixelBrightnessBus<NeoGrbwFeature, Neo800KbpsMethod> strip(PixelCount+2, PixelPin);//+2 weil ich im Bedienteil 2 weitere LED's zur hinterleuchtung verbaut habe

//Progcounter
int progActive = 1;
int progMax = 4;

uint16_t ProgCounter = 0,ProgCounter2=0;
int updated = 1;
unsigned long alteZeit=0, entprellZeit=1000 ,alteZeitTimer=0,sperrzeit433=1, controlTime=0;
unsigned long controlSleep=50;

//Initialisieren des ATMEGA
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  while (!Serial); // wait for serial attach

  Serial.println();
  Serial.println("Initializing...");
  Serial.flush();

  // this resets all the neopixels to an off state
  strip.SetBrightness(lightness);
  strip.Begin();
  strip.Show();

  //setup pins
  pinMode(rubikTopPlus, INPUT_PULLUP);
  pinMode(rubikTopMinus, INPUT_PULLUP);
  pinMode(rubikBottomPlus, INPUT_PULLUP);
  pinMode(rubikBottomMinus, INPUT_PULLUP);
  pinMode(rubikRightPlus, INPUT_PULLUP);
  pinMode(rubikRightMinus, INPUT_PULLUP);
  pinMode(rubikLeftPlus, INPUT_PULLUP);
  pinMode(rubikLeftMinus, INPUT_PULLUP);
  pinMode(rubikFrontPlus, INPUT_PULLUP);
  pinMode(rubikFrontMinus, INPUT_PULLUP);
  pinMode(rubikBackPlus, INPUT_PULLUP);
  pinMode(rubikBackMinus, INPUT_PULLUP);
  pinMode(programmChange, INPUT_PULLUP);
  pinMode(fullLight, INPUT_PULLUP);
  
  //interrupt verbinden
  attachInterrupt(digitalPinToInterrupt(programmChange), nextProg, FALLING);
  attachInterrupt(digitalPinToInterrupt(fullLight), allWhiteOn, FALLING);

  //Bilder der Random Seed
  randomSeed(25);
  
  //Fertig Ausgabe
  Serial.println();
  Serial.println("Running...");
}


//Programmschleife
void loop() {
  //Prog 1 Alles aus
  if(progActive == 1){
    
    if(updated=1){
          resetRubik();
          updated = 0;
    }
    allOff();
  }
  //Prog 2 Regenbogen mit allen LED's gleich
  if(progActive == 2){
    if(updated == 1){
      strip.SetPixelColor(0, RgbwColor(R,G,B,W));
      strip.SetPixelColor(1, RgbwColor(R,G,B,W));    
      updated = 0;
    }
    rainbow(PixelCount,wait*100);
    controlSetup();
  }
  //Prog 3 Regenbogen mit allen unterschiedlich
  if(progActive == 3){
    if(updated == 1){
      strip.SetPixelColor(0, RgbwColor(R,G,B,W));
      strip.SetPixelColor(1, RgbwColor(R,G,B,W));
      updated = 0;    
    }    
    rotRainbow(PixelCount,wait*100);
    controlSetup();
  }
  //Prog 4 Rubix Cube
  if(progActive == 4){
    if(updated == 1){
      strip.SetPixelColor(0, RgbwColor(R,G,B,W));
      strip.SetPixelColor(1, RgbwColor(R,G,B,W));    
    }
// function 1= top; 2= bottom; 3= right; 4=left; 5=front; 6= back;
// turns = amount of turns (so 3 is one to the left 1 is one to the right)
    if(!digitalRead(rubikTopPlus)){
          rotateRubik(1,1);
          delay(200);
          while(!digitalRead(rubikTopPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikTopMinus)){
          rotateRubik(1,3);
          delay(200);
          while(!digitalRead(rubikTopMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikBottomPlus)){
          rotateRubik(2,1);
          delay(200);
          while(!digitalRead(rubikBottomPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikBottomMinus)){
          rotateRubik(2,3);
          delay(200);
          while(!digitalRead(rubikBottomMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikRightPlus)){
          rotateRubik(3,1);
          delay(200);
          while(!digitalRead(rubikRightPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikRightMinus)){
          rotateRubik(3,3);
          delay(200);
          while(!digitalRead(rubikRightMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikLeftPlus)){
          rotateRubik(4,1);
          delay(200);
          while(!digitalRead(rubikLeftPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikLeftMinus)){
          rotateRubik(4,3);
          delay(200);
          while(!digitalRead(rubikLeftMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikFrontPlus)){
          rotateRubik(5,1);
          delay(200);
          while(!digitalRead(rubikFrontPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikFrontMinus)){
          rotateRubik(5,3);
          delay(200);
          while(!digitalRead(rubikFrontMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikBackPlus)){
          rotateRubik(6,1);
          delay(200);
          while(!digitalRead(rubikBackPlus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
    if(!digitalRead(rubikBackMinus)){
          rotateRubik(6,3);
          delay(200);
          while(!digitalRead(rubikBackMinus)){
            //delay damit nur ein Schritt gemacht wird
          }
    }
	// Wenn eine veränderung stattgefunden hat werden die LED aktualisiert
    if(updated == 1){
      setRubikColors();
      updated = 0;
    }
  }
  //Licht Programm stoppt alle anderen Programme und macht das Licht an
  while(digitalRead(fullLight)== 0){
      allWhiteOn(); 
  }
}

//Flackerndes licht mit der oben deffinierten Grundfarbe sieht etwas aus wie Kerzenlicht
void allWhiteOn(){

      while(digitalRead(fullLight)== 0){
        strip.SetBrightness(lightness);
        
        for (int k=0; k <= PixelCount+2; k++){
          Herbst strip.SetPixelColor(k, rndLight((int)((float)flackern/5.0),R,G,B,W));
        }
        controlSetup();
        strip.Show();
        
        delay((int)((float)wait/5.0));
      }
    
}
//Beeinflussung von geschwindigkeit und Lichtfarbe während der Laufzeit
void controlSetup(){
  if(millis()-controlSleep>controlTime){
        controlTime=millis();
        if(!digitalRead(rubikTopPlus)){
          R+=1;
        }
        if(!digitalRead(rubikTopMinus)){
          R-=1;
        }
        if(R<0){R=0;}
        if(R>255){R=255;}
        if(!digitalRead(rubikBottomPlus)){
          G+=1;
        }
        if(!digitalRead(rubikBottomMinus)){
          G-=1;
        }
        if(G<0){G=0;}
        if(G>255){G=255;}
        if(!digitalRead(rubikFrontPlus)){
          B+=1;
        }
        if(!digitalRead(rubikFrontMinus)){
          B-=1;
        }
        if(B<0){B=0;}
        if(B>255){B=255;}
        if(!digitalRead(rubikBackPlus)){
          W+=1;
        }
        if(!digitalRead(rubikBackMinus)){
          W-=1;
        }
        if(W<0){W=0;}
        if(W>255){W=255;}
        if(!digitalRead(rubikRightPlus)){
          lightness+=1;
        }
        if(!digitalRead(rubikRightMinus)){
          lightness-=1;
        }
        if(lightness<0){lightness=0;}
        if(lightness>255){lightness=255;}
        if(!digitalRead(rubikLeftPlus)){
          wait+=1;
        }
        if(!digitalRead(rubikLeftMinus)){
          wait-=1;
        }
        if(wait<0){wait=0;}
        if(wait>255){wait=255;}         
  }        
}
//Programmumschalter
void nextProg(){
  if((millis() - alteZeit) > entprellZeit) {
      progActive+= 1;

      if(progActive>progMax){
        progActive = 1;
      }
      Serial.println("Prog:");
      Serial.println(progActive);
      alteZeit = millis();
      updated = 1;
      
  }
}
//Rubix Cube zurücksetzen
void resetRubik(){
  for (int j=0; j<9;j++){
    Panel1[j] = PanelC1;
    Panel2[j] = PanelC2;
    Panel3[j] = PanelC3;
    Panel4[j] = PanelC4;
    Panel5[j] = PanelC5;
    Panel6[j] = PanelC6;
    PanelStore[j] = RgbwColor(0);
  }
  
}

//funktion zum generieren der Regenbogenfarben über 255 Positionen
RgbwColor wheel(int pos){
    
    if (pos < 85)
    {
      return RgbwColor(255 - pos * 3, pos * 3 , 0,0);
    }
    else
    {
          if (pos < 170)
          {
            pos -= 85;
            return RgbwColor(0, 255 - pos * 3, pos * 3,0);
          }
          else
          {
            pos -= 170;
            return RgbwColor(pos * 3, 0, 255 - pos * 3,0);
          }
    }
}

//Generieren von leichten Farbvariationen
RgbwColor rndLight(int variation,int R, int G,int B,int W){
    //zufallsvariationen.
    int Rx = random(R, R+variation);
    int Gx = random(G, G+variation);
    int Bx = random(B, B+variation);
    int Wx = random(W, W+variation);
	//begrenzen der Variation auf 0-255
    if (Rx>255){Rx=255;}
    if (Gx>255){Gx=255;}
    if (Bx>255){Bx=255;}
    if (Wx>255){Wx=255;}
	//Rückgabe
    return RgbwColor(Rx,Gx,Bx,Wx);
}


//Drehen des Rubix Cube
// funktion 1= top; 2= bottom; 3= right; 4=left; 5=front; 6= back;
// turns = anzahl der Drehungen (also 3 ist eins nach links 1 ist eins nach rechts)

void rotateRubik(int function, int turns){
    
    switch (function) {
      case 1: //Rotate top (Test OK)
        //repeat action for the number of turns
        for (int i=0; i<turns;i++){
             //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel4[j];
            }
            Panel4[2]=Panel3[2];
            Panel4[1]=Panel3[1];
            Panel4[0]=Panel3[0];
            Panel3[2]=Panel2[2];
            Panel3[1]=Panel2[1];
            Panel3[0]=Panel2[0];
            Panel2[2]=Panel1[2];
            Panel2[1]=Panel1[1];
            Panel2[0]=Panel1[0];
            Panel1[2]=PanelStore[2];
            Panel1[1]=PanelStore[1];
            Panel1[0]=PanelStore[0];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel5[j];
            }
            Panel5[0]=PanelStore[2];
            Panel5[1]=PanelStore[5];
            Panel5[2]=PanelStore[8];
            Panel5[5]=PanelStore[7];
            Panel5[8]=PanelStore[6];
            Panel5[7]=PanelStore[3];
            Panel5[6]=PanelStore[0];
            Panel5[3]=PanelStore[1];
        }
        updated = 1;
        break;
      case 2: //Rotate bottom (Test OK)
        //repeat action for the number of turns
        for (int i=0; i<turns;i++){
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel4[j];
            }
            Panel4[8]=Panel3[8];
            Panel4[7]=Panel3[7];
            Panel4[6]=Panel3[6];
            Panel3[8]=Panel2[8];
            Panel3[7]=Panel2[7];
            Panel3[6]=Panel2[6];
            Panel2[8]=Panel1[8];
            Panel2[7]=Panel1[7];
            Panel2[6]=Panel1[6];
            Panel1[8]=PanelStore[8];
            Panel1[7]=PanelStore[7];
            Panel1[6]=PanelStore[6];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel6[j];
            }
            Panel6[0]=PanelStore[6];
            Panel6[1]=PanelStore[3];
            Panel6[2]=PanelStore[0];
            Panel6[5]=PanelStore[1];
            Panel6[8]=PanelStore[2];
            Panel6[7]=PanelStore[5];
            Panel6[6]=PanelStore[8];
            Panel6[3]=PanelStore[7];
        }
        updated = 1;
        break;
      case 3: //Rotate right (test OK)
                //repeat action for the number of turns
        for (int i=0; i<turns;i++){
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel6[j];
            }
            Panel6[2]=Panel3[8];
            Panel6[1]=Panel3[5];
            Panel6[0]=Panel3[2];
            Panel3[8]=Panel5[6];
            Panel3[5]=Panel5[7];
            Panel3[2]=Panel5[8];
            Panel5[6]=Panel1[0];
            Panel5[7]=Panel1[3];
            Panel5[8]=Panel1[6];
            Panel1[0]=PanelStore[2];
            Panel1[3]=PanelStore[1];
            Panel1[6]=PanelStore[0];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel4[j];
            }
            Panel4[0]=PanelStore[2];
            Panel4[1]=PanelStore[5];
            Panel4[2]=PanelStore[8];
            Panel4[5]=PanelStore[7];
            Panel4[8]=PanelStore[6];
            Panel4[7]=PanelStore[3];
            Panel4[6]=PanelStore[0];
            Panel4[3]=PanelStore[1];
        }
        updated = 1;
        break;
      case 4: //Rotate left (test OK)
        //repeat action for the number of turns
        for (int i=0; i<turns;i++){
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel6[j];
            }
            Panel6[8]=Panel3[6];
            Panel6[7]=Panel3[3];
            Panel6[6]=Panel3[0];
            Panel3[6]=Panel5[0];
            Panel3[3]=Panel5[1];
            Panel3[0]=Panel5[2];
            Panel5[0]=Panel1[2];
            Panel5[1]=Panel1[5];
            Panel5[2]=Panel1[8];
            Panel1[2]=PanelStore[8];
            Panel1[5]=PanelStore[7];
            Panel1[8]=PanelStore[6];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel2[j];
            }
            Panel2[0]=PanelStore[6];
            Panel2[1]=PanelStore[3];
            Panel2[2]=PanelStore[0];
            Panel2[5]=PanelStore[1];
            Panel2[8]=PanelStore[2];
            Panel2[7]=PanelStore[5];
            Panel2[6]=PanelStore[8];
            Panel2[3]=PanelStore[7];
        }
        updated = 1;
        break;
      case 5: //Rotate front
        //repeat action for the number of turns
        for (int i=0; i<turns;i++){
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel6[j];
            }
            Panel6[2]=Panel2[6];
            Panel6[5]=Panel2[3];
            Panel6[8]=Panel2[0];
            Panel2[6]=Panel5[2];
            Panel2[3]=Panel5[5];
            Panel2[0]=Panel5[8];
            Panel5[2]=Panel4[2];
            Panel5[5]=Panel4[5];
            Panel5[8]=Panel4[8];
            Panel4[2]=PanelStore[2];
            Panel4[5]=PanelStore[5];
            Panel4[8]=PanelStore[8];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel1[j];
            }
            Panel1[0]=PanelStore[6];
            Panel1[1]=PanelStore[3];
            Panel1[2]=PanelStore[0];
            Panel1[5]=PanelStore[1];
            Panel1[8]=PanelStore[2];
            Panel1[7]=PanelStore[5];
            Panel1[6]=PanelStore[8];
            Panel1[3]=PanelStore[7];
        }
        updated = 1;
        break;
      case 6: //Rotate back
        //repeat action for the number of turns
        for (int i=0; i<turns;i++){
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel6[j];
            }
            Panel6[0]=Panel2[8];
            Panel6[3]=Panel2[5];
            Panel6[6]=Panel2[2];
            Panel2[8]=Panel5[0];
            Panel2[5]=Panel5[3];
            Panel2[2]=Panel5[6];
            Panel5[0]=Panel4[0];
            Panel5[3]=Panel4[3];
            Panel5[6]=Panel4[6];
            Panel4[0]=PanelStore[0];
            Panel4[3]=PanelStore[3];
            Panel4[6]=PanelStore[6];
            //store the last Panel
            for (int j=0; j<9;j++){
              PanelStore[j]=Panel3[j];
            }
            Panel3[0]=PanelStore[2];
            Panel3[1]=PanelStore[5];
            Panel3[2]=PanelStore[8];
            Panel3[5]=PanelStore[7];
            Panel3[8]=PanelStore[6];
            Panel3[7]=PanelStore[3];
            Panel3[6]=PanelStore[0];
            Panel3[3]=PanelStore[1];
        }
        updated = 1;
        break;       
      default: 
        // Do nothing
      break;
    }
    if(updated==1){
      setRubikColors();
      updated = 0;
    }
}
//Aktualisieren aller LED mit den Farben der Arrays
void setRubikColors(){
    ProgCounter = 0;
    while (ProgCounter<=8){
        strip.SetPixelColor(ProgCounter+2, Panel1[ProgCounter]);
        strip.SetPixelColor(ProgCounter+9+2, Panel2[ProgCounter]);
        strip.SetPixelColor(ProgCounter+18+2, Panel3[ProgCounter]);
        strip.SetPixelColor(ProgCounter+27+2, Panel4[ProgCounter]);
        strip.SetPixelColor(ProgCounter+36+2, Panel5[ProgCounter]);
        strip.SetPixelColor(ProgCounter+45+2, Panel6[ProgCounter]);
        ProgCounter+=1;
    }
    if (ProgCounter>8){
        ProgCounter=0;
        strip.Show(); 
    }
}

//Regenbogenfunktion mit allen seiten gleich
void rainbow(uint16_t numPixel,long twait){
    if (ProgCounter<=255){
      if (ProgCounter2<=numPixel){
          strip.SetPixelColor(ProgCounter2+2, wheel(ProgCounter));
          ProgCounter2+=1;
      }
      if (ProgCounter2>numPixel){
          ProgCounter2=0;
          ProgCounter=(int)(((float)(millis() - alteZeitTimer)/(float)twait)*255.0);
          strip.Show(); 
      }
    }
    if (ProgCounter>255){
        alteZeitTimer = millis(); //Timer zurücksetzen
        ProgCounter=0;
    }
}

//Regenbogenfunktion mit allen seiten unterschiedlich
void rotRainbow(uint16_t numPixel,long twait){
    if (ProgCounter<=255){
      if (ProgCounter2<=numPixel){
          int pos = (int)(ProgCounter+(ProgCounter2 * 255/(numPixel-1)));
          while(pos > 255){
          pos -= 255;
          }
          strip.SetPixelColor(ProgCounter2+2, wheel(pos));
          ProgCounter2+=1;
      }
      if (ProgCounter2>numPixel){
          ProgCounter2=0;
          ProgCounter=(int)(((float)(millis() - alteZeitTimer)/(float)twait)*255.0);
          strip.Show(); 
      }
    }
    if (ProgCounter>255){
        alteZeitTimer = millis(); //Timer zurücksetzen
        ProgCounter=0;
      
    }    
}


//alles Ausschalten
void allOff(){
    if (ProgCounter<=PixelCount+2){
      strip.SetPixelColor(ProgCounter, RgbwColor(0));
      ProgCounter+=1;
    }
    if (ProgCounter>PixelCount+2){
      ProgCounter = 0;
      strip.Show();
    }
}