#include <FastLED.h>
#include "ButtonConfig.h"
#include "Debounce.h"
#include <EEPROM.h>
#include "NeoPixelAnimator.h" // Asegúrate de incluir NeoPixelAnimator

#define patternpos 0
#define colorpos 1

//*********Pin Numbers**************
#define LED_PIN1   6
#define ButtonPin 2

// **********Button Info*************
#define ButtonsUsed 0b00000001  
Debouncer btns(ButtonsUsed);
#define PushButton 0x01
#define buttonchecktime 3

// *********LED strip Info***********
#define LED_TYPE    WS2812
#define COLOR_ORDER GRB
#define VOLTS       5
#define MAX_MA      1500
const uint16_t NUM_LEDS=100;

CRGBArray <NUM_LEDS> leds;

CRGBPalette16 gCurrentPalette;
CRGBPalette16 gTargetPalette;

//********Adjustable Settings************
#define TWINKLE_SPEED 5 
#define TWINKLE_DENSITY 5 
#define CYCLE_SPEED  10
#define SECONDS_PER_PALETTE  100
#define MINUTES_PER_PATTERN 3
#define BRIGHTNESS  80
#define FRAMES_PER_SECOND  120
#define CHASE_CYCLES 5
#define CHASE_CHANGE_RATE 4
#define MIN_CHASE_SPEED 375

uint8_t CHASE_ADJUST = MIN_CHASE_SPEED/CHASE_CYCLES;

const fract8 GlitterChance=60;
const uint8_t BlendChangeRate=12;
uint8_t CurrentPattern;
uint8_t gHue = 0;
bool SolidOn=false;
bool LightsOn=true;

CRGB RotateSolids[] = {CRGB::FairyLight, CRGB::Red, CRGB::Green, ((CRGB::FairyLight & 0xFEFEFE) / 2), CRGB::White};
const uint8_t NumToRotate = sizeof(RotateSolids) / sizeof(RotateSolids[0]);
uint8_t colorindex;

#define Program(x) void (x)(CRGBSet& ledsX, uint16_t NUM_LEDSX)
Program(cycle);
Program(twinkle);
Program(juggle);
Program(confetti);
Program(rainbowWithGlitter);
Program(theaterChase);
typedef Program(*PatternList[]);
PatternList gPatterns = {theaterChase,juggle, confetti, cycle};
const uint8_t numberOfPatterns = sizeof(gPatterns) / sizeof(gPatterns[0]);

// Integración de NeoPixelAnimator para BPM
NeoPixelAnimator animations15(1, NEO_MILLISECONDS); // Inicializa el objeto de animación
uint8_t gHue15 = 0;

// Definición de la animación BPM usando NeoPixelAnimator
void bpm(CRGBSet& ledsX, uint16_t NUM_LEDSX) {
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8(BeatsPerMinute, 64, 255);
  for (int i = 0; i < NUM_LEDSX; i++) {
    ledsX[i] = ColorFromPalette(palette, gHue15 + (i * 2), beat - gHue15 + (i * 10));
  }
}

void Loopanimations15Update(const AnimationParam& param) {
  if (param.state == AnimationState_Completed) {
    bpm(leds, NUM_LEDS); // Llamamos a la animación BPM con FastLED
    gHue15++;
    animations15.RestartAnimation(param.index);
  }
}

void initAnimation15() {
  gHue15 = 0;
  animations15.StartAnimation(0, 10, Loopanimations15Update);
}

void animation15Manager() {
  animations15.UpdateAnimations();
  FastLED.show();  // Necesario para renderizar la animación con FastLED
}

void setup() {
  Serial.begin(9600);
  pinMode(ButtonPin, INPUT_PULLUP);

  // Configuración de FastLED
  FastLED.addLeds<LED_TYPE,LED_PIN1,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.setMaxPowerInVoltsAndMilliamps(VOLTS, MAX_MA);
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.setTemperature(Tungsten40W);

  CurrentPattern = EEPROM[patternpos];
  if (CurrentPattern == numberOfPatterns) { 
    SolidOn=true; 
    colorindex=EEPROM[colorpos];
    Rotate();
  } else if (CurrentPattern > numberOfPatterns) {
    CurrentPattern = 0;
  }
  chooseNextColorPalette(gCurrentPalette);
  gTargetPalette = gCurrentPalette;

  // Inicializar la animación BPM
  initAnimation15();
}

void loop() {
  EVERY_N_MILLISECONDS_I(buttoncheck, buttonchecktime) {
    uint32_t ms = millis();
    btns.ButtonProcess(digitalRead(ButtonPin), ms);

    if (btns.ButtonShortPress(PushButton)) {
      nextPattern();
      Serial.println(CurrentPattern);
    }

    if (btns.ButtonHeld(PushButton)) {
      (LightsOn) ? FastLED.clear(true) : Rotate();
      LightsOn = !LightsOn;
      Serial.println(LightsOn);
    }

    if (btns.ButtonDblClick(PushButton) && LightsOn && SolidOn) {
      Rotate();
    }
  }

  if (LightsOn && !SolidOn) {
    EVERY_N_MILLISECONDS_I(loop, 1000 / FRAMES_PER_SECOND) {
      gPatterns[CurrentPattern](leds, NUM_LEDS);
      FastLED.show();  // Actualiza las luces
    }
    EVERY_N_SECONDS_I(palette, SECONDS_PER_PALETTE) {
      chooseNextColorPalette(gTargetPalette);
    }
    EVERY_N_MILLISECONDS_I(blend, 10) {
      nblendPaletteTowardPalette(gCurrentPalette, gTargetPalette, BlendChangeRate);
    }
  }

  // Actualizar las animaciones BPM
  animation15Manager();
}

void Rotate() {
  FastLED.showColor(RotateSolids[colorindex]);
  EEPROM[colorpos] = colorindex;
  colorindex = addmod8(colorindex, 1, NumToRotate);
}

void nextPattern() {
  CurrentPattern = addmod8(CurrentPattern, 1, numberOfPatterns + 1);
  EEPROM[patternpos] = CurrentPattern;
  if (CurrentPattern == numberOfPatterns) {
    SolidOn = true;
    Rotate();
  } else {
    SolidOn = false;
  }
}