#include <FastLED.h>
#include <OneButton.h>

#define LED_PIN     5
#define BTN_PIN     7
#define NUM_LEDS    50
#define BRIGHTNESS  64
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

OneButton btn = OneButton(
  BTN_PIN,  // Input pin for the button
  true,        // Button is active LOW
  true         // Enable internal pull-up resistor
);

// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.

CRGBPalette16 currentPalette;
TBlendType    currentBlending;

uint8_t loopIndex = 0;
uint8_t currentPattern = 0;

#define NumPatterns 4;

extern CRGBPalette16 PinkParadise;
extern const TProgmemPalette16 PinkParadise_p PROGMEM;

void setup() {

    Serial.begin(115200); // Any baud rate should work

    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness( BRIGHTNESS );

    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;

    btn.attachClick(HandleClick);
}


void loop()
{
    //ChangePalettePeriodically();

    loopIndex = loopIndex + 1; /* motion speed */

    FillLEDsFromPaletteColors();

    FastLED.show();
    FastLED.delay(1000 / UPDATES_PER_SECOND);

    btn.tick();

}

void SetPattern() {

  switch (currentPattern) {
    case 0:
      currentPalette = RainbowColors_p; 
      currentBlending = LINEARBLEND;
      break;

    case 1:
      currentPalette = RainbowColors_p; 
      currentBlending = NOBLEND;
      break;

    case 2:
      currentPalette = ForestColors_p; 
      currentBlending = LINEARBLEND;
      break;

    case 3:
      currentPalette = PinkParadise_p; 
      currentBlending = LINEARBLEND;
      break;

  }

}

void HandleClick() {

  Serial.println("Clicked!");

  currentPattern = (currentPattern + 1) % NumPatterns;
  SetPattern();

}

void FillLEDsFromPaletteColors()
{
    uint8_t brightness = 255;
    uint8_t colorIndex = loopIndex;

    for( int i = 0; i < NUM_LEDS; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;
    }
}


// // There are several different palettes of colors demonstrated here.
// //
// // FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// // OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
// //
// // Additionally, you can manually define your own color palettes, or you can write
// // code that creates color palettes on the fly.  All are shown here.

// void ChangePalettePeriodically()
// {
//     uint8_t secondHand = (millis() / 1000) % 60;
//     static uint8_t lastSecond = 99;

//     if( lastSecond != secondHand) {
//         lastSecond = secondHand;
//         if( secondHand ==  0)  { currentPalette = RainbowColors_p;         currentBlending = LINEARBLEND; }
//         if( secondHand == 10)  { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
//         if( secondHand == 15)  { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
//         if( secondHand == 20)  { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
//         if( secondHand == 25)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
//         if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
//         if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
//         if( secondHand == 40)  { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
//         if( secondHand == 45)  { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
//         if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
//         if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
//     }
// }

// // This function fills the palette with totally random colors.
// void SetupTotallyRandomPalette()
// {
//     for( int i = 0; i < 16; i++) {
//         currentPalette[i] = CHSV( random8(), 255, random8());
//     }
// }

// // Additional notes on FastLED compact palettes:
// //
// // Normally, in computer graphics, the palette (or "color lookup table")
// // has 256 entries, each containing a specific 24-bit RGB color.  You can then
// // index into the color palette using a simple 8-bit (one byte) value.
// // A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// // is quite possibly "too many" bytes.
// //
// // FastLED does offer traditional 256-element palettes, for setups that
// // can afford the 768-byte cost in RAM.
// //
// // However, FastLED also offers a compact alternative.  FastLED offers
// // palettes that store 16 distinct entries, but can be accessed AS IF
// // they actually have 256 entries; this is accomplished by interpolating
// // between the 16 explicit entries to create fifteen intermediate palette
// // entries between each pair.
// //
// // So for example, if you set the first two explicit entries of a compact
// // palette to Green (0,255,0) and Blue (0,0,255), and then retrieved
// // the first sixteen entries from the virtual palette (of 256), you'd get
// // Green, followed by a smooth gradient from green-to-blue, and then Blue.


const TProgmemPalette16 PinkParadise_p PROGMEM =
{
    CRGB::Amethyst,
    CRGB::DarkOrchid,
    CRGB::DarkViolet,
    CRGB::Indigo,

    CRGB::HotPink,
    CRGB::Fuchsia,
    CRGB::HotPink,
    CRGB::DeepPink,

    CRGB::Amethyst,
    CRGB::DarkOrchid,
    CRGB::DarkViolet,
    CRGB::Indigo,

    CRGB::HotPink,
    CRGB::Fuchsia,
    CRGB::HotPink,
    CRGB::DeepPink
};