#include <Adafruit_NeoPixel.h>
#define PIN 0
#define PIN2 1
bool pressed, pulse, reverse = false;
uint8_t rit = 0;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(48, PIN, NEO_GRB + NEO_KHZ800);


void setup() {
  strip.begin();
  strip.show(); 
  pinMode(PIN2, INPUT_PULLUP);
}

void loop() {
  buttonPress();
  if(pulse) breath();
  else demo_rotate();
}

void buttonPress(){
  pressed = digitalRead(PIN2);
  if (pressed == 1) {
    while (pressed == 1) {
      delay(5);
      pressed = digitalRead(PIN2);
    }
    if (pulse) pulse = false;
    else  pulse = true;
  }
}

void breath() {
  const uint8_t maxPixels = 40; 
  const uint16_t hueIncrement = 15;
  const uint8_t lightnessIncrement = 4;
  const uint8_t numIterations = 9;
  const uint8_t delayTime = 100;

  static uint16_t hue = 0;
  static uint8_t saturation = 100;
  static uint8_t lightness = 80;

  uint32_t color;

  color = hsl(hue+=15, saturation, lightness);
  
  for (uint8_t k = 0; k < 2; k++) {
    for (uint8_t i = 0; i < numIterations; i++) {
      color = hsl(hue, saturation, lightness);
      for (uint8_t j = 0; j < maxPixels; j++) {
        strip.setPixelColor(j, color);
      }
      strip.show();
      lightness += (k == 0) ? -lightnessIncrement : lightnessIncrement;
      delay(delayTime);
      buttonPress();
    }
  }

  hue %= 360;
}


void demo_rotate() { 
  static uint8_t massimo = 24;                //massimo numero di pixel della striscia grande
  
  static uint16_t hue = 0; // 0-359           //rotazione del colore
  static uint8_t saturation = 100; // 0-100
 static uint8_t lightness = 50; // 0-100
  
  uint32_t color;
  uint8_t i, num = 0, tempo = 30; 
  
  if(!reverse) {
    rit+=3; 
    if(rit >= 15) reverse = true;             //finchè rit è inferiore a 11 continua a sommare
  }
  else if(reverse) {
    rit-=3; 
    if(rit <= 0) reverse = false;             //finchè rit è maggiore di 11 continua a sottrarre
  }

  for(i=0; i < massimo; i++) {
    buttonPress();
    color = hsl(hue+=3, saturation, lightness);   //creazione del colore tramite funzione di conversione da rgb a hsl
    strip.setPixelColor(i, color);                //impostazione del colore sulla strip
    if(i%3==0) num++;                             //se il numero è divisibile per 3 aggiungo 1 a num per poi sottrarlo al numero della striscia principale
    strip.setPixelColor(24+i-num, color);         //imposto il pixel di partenza della seconda striscia
    strip.show();                                 //aggiorno i pixel
    delay(5+(rit));
  }

  hue %= 360;
}

uint32_t hsl(uint16_t ih, uint8_t is, uint8_t il) {

  float h, s, l, t1, t2, tr, tg, tb;
  uint8_t r, g, b;

  h = (ih % 360) / 360.0;
  s = constrain(is, 0, 100) / 100.0;
  l = constrain(il, 0, 100) / 100.0;

  if ( s == 0 ) { 
    r = g = b = 255 * l;
    return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
  } 
  
  if ( l < 0.5 ) t1 = l * (1.0 + s);
  else t1 = l + s - l * s;
  
  t2 = 2 * l - t1;
  tr = h + 1/3.0;
  tg = h;
  tb = h - 1/3.0;

  r = hsl_convert(tr, t1, t2);
  g = hsl_convert(tg, t1, t2);
  b = hsl_convert(tb, t1, t2);

  return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
}

uint8_t hsl_convert(float c, float t1, float t2) {

  if ( c < 0 ) c+=1; 
  else if ( c > 1 ) c-=1;

  if ( 6 * c < 1 ) c = t2 + ( t1 - t2 ) * 6 * c;
  else if ( 2 * c < 1 ) c = t1;
  else if ( 3 * c < 2 ) c = t2 + ( t1 - t2 ) * ( 2/3.0 - c ) * 6;
  else c = t2;
  
  return (uint8_t)(c*255); 
}