#include <Adafruit_NeoPixel.h>

// Paramètres des LEDs WS2811
#define NUMPIXELS 12

// Pins des LEDs
const int ledPins[NUMPIXELS] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};

// Pins des boutons
#define BUTTON1_PIN 2
#define BUTTON2_PIN 3
#define BUTTON3_PIN 4
#define BUTTON4_PIN 5
#define BUTTON5_PIN 18
#define BUTTON6_PIN 19
#define BUTTON7_PIN 20
#define BUTTON8_PIN 21
#define BUTTON9_PIN 22

// Pins de l'interrupteur 4 positions
#define SWITCH_PIN_1 23
#define SWITCH_PIN_2 24
#define SWITCH_PIN_3 25
#define SWITCH_PIN_4 26

// Pin du potentiomètre
#define POTENTIOMETER_PIN A0

// Création des objets NeoPixel pour chaque LED
Adafruit_NeoPixel pixels[NUMPIXELS] = {
  Adafruit_NeoPixel(1, ledPins[0], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[1], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[2], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[3], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[4], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[5], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[6], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[7], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[8], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[9], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[10], NEO_GRB + NEO_KHZ800),
  Adafruit_NeoPixel(1, ledPins[11], NEO_GRB + NEO_KHZ800)
};

// Couleurs utilisées pour l'animation
uint32_t colors[] = {
  Adafruit_NeoPixel::Color(255, 0, 0), // Rouge
  Adafruit_NeoPixel::Color(0, 255, 0), // Vert
  Adafruit_NeoPixel::Color(0, 0, 255), // Bleu
  Adafruit_NeoPixel::Color(255, 255, 0), // Jaune
  Adafruit_NeoPixel::Color(0, 255, 255), // Cyan
  Adafruit_NeoPixel::Color(255, 0, 255) // Magenta
};
const int numColors = sizeof(colors) / sizeof(colors[0]);

// Variables pour suivre l'état des boutons et de l'animation
bool button1Pressed = false;
bool button2Pressed = false;
bool button3Pressed = false;
bool button4Pressed = false;
bool button5Pressed = false;
bool button6Pressed = false;
bool button7Pressed = false;
bool button8Pressed = false;
bool button9Pressed = false;
bool wasButton1Pressed = false;
bool wasButton2Pressed = false;
bool wasButton3Pressed = false;
bool wasButton4Pressed = false;
bool wasButton5Pressed = false;
bool wasButton6Pressed = false;
bool wasButton7Pressed = false;
bool wasButton8Pressed = false;
bool wasButton9Pressed = false;
bool isAnimating = false;
bool flashMode = false;
bool wasFlashing = false;
int currentColor = 0;
int currentStep = 0;
unsigned long lastUpdateTime = 0;
unsigned long flashStartTime = 0;
int animationMode = 0;
unsigned long animationInterval = 100;

// Sauvegarde de l'état précédent des LEDs
uint32_t previousState[NUMPIXELS];

void setup() {
  // Initialisation des LEDs WS2811
  for (int i = 0; i < NUMPIXELS; i++) {
    pixels[i].begin();
    pixels[i].show(); // Initialise toutes les LEDs à 'off'
  }

  // Configuration des pins des boutons
  pinMode(BUTTON1_PIN, INPUT_PULLUP); // Utilise la résistance de pull-up interne
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
  pinMode(BUTTON3_PIN, INPUT_PULLUP);
  pinMode(BUTTON4_PIN, INPUT_PULLUP);
  pinMode(BUTTON5_PIN, INPUT_PULLUP);
  pinMode(BUTTON6_PIN, INPUT_PULLUP);
  pinMode(BUTTON7_PIN, INPUT_PULLUP);
  pinMode(BUTTON8_PIN, INPUT_PULLUP);
  pinMode(BUTTON9_PIN, INPUT_PULLUP);

  // Configuration des pins de l'interrupteur 4 positions
  pinMode(SWITCH_PIN_1, INPUT_PULLUP);
  pinMode(SWITCH_PIN_2, INPUT_PULLUP);
  pinMode(SWITCH_PIN_3, INPUT_PULLUP);
  pinMode(SWITCH_PIN_4, INPUT_PULLUP);
}

void loop() {
  // Lire l'état des boutons
  button1Pressed = digitalRead(BUTTON1_PIN) == LOW;
  button2Pressed = digitalRead(BUTTON2_PIN) == LOW;
  button3Pressed = digitalRead(BUTTON3_PIN) == LOW;
  button4Pressed = digitalRead(BUTTON4_PIN) == LOW;
  button5Pressed = digitalRead(BUTTON5_PIN) == LOW;
  button6Pressed = digitalRead(BUTTON6_PIN) == LOW;
  button7Pressed = digitalRead(BUTTON7_PIN) == LOW;
  button8Pressed = digitalRead(BUTTON8_PIN) == LOW;
  button9Pressed = digitalRead(BUTTON9_PIN) == LOW;

  // Lire la position de l'interrupteur 4 positions
  if (digitalRead(SWITCH_PIN_1) == LOW) {
    animationMode = 0;
  } else if (digitalRead(SWITCH_PIN_2) == LOW) {
    animationMode = 1;
  } else if (digitalRead(SWITCH_PIN_3) == LOW) {
    animationMode = 2;
  } else if (digitalRead(SWITCH_PIN_4) == LOW) {
    animationMode = 3;
  }

  // Lire la valeur du potentiomètre et ajuster l'intervalle d'animation
  int potValue = analogRead(POTENTIOMETER_PIN);
  animationInterval = map(potValue, 0, 1023, 50, 500);

  // Gestion du bouton 1
  if (button1Pressed && !wasButton1Pressed) {
    isAnimating = !isAnimating; // Bascule l'état d'animation
    if (isAnimating) {
      // Allume toutes les LEDs en bleu
      setAllPixelsColor(Adafruit_NeoPixel::Color(0, 0, 255));
      delay(1000); // Attendre 1 seconde avant de commencer l'animation
      currentColor = 0;
      currentStep = 0;
      lastUpdateTime = millis();
    }
  }
  wasButton1Pressed = button1Pressed;

  // Gestion du bouton 2
  if (button2Pressed && !wasButton2Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(255, 255, 0)); // Jaune
    isAnimating = false;
    flashMode = false;
  }
  wasButton2Pressed = button2Pressed;

  // Gestion du bouton 3
  if (button3Pressed && !wasButton3Pressed) {
    flashMode = true;
    flashStartTime = millis();
    wasFlashing = true;
    saveCurrentState(); // Sauvegarder l'état actuel des LEDs
  } else if (!button3Pressed && wasButton3Pressed) {
    flashMode = false;
    wasFlashing = false;
    restorePreviousState(); // Restaurer l'état précédent des LEDs
  }
  wasButton3Pressed = button3Pressed;

  // Gestion du bouton 4
  if (button4Pressed && !wasButton4Pressed) {
    turnOffAllPixels();
    isAnimating = false;
    flashMode = false;
  }
  wasButton4Pressed = button4Pressed;

  // Gestion du bouton 5
  if (button5Pressed && !wasButton5Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(255, 255, 255)); // Blanc
    isAnimating = false;
    flashMode = false;
  }
  wasButton5Pressed = button5Pressed;

  // Gestion du bouton 6
  if (button6Pressed && !wasButton6Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(0, 255, 0)); // Vert
    isAnimating = false;
    flashMode = false;
  }
  wasButton6Pressed = button6Pressed;

  // Gestion du bouton 7
  if (button7Pressed && !wasButton7Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(255, 255, 255)); // Blanc
    isAnimating = false;
    flashMode = false;
  }
  wasButton7Pressed = button7Pressed;

  // Gestion du bouton 8
  if (button8Pressed && !wasButton8Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(255, 0, 0)); // Rouge
    isAnimating = false;
    flashMode = false;
  }
  wasButton8Pressed = button8Pressed;

  // Gestion du bouton 9
  if (button9Pressed && !wasButton9Pressed) {
    setAllPixelsColor(Adafruit_NeoPixel::Color(0, 0, 255)); // Bleu
    isAnimating = false;
    flashMode = false;
  }
  wasButton9Pressed = button9Pressed;

  // Animation principale
  if (isAnimating && !flashMode) {
    switch (animationMode) {
      case 0:
        runAnimation();
        break;
      case 1:
        runRainbowAnimation();
        break;
      case 2:
        runSolidColorAnimation();
        break;
      case 3:
        runSplitAnimation();
        break;
    }
  } else if (flashMode) {
    flashAllPixels(Adafruit_NeoPixel::Color(255, 255, 255), 100); // Blanc clignotant rapide (stroboscope)
  }
}

void runAnimation() {
  unsigned long currentTime = millis();
  if (currentTime - lastUpdateTime >= animationInterval) {
    lastUpdateTime = currentTime;
    // Éteint toutes les LEDs
    for (int j = 0; j < NUMPIXELS; j++) {
      pixels[j].clear();
    }

    // Allume la LED actuelle avec la couleur actuelle
    pixels[currentStep].setPixelColor(0, colors[currentColor]);
    pixels[currentStep].show();

    currentStep++;
    if (currentStep >= NUMPIXELS) {
      currentStep = 0;
      currentColor++;
      if (currentColor >= numColors) {
        currentColor = 0;
      }
    }
  }
}

void runRainbowAnimation() {
  unsigned long currentTime = millis();
  if (currentTime - lastUpdateTime >= animationInterval) {
    lastUpdateTime = currentTime;
    for (int i = 0; i < NUMPIXELS; i++) {
      uint16_t hue = (currentStep * 5 + i * 256 / NUMPIXELS) & 255;
      pixels[i].setPixelColor(0, pixels[i].gamma32(pixels[i].ColorHSV(hue * 65536L / 256)));
      pixels[i].show();
    }
    currentStep++;
    if (currentStep >= 256) {
      currentStep = 0;
    }
  }
}

void runSolidColorAnimation() {
  unsigned long currentTime = millis();
  if (currentTime - lastUpdateTime >= animationInterval) {
    lastUpdateTime = currentTime;
    uint32_t color = pixels[currentStep % numColors].ColorHSV(currentStep * 65536L / numColors);
    setAllPixelsColor(color);
    currentStep++;
  }
}

void runSplitAnimation() {
  unsigned long currentTime = millis();
  if (currentTime - lastUpdateTime >= animationInterval) {
    lastUpdateTime = currentTime;
    for (int i = 0; i < NUMPIXELS; i++) {
      uint32_t color = colors[(i + currentStep) % numColors];
      pixels[i].setPixelColor(0, color);
      pixels[i].show();
    }
    currentStep++;
  }
}

void setAllPixelsColor(uint32_t color) {
  for (int i = 0; i < NUMPIXELS; i++) {
    pixels[i].setPixelColor(0, color);
    pixels[i].show();
  }
}

void flashAllPixels(uint32_t color, int delayTime) {
  unsigned long currentTime = millis();
  if ((currentTime - flashStartTime) % (2 * delayTime) < delayTime) {
    setAllPixelsColor(color);
  } else {
    turnOffAllPixels();
  }
}

void turnOffAllPixels() {
  for (int i = 0; i < NUMPIXELS; i++) {
    pixels[i].clear();
    pixels[i].show();
  }
}

void saveCurrentState() {
  for (int i = 0; i < NUMPIXELS; i++) {
    previousState[i] = pixels[i].getPixelColor(0);
  }
}

void restorePreviousState() {
  for (int i = 0; i < NUMPIXELS; i++) {
    pixels[i].setPixelColor(0, previousState[i]);
    pixels[i].show();
  }
}