#include "Adafruit_NeoPixel.h"

#define NUMPIXELS   156
#define LED_PIN     5
//#define LED_PIN   4
#define BRIGHTNESS  50
#define BUTTON      12 //botón en GPIO12 (D6)
// #define BUTTON      14 //botón en GPIO14 (D5) - PLACA DE BACKUP NR3 porque el D6 esta petado


volatile int sceneNumber = 0;
volatile bool sceneFlag = 0;
//volatile bool oldSceneFlag = 0;
//volatile int ledState = HIGH;         // the current state of the output pin
//volatile int buttonState;             // the current reading from the input pin
//volatile int lastButtonState = LOW;   // the previous reading from the input pin
//unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
//unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers
//bool previousPinState = HIGH;

Adafruit_NeoPixel strip(NUMPIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);

void ICACHE_RAM_ATTR scene();

void setup() 
{
  
 Serial.begin(115200);
 pinMode(BUTTON, INPUT_PULLUP);
 digitalWrite(BUTTON, HIGH);
 attachInterrupt(BUTTON, scene, FALLING);

 strip.begin();                     // INITIALIZE NeoPixel strip object (REQUIRED)
 strip.show();                      // Turn OFF all pixels ASAP
 strip.setBrightness(BRIGHTNESS);   // Set BRIGHTNESS to about 1/5 (max = 255)
 
 delay(1000);
 initSeq(); // secuencia de inicio blanca

}

void scene() 
{
  
 static unsigned long last_interrupt_time = 0;
 unsigned long interrupt_time = millis();
 
 if (interrupt_time - last_interrupt_time > 500)
 {
    sceneFlag = true; 
    
    if(!digitalRead(BUTTON))
    {
        //Serial.println(sceneFlag);
        sceneFlag = 0;
        sceneNumber++;
        if(sceneNumber>4)
            sceneNumber = 0;
    }
 
 }
 
 last_interrupt_time = interrupt_time;

}



void colorWipe(uint32_t color, int wait) 
{
  for(int i=0; i<strip.numPixels(); i++) 
  { // For each pixel in strip...
    strip.setPixelColor(i, color);         //  Set pixel's color (in RAM)
    strip.show();                          //  Update strip to match
    delay(wait);                           //  Pause for a moment
  }
}

void colorWipe2(uint32_t color, int wait) 
{
  for(int i=0; i<=(NUMPIXELS/2); i++) { 
    strip.setPixelColor(i, color);       
    strip.setPixelColor(NUMPIXELS - i, color);       
    strip.show();                       
    delay(wait);                   
  }
}

void colorGradient(int r1, int g1, int b1, int r2, int g2, int b2, int wait, int modo)
{

  int steps = NUMPIXELS;
  for (int i = 0; i < steps; i++) {
    uint8_t red = (((r1 * (steps - i)) + (r2 * i)) / steps);
    uint8_t green = (((g1 * (steps - i)) + (g2 * i)) / steps);
    uint8_t blue = (((b1 * (steps - i)) + (b2 * i)) / steps);
    // Sets the pixels to the color adjusted in the fade
    strip.setPixelColor(i, red, green, blue);
    
    if(modo)
        strip.setPixelColor(NUMPIXELS - i, strip.getPixelColor(i));  // clonamos el interior
 
    strip.show();                       
    delay(wait);
  }

}

uint8_t white(uint32_t c) {
  return (c >> 24);
}
uint8_t red(uint32_t c) {
  return (c >> 16);
}
uint8_t green(uint32_t c) {
  return (c >> 8);
}
uint8_t blue(uint32_t c) {
  return (c);
}


void initSeq()
{
  
  ///////////////////
  // FADE IN WHITE
  ///////////////////
  
  for(int i=0; i<=(NUMPIXELS/2); i++) 
  { 
    strip.setPixelColor(i, strip.Color(255, 255, 255));       
    strip.setPixelColor(NUMPIXELS - i, strip.Color(255, 255, 255));       
    strip.show();                       
  }
  
  ///////////////////
  // FADE OUT
  ///////////////////
  //fadeOut(25, 10, 10); // frames, fadevalue, delay ;
  
}

void fadeOut(int frames, int fadeValue, int wait)
{
  for(int f=0; f<=frames; f++)   // number of fade frames
  {
    for(int i=0; i<=NUMPIXELS; i++)   
    { 
      fadeToBlack(i, fadeValue); // fadevalue = time of fade out                          
    }
    strip.show(); 
    delay(wait);
  }

}

void Fire(int Cooling, int Sparking, int SpeedDelay) {
     
    static byte heat[NUMPIXELS];
    int cooldown;

    // Step 1.  Cool down every cell a little
    for ( int i = 0; i < NUMPIXELS ; i++) {
      cooldown = random(0, ((Cooling * 10) / NUMPIXELS) + 2);

      if (cooldown > heat[i]) {
        heat[i] = 0;
      } else {
        heat[i] = heat[i] - cooldown;
      }
    }

    // Step 2.  Heat from each cell drifts 'up' and diffuses a little
    for ( int k = NUMPIXELS - 1; k >= 2; k--) {
      heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
    }

    // Step 3.  Randomly ignite new 'sparks' near the bottom
    if ( random(255) < Sparking ) {
      int y = random(7);
      heat[y] = heat[y] + random(160, 255);
      //heat[y] = random(160,255);
    }

    // Step 4.  Convert heat to LED colors
    for ( int j = 0; j < NUMPIXELS; j++) {
      setPixelHeatColor(j, heat[j] );
    }

    for(int i=0; i<=(NUMPIXELS/2); i++) 
    { // For each pixel in strip...   
      strip.setPixelColor(NUMPIXELS - i, strip.getPixelColor(i));     
    }
    
    strip.show();
    delay(SpeedDelay);

}


void setPixelHeatColor (int Pixel, byte temperature)
{
  // Scale 'heat' down from 0-255 to 0-191
  byte t192 = round((temperature / 255.0) * 191);

  // calculate ramp up from
  byte heatramp = t192 & 0x3F; // 0..63
  heatramp <<= 2; // scale up to 0..252

  // figure out which third of the spectrum we're in:
  if ( t192 > 0x80) {                    // hottest
    setPixel(Pixel, 255, 255, heatramp, 0);
  } else if ( t192 > 0x40 ) {            // middle
    setPixel(Pixel, 255, heatramp, 0, 0);
  } else {                               // coolest
    setPixel(Pixel, heatramp, 0, 0, 0);
  }
}

void setPixel(int Pixel, byte red, byte green, byte blue, byte white)
{
  strip.setPixelColor(Pixel, strip.Color(red, green, blue, white));
}

void setAll(byte red, byte green, byte blue, byte white)
{
  for (int i = 0; i < NUMPIXELS; i++ ) {
    setPixel(i, red, green, blue, white);
  }
}

void fadeToBlack(int ledNo, byte fadeValue) 
{
    uint32_t oldColor;
    uint8_t r, g, b, w;
    int value;
    
    oldColor = strip.getPixelColor(ledNo);

    w = (oldColor & 0xff000000UL) >> 24;
    r = (oldColor & 0x00ff0000UL) >> 16;
    g = (oldColor & 0x0000ff00UL) >> 8;
    b = (oldColor & 0x000000ffUL);

    r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
    g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
    b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
    w=(w<=10)? 0 : (int) w-(w*fadeValue/256);
    
    strip.setPixelColor(ledNo, r,g,b,w);
}


void loop() 
{

//   if( sceneFlag )
//   {    
//        sceneFlag = 0;
//   }
    
  switch (sceneNumber)
  {

    case 0  : {  // OFF 
        //setAll(0, 0, 0, 0); // Aqui sería mejor tener un Fade Out
        //strip.show();
        fadeOut( 25, 10, 5 );
        break;
    }
    case 1  : {
        Fire(55,120,10); // FIRE
        break;
    }
    case 2  : { // RED
        colorWipe2(strip.Color(255, 0, 0), 3); // RED: Estaria bien un degradado
        //colorGradient(255,0,0,255,255,0, 10, 0);
        //colorGradient(255,0,0,255,255,0, 10, 1);
        break;
    }
    case 3  : { // BLUE
         colorWipe2(strip.Color(0, 0, 255), 3); // BLUE: Estaria bien un degradado
        break;
    }
    case 4  : { // GREEN
        colorWipe2(strip.Color(0, 255, 0), 3); // GREEN: Estaria bien un degradado
        break;
    }
  }

}