/*
//const int ledPins[] = {2, 3, 4, 5, 9, 10};
const int ledPins[] = {A0, A1, A2, A3, A4, A5};

const int numLeds = 6;

const int startButtonPin = 7;   // START button
const int modeButtonPin  = 8;   // Speed mode button

void setup() {
  // Initialize random seed
  randomSeed(analogRead(0));

  // Set LED pins as outputs
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
  }

  // Set buttons as INPUT_PULLUP
  pinMode(startButtonPin, INPUT_PULLUP);
  pinMode(modeButtonPin, INPUT_PULLUP);
}

void loop() {

  // Wait for START button press
  while (digitalRead(startButtonPin) == HIGH) {
    // Waiting...
  }

  // Debounce delay
  delay(200);

  // Array to track used LEDs
  boolean ledUsed[numLeds];
  for (int i = 0; i < numLeds; i++) {
    ledUsed[i] = false;
  }

  // Generate random sequence
  for (int i = 0; i < numLeds; i++) {

    int randomDelay;

    // Check mode button
    if (digitalRead(modeButtonPin) == LOW) {
      // Fast mode (button pressed)
      randomDelay = random(500, 1001);
    } else {
      // Normal mode
      randomDelay = random(3000, 5001);
    }

    delay(randomDelay);

    int randomIndex;
    do {
      randomIndex = random(0, numLeds);
    } while (ledUsed[randomIndex]);

    // Turn LED ON
    digitalWrite(ledPins[randomIndex], HIGH);
    delay(200);
    digitalWrite(ledPins[randomIndex], LOW);

    ledUsed[randomIndex] = true;
  }

  // Small delay before next round
  delay(500);
}
*/



// -----------------------------
// Stick Catch Game with RGB FX
// -----------------------------

// Electromagnet / LED pins
/*
const int ledPins[] = {A0, A1, A2, A3, A4, 2};
const int numLeds = sizeof(ledPins) / sizeof(ledPins[0]);

// Buttons
const int startButtonPin = 7;
const int modeButtonPin  = 8;

// RGB strip pins (PWM → MOSFETs)
const int redPin   = 9;
const int greenPin = 10;
const int bluePin  = 11;


// -----------------------------
// RGB Control (Common Anode)
// -----------------------------
void setColor(int r, int g, int b) {
  analogWrite(redPin,   255 - r);
  analogWrite(greenPin, 255 - g);
  analogWrite(bluePin,  255 - b);
}


// -----------------------------
// Idle Effect
// -----------------------------
void idleBreathing() {

  for (int i = 0; i < 255; i++) {
    if (digitalRead(startButtonPin) == LOW) return;

    setColor(i/2, 0, i);
    delay(10);
  }

  for (int i = 255; i > 0; i--) {
    if (digitalRead(startButtonPin) == LOW) return;

    setColor(i/2, 0, i);
    delay(10);
  }
}


// -----------------------------
// Start Animations
// -----------------------------
void energyCharge() {

  for (int i = 0; i < 255; i+=5) {
    setColor(i,0,0);
    delay(20);
  }

  for (int i = 0; i < 255; i+=5) {
    setColor(255,i/2,0);
    delay(15);
  }

  setColor(255,255,255);
  delay(200);

  setColor(0,0,0);
}

void arcadeSweep() {

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

    setColor(0,0,255);
    delay(200);

    setColor(0,255,0);
    delay(200);

    setColor(255,0,0);
    delay(200);

    setColor(0,0,0);
    delay(100);
  }
}

void heartbeatBuild() {

  for(int i=0;i<3;i++){
    setColor(255,0,0);
    delay(120);
    setColor(0,0,0);
    delay(400);
  }

  for(int i=0;i<5;i++){
    setColor(255,0,0);
    delay(80);
    setColor(0,0,0);
    delay(120);
  }
}


// -----------------------------
// Suspense Mode
// -----------------------------
void suspenseGlow(int duration) {

  setColor(80,80,80);
  delay(duration);

}


// -----------------------------
// Stick Drop Flash
// -----------------------------
void dropFlash() {

  setColor(255,0,0);
  delay(120);
  setColor(0,0,0);

}


// -----------------------------
// Rainbow Flicker
// -----------------------------
void rainbowFlicker() {

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

    setColor(random(255), random(255), random(255));
    delay(70);

  }

  setColor(0,0,0);

}


// -----------------------------
// End Effects
// -----------------------------
void successPulse() {

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

    setColor(0,255,0);
    delay(200);

    setColor(0,0,0);
    delay(200);

  }

}

void failFade() {

  for(int i=255;i>0;i-=5){

    setColor(i,0,0);
    delay(20);

  }

  setColor(0,0,0);

}


// -----------------------------
// Setup
// -----------------------------
void setup() {

  randomSeed(analogRead(A5));

  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
  }

  pinMode(startButtonPin, INPUT_PULLUP);
  pinMode(modeButtonPin, INPUT_PULLUP);

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}


// -----------------------------
// Main Loop
// -----------------------------
void loop() {

  // Idle until start pressed
  while (digitalRead(startButtonPin) == HIGH) {
    idleBreathing();
  }

  delay(200);

  // Start animation (choose one)
  //energyCharge();
  arcadeSweep();
 // heartbeatBuild();


  // Track used sticks
  boolean ledUsed[numLeds];

  for(int i=0;i<numLeds;i++){
    ledUsed[i] = false;
  }


  // Drop sequence
  for (int i = 0; i < numLeds; i++) {

    int randomDelay;

    if (digitalRead(modeButtonPin) == LOW) {
      randomDelay = random(500,1000);
    } 
    else {
      randomDelay = random(3000,5000);
    }

    suspenseGlow(randomDelay);

    int randomIndex;

    do {
      randomIndex = random(0,numLeds);
    } 
    while (ledUsed[randomIndex]);

    dropFlash();

    digitalWrite(ledPins[randomIndex], HIGH);

    rainbowFlicker();

    digitalWrite(ledPins[randomIndex], LOW);

    ledUsed[randomIndex] = true;

  }


  // End animation
  successPulse();
  //failFade();

  delay(1000);

}

*/

// -----------------------------
// Stick Catch Game with Rainbow Idle & Event-Based RGB
// -----------------------------

// Stick / electromagnet pins
const int ledPins[] = {A0, A1, A2, A3, A4, 2};  // A5 freed for random seed
const int numLeds = sizeof(ledPins) / sizeof(ledPins[0]);

// Buttons
const int startButtonPin = 7;
const int modeButtonPin  = 8;

// RGB strip pins (PWM → MOSFETs)
const int redPin   = 9;
const int greenPin = 10;
const int bluePin  = 11;

// -----------------------------
// RGB Control (Common Anode)
// -----------------------------
void setColor(int r, int g, int b) {
  analogWrite(redPin,   255 - r);
  analogWrite(greenPin, 255 - g);
  analogWrite(bluePin,  255 - b);
}

// -----------------------------
// Idle Effect — Rainbow Scroll
// -----------------------------
void idleRainbow() {
  const int delayTime = 50;  // speed of the rainbow
  for (int hue = 0; hue < 360; hue += 2) {

    // Stop immediately if START button pressed
    if (digitalRead(startButtonPin) == LOW) return;

    // Convert hue to RGB
    int r, g, b;
    hueToRGB(hue, r, g, b);

    setColor(r, g, b);
    delay(delayTime);
  }
}

// -----------------------------
// Hue to RGB Conversion
// hue: 0–360
// r,g,b: 0–255
// -----------------------------
void hueToRGB(int hue, int &r, int &g, int &b) {
  float h = hue / 60.0;         // sector 0–5
  int i = int(h) % 6;
  float f = h - i;
  int q = int(255 * (1 - f));
  int t = int(255 * f);

  switch(i) {
    case 0: r=255; g=t;   b=0;   break;
    case 1: r=q;   g=255; b=0;   break;
    case 2: r=0;   g=255; b=t;   break;
    case 3: r=0;   g=q;   b=255; break;
    case 4: r=t;   g=0;   b=255; break;
    case 5: r=255; g=0;   b=q;   break;
  }
}

// -----------------------------
// Start Animations
// -----------------------------
void energyCharge() {
  for (int i = 0; i < 255; i += 5) {
    setColor(i, 0, 0);  // red build
    delay(20);
  }
  for (int i = 0; i < 255; i += 5) {
    setColor(255, i/2, 0); // orange
    delay(15);
  }
  setColor(255, 255, 255); // white flash
  delay(200);
  setColor(0, 0, 0);       // turn off after animation
}

// -----------------------------
// Lightning Strike Flash for Stick Drop
// -----------------------------
void dropFlashLightning() {
  for(int i = 0; i < 3; i++) {
    setColor(random(200,255), random(200,255), random(200,255));
    delay(random(50,120));
    setColor(0, 0, 0);
    delay(30);
  }
}

// -----------------------------
// End Animation
// -----------------------------
void successPulse() {
  for(int i = 0; i < 3; i++) {
    setColor(0, 255, 0);
    delay(200);
    setColor(0, 0, 0);
    delay(200);
  }
}

void failFade() {
  for(int i = 255; i > 0; i -= 5) {
    setColor(i, 0, 0);
    delay(20);
  }
  setColor(0, 0, 0);
}

// -----------------------------
// Setup
// -----------------------------
void setup() {
  randomSeed(analogRead(A5)); // A5 must remain free

  for (int i = 0; i < numLeds; i++) pinMode(ledPins[i], OUTPUT);

  pinMode(startButtonPin, INPUT_PULLUP);
  pinMode(modeButtonPin, INPUT_PULLUP);

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

// -----------------------------
// Main Loop
// -----------------------------
void loop() {

  // Idle until start pressed
  while (digitalRead(startButtonPin) == HIGH) {
    idleRainbow();
  }
  delay(200);

  // Start animation
  energyCharge();

  // Track used sticks
  boolean ledUsed[numLeds];
  for (int i = 0; i < numLeds; i++) ledUsed[i] = false;

  // Drop sequence
  for (int i = 0; i < numLeds; i++) {

    // Random delay for suspense
    int randomDelay;
    if (digitalRead(modeButtonPin) == LOW) randomDelay = random(1000, 2000);
    else randomDelay = random(2000, 3500);

    delay(randomDelay); // suspense, RGB off for focus

    // Select a random unused stick
    int randomIndex;
    do { randomIndex = random(0, numLeds); }
    while (ledUsed[randomIndex]);

    // Lightning strike flash
    dropFlashLightning();

    // Activate electromagnet / LED
    digitalWrite(ledPins[randomIndex], HIGH);
    delay(200);  // hold stick
    digitalWrite(ledPins[randomIndex], LOW);

    ledUsed[randomIndex] = true;
  }

  // End animation
  successPulse();
  //failFade();  // use for fail condition

  delay(1000);
}