#include <FastLED.h>

#define DATA_PIN_BTN1 2
#define DATA_PIN_BTN2 3

#define NUM_LEDS_BOTTOM 57  //the number of leds that will light
//#define NUM_LEDS_BOTTOM 3  //the number of leds that will light
#define NUM_LEDS_BOTTOM_STATUS 58  //the number of leds that will light
//#define NUM_LEDS_BOTTOM_STATUS 4  //the number of leds that will light
#define NUM_LEDS_EYE 31     //the number of leds that will light
#define NUM_LEDS_TOP 7      //the number of leds that will light

#define NUM_COLOR_SETS 11

#define DATA_PINA 8  // Connect to the data wires on the pixel strips
#define DATA_PINB 7
#define DATA_PINC 6

#define DATA_PINR 13
#define DATA_PING 11
#define DATA_PINB 12

#define LIGHT_0 A0

int lightsOff = 0;

int btn1State;
int btn2State;
int program = 0;

int fadeAmount = 5;  // Set the amount to fade I usually do 5, 10, 15, 20, 25 etc even up to 255.
int brightness = 0;

CRGB ledsA[NUM_LEDS_BOTTOM_STATUS];  // sets number of pixels that will light on each strip.
CRGB ledsB[NUM_LEDS_EYE];
CRGB ledsC[NUM_LEDS_TOP];

int twinkleA[NUM_LEDS_BOTTOM];
int twinkleASteps[NUM_LEDS_BOTTOM];
int twinkleAStepsToDo[NUM_LEDS_BOTTOM];

CRGB bottomDefaultColor;

int colorIndex = 0;
CRGB bottomColors[NUM_COLOR_SETS];
//CRGB color0 = new CRGB(128,50,245);
//CRGB color1 = new CRGB(255,245,182);
//CRGB color2 = new CRGB(75,200,240);

int eyeDefaultR = 100;
int eyeDefaultG = 200;
int eyeDefaultB = 200;

int topDefaultR = 100;
int topDefaultG = 200;
int topDefaultB = 200;

float pulseRate = 1.05;

void loop() {
  int state;
  int delayValue = 50;

  int lightValue;


  //burstFade2(ledsA, NUM_LEDS_BOTTOM, bottomDefaultR, bottomDefaultG, bottomDefaultB);
  //burstFade2(ledsB, NUM_LEDS_EYE, eyeDefaultR, eyeDefaultG, eyeDefaultB);
  //burstFade2(ledsC, NUM_LEDS_TOP, topDefaultR, topDefaultG, topDefaultB);

    switch (program) {
      case 0:
        twinkle();
        break;
      case 1:
        organicOne();
        break;
      case 2:
        pulse();
        break;
      case 3:
        CRGB c = bottomColors[colorIndex];
        burstFade2(ledsA, NUM_LEDS_BOTTOM, c.r, c.g, c.b);
        break;
      case 4:
        burstFadeToBlack();
        break;
    }
  FastLED.show();

  delay(50);  // This delay sets speed of the fade. I usually do from 5-75 but you can always go higher.
}

void setup() {
  long rand;

  Serial.begin(115200);  // Any baud rate should work
  //Serial.println("Starting...\n");

  pinMode(DATA_PIN_BTN1, INPUT);
  pinMode(DATA_PIN_BTN2, INPUT);
  //btn1State = digitalRead(DATA_PIN_BTN1);
  //btn2State = digitalRead(DATA_PIN_BTN2);
  pinMode(DATA_PINR, OUTPUT);
  pinMode(DATA_PING, OUTPUT);
  pinMode(DATA_PINB, OUTPUT);

  bottomColors[0] = CRGB::Aqua;
  bottomColors[1] = CRGB::Aquamarine;
  bottomColors[2] = CRGB::Chartreuse;
  bottomColors[3] = CRGB::Crimson;
  bottomColors[4] = CRGB::DeepSkyBlue;
  bottomColors[5] = CRGB::GreenYellow;
  bottomColors[6] = CRGB::LightSeaGreen;
  bottomColors[7] = CRGB::OrangeRed;
  bottomColors[8] = CRGB::FairyLight;
  bottomColors[9] = CRGB::Violet;
  bottomColors[10] = CRGB::Coral;
  colorIndex = 0;

  FastLED.addLeds<WS2812B, DATA_PINA, GRB>(ledsA, NUM_LEDS_BOTTOM_STATUS);

  //FastLED.addLeds<WS2812B, DATA_PINB, GRB>(ledsB, NUM_LEDS_EYE);
  //FastLED.addLeds<WS2812B, DATA_PINC, GRB>(ledsC, NUM_LEDS_TOP);
  //randomSeed(analogRead(A0));

  //for (int i = 0; i < NUM_LEDS_TOP - 1; i++) {
  //  rand = random(-50, 50);
  //  ledsC[i].setRGB(topDefaultR - rand, topDefaultG - rand, topDefaultB - rand);
  //}
  //ledsC[NUM_LEDS_TOP - 1] = CRGB::Green;
  //for (int i = 0; i < NUM_LEDS_EYE - 1; i++) {
  //rand = random(0, 50);
  //ledsB[i].setRGB(eyeDefaultR - rand, eyeDefaultG - rand, eyeDefaultB - rand);
  //}
  //ledsB[NUM_LEDS_EYE - 1] = CRGB::Red;
  //FastLED.show();
  initFountain();
  FastLED.show();

  delay(1000);
}

void initFountain() {
  CRGB color = bottomColors[colorIndex];

  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {
    ledsA[i].setRGB(color.r, color.g, color.b);
    if (false && random(0, 2) == 1) {
      twinkleA[i] = 1;
      twinkleASteps[i] = getTwinkleSteps();
    } else {
      twinkleA[i] = getTwinkle();
      //twinkleA[i] = 1;
      twinkleASteps[i] = 0;
    }
  }

  switch (program) {
    case 0:
      ledsA[NUM_LEDS_BOTTOM] = CRGB::Blue;
      //analogWrite(DATA_PINR,0);
      //analogWrite(DATA_PING,0);
      //analogWrite(DATA_PINB,128);
      break;
    case 1:
      ledsA[NUM_LEDS_BOTTOM] = CRGB::Green;
      //analogWrite(DATA_PINR,0);
      //analogWrite(DATA_PING,32);
      //analogWrite(DATA_PINB,256);
      break;
    case 2:
      ledsA[NUM_LEDS_BOTTOM] = CRGB::Red;
      //analogWrite(DATA_PINR,0);
      //analogWrite(DATA_PING,64);
      //analogWrite(DATA_PINB,128);
      break;
    case 3:
      ledsA[NUM_LEDS_BOTTOM] = CRGB::Purple;
      //analogWrite(DATA_PINR,0);
      //analogWrite(DATA_PING,96);
      //analogWrite(DATA_PINB,128);
      break;
    case 4:
      ledsA[NUM_LEDS_BOTTOM] = CRGB::Yellow;
      //analogWrite(DATA_PINR,0);
      //analogWrite(DATA_PING,196);
      //analogWrite(DATA_PINB,255);
      break;
  }

  switch (colorIndex) {
    case 0:
      //analogWrite(DATA_PINR,10);
      break;
    case 1:
      //analogWrite(DATA_PINR,128);
      break;
    case 2:
      //analogWrite(DATA_PINR,255);
      break;
  }

  FastLED.show();
}

int getTwinkle() {
  return (256 - random(2, 11));
}

int getTwinkleSteps() {
  //return (random(100, 111));
  return(100);
}

void twinkle() {
  int r, g, b, t;
  CRGB c = bottomColors[colorIndex];

  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {

    if (twinkleASteps[i] == 0 ) {
      ledsA[i].nscale8(twinkleA[i]);

      if (ledsA[i].r <= (c.r * .001) && ledsA[i].g <= (c.g * .001) && ledsA[i].b <= (c.b * .001)) {
        ledsA[i]=CRGB::Black;
        t = getTwinkleSteps();
        twinkleASteps[i] = t;
        twinkleAStepsToDo[i] = t;
        //reverse
      }
    }
    else {
      if(i == 10 ){
        Serial.print("  steps left to do: ");
        Serial.println(twinkleAStepsToDo[i]);
      }

      if( twinkleAStepsToDo[i] > 0  ){
        twinkleAStepsToDo[i]--;

        if( i == 10 ){
            Serial.print("  current b value:");
            Serial.println(ledsA[i].b);
            Serial.print(" adding to b: ");
            Serial.println((c.b / twinkleASteps[i]));
        }


        safeAddRed(ledsA[i], (c.r / twinkleASteps[i]));
        safeAddGreen(ledsA[i], (c.g / twinkleASteps[i]));
        safeAddBlue(ledsA[i], (c.b / twinkleASteps[i]));
        twinkleAStepsToDo[i]=0;
      }
      else{

        if( i = =10 ){
          Serial.println("RESETTING LED 10");
        }
        ledsA[i].r = c.r;
        ledsA[i].g = c.g;
        ledsA[i].b = c.b;
        twinkleASteps[i] = 0;
        twinkleA[i] = getTwinkle();
      }
    }
  }
}


void pulse() {
  int r, g, b, min, max;
  float fadeRate = 0.05;

  min = getMinimumValue(ledsA[1]);
  max = getMaximumValue(ledsA[1]);

  if (min <= 10) {
    pulseRate = 1.05;
  } else if (max >= 245) {
    pulseRate = 0.95;
  }

  //minVal = min(led.r, led.g);
  r = ledsA[1].r * pulseRate;
  g = ledsA[1].g * pulseRate;
  b = ledsA[1].b * pulseRate;

  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {
    ledsA[i].setRGB(r, g, b);
  }
}

void burstFade2(CRGB leds[], int numLed, int defaultR, int defaultG, int defaultB) {
  long rand;
  long fade;
  int maxVal;
  int minVal;

  for (int i = 0; i < numLed; i++) {
    rand = random(32);
    fade = random(20);

    maxVal = getMaximumValue(leds[i]);
    minVal = getMinimumValue(leds[i]);

    if (rand == 31) {
      //Serial.println("BAND\n");
      if (fade % 2 == 0) {
        leds[i].setRGB(defaultR, defaultG, defaultB);
      } else {
        //leds[i].setRGB(defaultR/2,defaultG/2,defaultB/2);
      }
    } else if (maxVal > 250) {
      safeSubtract(leds[i], fade);
    } else if (minVal < 5) {
      safeAdd(leds[i], fade);
    } else if (rand % 2) {
      safeSubtract(leds[i], fade);
    } else {
      safeAdd(leds[i], fade);
    }
  }
}

void burstFadeToBlack() {
  long rand;
  long fade;
  int factor;
  int minVal;
  CRGB c = bottomColors[colorIndex];

  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {
    rand = random(81);
    fade = random(15);

    minVal = getMinimumValue(ledsA[i]);

    if (minVal < 5) {
      if (rand % 10 == 0) {
        ledsA[i].setRGB(c.r, c.g, c.b);
      } else {
        ledsA[i] = CRGB::Black;
      }
    } else if (rand % 2 == 0) {

      if (minVal - fade > 0) {

        ledsA[i].r -= fade;
        ledsA[i].g -= fade;
        ledsA[i].b -= fade;
      }
    }
  }
}

int getMinimumValue(CRGB led) {
  int minVal = 0;

  minVal = min(led.r, led.g);
  minVal = min(minVal, led.b);
  return (minVal);
}

int getMaximumValue(CRGB led) {
  int maxVal = 0;

  maxVal = max(led.r, led.g);
  maxVal = max(maxVal, led.b);
  return (maxVal);
}

void safeSubtract(CRGB& led, int fade) {
  int minValue = getMinimumValue(led);

  if (minValue < fade) {
    fade = minValue;
  }
  led.r -= fade;
  led.g -= fade;
  led.b -= fade;
}

void safeAdd(CRGB& led, int fade) {
  int maxValue = getMaximumValue(led);

  if ((maxValue + fade > 255)) {
    fade = 255 - maxValue;
  }
  led.r += fade;
  led.g += fade;
  led.b += fade;
}

void organicOne() {
  long rand;
  long fade;
  int maxVal;
  int minVal;
  CRGB c = bottomColors[colorIndex];

  fade = random(20);
  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {
    rand = random(32);

    maxVal = getMaximumValue(ledsA[i]);
    minVal = getMinimumValue(ledsA[i]);

    if (rand == 31) {
      //Serial.println("BAND\n");
      if (fade % 2 == 0) {
        ledsA[i].setRGB(c.r, c.g, c.b);
      }
    } else if (maxVal > 250) {
      safeSubtract(ledsA[i], fade);
    } else if (minVal < 5) {
      safeAdd(ledsA[i], fade);
    } else if (rand % 2) {
      safeSubtract(ledsA[i], fade * 2);
    } else {
      safeAdd(ledsA[i], fade);
    }
  }
}

void organicTwo() {
  long rand;
  long fade;

  int rSum;
  int gSum;
  int bSum;

  int n = 1;
  int direction = 0;  // 0 both; 1 left; 2 right

  int j, k, count;
  CRGB c = bottomColors[colorIndex];

  Serial.print("organicTwo\n");

  fade = random(-3, 3);
  for (int i = 0; i < NUM_LEDS_BOTTOM; i++) {
    //for(int i = 0; i < 6-1; i++ ){
    rand = random(32);
    rSum = 0;
    gSum = 0;
    bSum = 0;
    count = 0;

    if (direction == 0 or direction == 1) {
      j = i - n;
      if (j < 0) {
        j = 0;
      }
      for (k = j; k < i; k++) {
        rSum += ledsA[k].red;
        gSum += ledsA[k].green;
        bSum += ledsA[k].blue;
        count++;
      }
    }

    if (direction == 0 || direction == 2) {
      j = i + n;
      if (j >= NUM_LEDS_BOTTOM) {
        j = NUM_LEDS_BOTTOM - 1;
      }
      for (k = i + 1; k <= j; k++) {
        rSum += ledsA[k].red;
        gSum += ledsA[k].green;
        bSum += ledsA[k].blue;
        count++;
      }
    }

    if (rand == 31) {
      //Serial.println("BAND\n");
      if (fade % 2 == 0) {
        ledsA[i].setRGB(c.r, c.g, c.b);
      }
    } else {
      safeSetRed(ledsA[i], int(rSum / count) + fade);
      safeSetBlue(ledsA[i], int(bSum / count) + fade);
      safeSetGreen(ledsA[i], int(gSum / count) + fade);
    }
  }
  FastLED.show();
}

void safeSetRed(CRGB& led, int val) {
  if (val > 255) {
    val = 255;
  } else if (val < 0) {
    val = 0;
  }
  led.r = val;
}

void safeSetGreen(CRGB& led, int val) {
  if (val > 255) {
    val = 255;
  } else if (val < 0) {
    val = 0;
  }
  led.g = val;
}

void safeSetBlue(CRGB& led, int val) {
  if (val > 255) {
    val = 255;
  } else if (val < 0) {
    val = 0;
  }
  led.b = val;
}

void safeAddRed(CRGB& led, int val) {

  if (val < 0) {
    return (safeSubRed(led, -val));
  }

  if ((led.r + val > 255) < val) {
    val = 255 - led.r;
  }
  led.r += val;
}

void safeSubRed(CRGB& led, int val) {

  if (val < 0) {
    return (safeAddRed(led, -val));
  }

  if (led.r < val) {
    val = led.r;
  }
  led.r -= val;
}

void safeAddGreen(CRGB& led, int val) {

  if (val < 0) {
    return (safeSubGreen(led, -val));
  }

  if ((led.g + val > 255) < val) {
    val = 255 - led.g;
  }
  led.g += val;
}

void safeSubGreen(CRGB& led, int val) {

  if (val < 0) {
    return (safeAddGreen(led, -val));
  }

  if (led.g < val) {
    val = led.g;
  }
  led.g -= val;
}

void safeAddBlue(CRGB& led, int val) {

  if (val < 0) {
    return (safeSubBlue(led, -val));
  }

  if ((led.b + val > 255) < val) {
    val = 255 - led.b;
  }
  led.b += val;
}

void safeSubBlue(CRGB& led, int val) {

  if (val < 0) {
    return (safeAddBlue(led, -val));
  }

  if (led.b < val) {
    val = led.b;
  }
  led.b -= val;
}