//6SHWINT - MIDTERM PAROL PROJECT

//Group 1:
//Castro, Aubrey
//Dacquil, Kristine
//Masbang, Coleen

//NW - 301
//09-15-2024

#include <FastLED.h> 
// Pin definitions
const int rgbPinR = 46;
const int rgbPinG = 47;
const int rgbPinB = 48;

int orangePins[] = {2, 5, 13}; 
int purplePins[] = {3, 10, 30, 31, 32, 33, 34, 35, 36, 37};
int redPins[] = {4, 9, 22, 23, 24, 25, 26, 27, 28, 29};
int bluePins[] = {6, 11, 38, 39, 40, 41, 42, 43, 44, 45};
int greenPin = 7;
int pinkPins[] = {8, 12};

// Time interval based on 173 BPM (roughly 347 milliseconds per beat)
int beatInterval = 347;

// Helper function to turn on an array of pins together
void turnOnPins(int pins[], int size) {
  for (int i = 0; i < size; i++) {
    digitalWrite(pins[i], HIGH);
  }
}

// Helper function to turn off an array of pins together
void turnOffPins(int pins[], int size) {
  for (int i = 0; i < size; i++) {
    digitalWrite(pins[i], LOW);
  }
}

// RGB Color Cycle function with a break
void cycleRGB() {
  // Red
  digitalWrite(rgbPinR, HIGH);
  digitalWrite(rgbPinG, LOW);
  digitalWrite(rgbPinB, LOW);
  delay(beatInterval);
  
  // Green
  digitalWrite(rgbPinR, LOW);
  digitalWrite(rgbPinG, HIGH);
  digitalWrite(rgbPinB, LOW);
  delay(beatInterval);
  
  // Blue
  digitalWrite(rgbPinR, LOW);
  digitalWrite(rgbPinG, LOW);
  digitalWrite(rgbPinB, HIGH);
  delay(beatInterval);
  
  // Cyan
  digitalWrite(rgbPinR, LOW);
  digitalWrite(rgbPinG, HIGH);
  digitalWrite(rgbPinB, HIGH);
  delay(beatInterval);
  
  // Magenta
  digitalWrite(rgbPinR, HIGH);
  digitalWrite(rgbPinG, LOW);
  digitalWrite(rgbPinB, HIGH);
  delay(beatInterval);
  
  // Yellow
  digitalWrite(rgbPinR, HIGH);
  digitalWrite(rgbPinG, HIGH);
  digitalWrite(rgbPinB, LOW);
  delay(beatInterval);
  
  // Turn off for 0.9 seconds (900 ms)
  digitalWrite(rgbPinR, LOW);
  digitalWrite(rgbPinG, LOW);
  digitalWrite(rgbPinB, LOW);
  delay(900);
}

// Additional transition for Orange, Green, and Pink pins
void additionalTransition() {
  // Flash Orange pins together
  turnOnPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));
  delay(beatInterval);
  turnOffPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));

  // Flash Green pin with Pink pins
  digitalWrite(greenPin, HIGH);
  turnOnPins(pinkPins, sizeof(pinkPins) / sizeof(pinkPins[0]));
  delay(beatInterval);
  digitalWrite(greenPin, LOW);
  turnOffPins(pinkPins, sizeof(pinkPins) / sizeof(pinkPins[0]));

  // Alternating pattern with Orange and Pink
  for (int i = 0; i < 3; i++) {
    digitalWrite(orangePins[i % 3], HIGH);
    digitalWrite(pinkPins[i % 2], HIGH);
    delay(beatInterval / 2);
    digitalWrite(orangePins[i % 3], LOW);
    digitalWrite(pinkPins[i % 2], LOW);
  }
}

// Flower-like transition function (turn on groups in a circular-like pattern)
void flowerTransition() {
  // Start with orange
  turnOnPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));
  delay(beatInterval / 2);
  turnOffPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));

  // Next, light up blue group with extras
  turnOnPins(bluePins, sizeof(bluePins) / sizeof(bluePins[0]));
  digitalWrite(6, HIGH);
  digitalWrite(11, HIGH);
  delay(beatInterval / 2);
  turnOffPins(bluePins, sizeof(bluePins) / sizeof(bluePins[0]));
  digitalWrite(6, LOW);
  digitalWrite(11, LOW);

  // Follow with purple group
  turnOnPins(purplePins, sizeof(purplePins) / sizeof(purplePins[0]));
  digitalWrite(3, HIGH);
  digitalWrite(10, HIGH);
  delay(beatInterval / 2);
  turnOffPins(purplePins, sizeof(purplePins) / sizeof(purplePins[0]));
  digitalWrite(3, LOW);
  digitalWrite(10, LOW);

  // Finish with red group
  turnOnPins(redPins, sizeof(redPins) / sizeof(redPins[0]));
  digitalWrite(4, HIGH);
  digitalWrite(9, HIGH);
  delay(beatInterval / 2);
  turnOffPins(redPins, sizeof(redPins) / sizeof(redPins[0]));
  digitalWrite(4, LOW);
  digitalWrite(9, LOW);
}

// Series effects for grouped pins (only called once per loop)
void purpleSeriesEffect() {
  digitalWrite(3, HIGH);  // Keep pin 3 on
  digitalWrite(10, HIGH); // Keep pin 10 on
  
  for (int i = 0; i < sizeof(purplePins) / sizeof(purplePins[0]); i++) {
    digitalWrite(purplePins[i], HIGH);
    delay(100);  // Adjust delay as needed for the series effect speed
    digitalWrite(purplePins[i], LOW);
  }
  
  digitalWrite(3, LOW);
  digitalWrite(10, LOW);
}

void redSeriesEffect() {
  digitalWrite(4, HIGH);  // Keep pin 4 on
  digitalWrite(9, HIGH);  // Keep pin 9 on
  
  for (int i = 0; i < sizeof(redPins) / sizeof(redPins[0]); i++) {
    digitalWrite(redPins[i], HIGH);
    delay(100);  // Adjust delay as needed for the series effect speed
    digitalWrite(redPins[i], LOW);
  }

  digitalWrite(4, LOW);
  digitalWrite(9, LOW);
}

void blueSeriesEffect() {
  digitalWrite(6, HIGH);  // Keep pin 6 on
  digitalWrite(11, HIGH); // Keep pin 11 on
  
  for (int i = 0; i < sizeof(bluePins) / sizeof(bluePins[0]); i++) {
    digitalWrite(bluePins[i], HIGH);
    delay(100);  // Adjust delay as needed for the series effect speed
    digitalWrite(bluePins[i], LOW);
  }

  digitalWrite(6, LOW);
  digitalWrite(11, LOW);
}

// Setup function to initialize all pins
void setup() {
  // Set all pins as outputs
  for (int i = 0; i < sizeof(orangePins) / sizeof(orangePins[0]); i++) {
    pinMode(orangePins[i], OUTPUT);
  }
  for (int i = 0; i < sizeof(purplePins) / sizeof(purplePins[0]); i++) {
    pinMode(purplePins[i], OUTPUT);
  }
  for (int i = 0; i < sizeof(redPins) / sizeof(redPins[0]); i++) {
    pinMode(redPins[i], OUTPUT);
  }
  for (int i = 0; i < sizeof(bluePins) / sizeof(bluePins[0]); i++) {
    pinMode(bluePins[i], OUTPUT);
  }
  pinMode(greenPin, OUTPUT);
  for (int i = 0; i < sizeof(pinkPins) / sizeof(pinkPins[0]); i++) {
    pinMode(pinkPins[i], OUTPUT);
  }

  pinMode(rgbPinR, OUTPUT);
  pinMode(rgbPinG, OUTPUT);
  pinMode(rgbPinB, OUTPUT);
}

// Loop function to execute transitions continuously
void loop() {
  // RGB color cycle effect with a break
  cycleRGB();

  // Execute series effects for each group (only once per loop)
  purpleSeriesEffect();
  redSeriesEffect();
  blueSeriesEffect();

  // Execute additional transitions for variety
  additionalTransition();

  // Flower-like transition to create a circular lighting pattern
  flowerTransition();

  // Turn on all Blue pins together with pins 6 and 11
  turnOnPins(bluePins, sizeof(bluePins) / sizeof(bluePins[0]));
  digitalWrite(6, HIGH);
  digitalWrite(11, HIGH);
  delay(beatInterval);
  turnOffPins(bluePins, sizeof(bluePins) / sizeof(bluePins[0]));
  digitalWrite(6, LOW);
  digitalWrite(11, LOW);

  // Turn on all Purple pins together with pins 3 and 10
  turnOnPins(purplePins, sizeof(purplePins) / sizeof(purplePins[0]));
  digitalWrite(3, HIGH);
  digitalWrite(10, HIGH);
  delay(beatInterval);
  turnOffPins(purplePins, sizeof(purplePins) / sizeof(purplePins[0]));
  digitalWrite(3, LOW);
  digitalWrite(10, LOW);

  // Turn on all Red pins together with pins 4 and 9
  turnOnPins(redPins, sizeof(redPins) / sizeof(redPins[0]));
  digitalWrite(4, HIGH);
  digitalWrite(9, HIGH);
  delay(beatInterval);
  turnOffPins(redPins, sizeof(redPins) / sizeof(redPins[0]));
  digitalWrite(4, LOW);
  digitalWrite(9, LOW);

  // Turn on all Orange pins together
  turnOnPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));
  delay(beatInterval / 2); // Shorter delay for faster effect
  turnOffPins(orangePins, sizeof(orangePins) / sizeof(orangePins[0]));

  // Turn on Green pin and both Pink pins together
  digitalWrite(greenPin, HIGH);
  turnOnPins(pinkPins, sizeof(pinkPins) / sizeof(pinkPins[0]));
  delay(beatInterval / 2);
  digitalWrite(greenPin, LOW);
  turnOffPins(pinkPins, sizeof(pinkPins) / sizeof(pinkPins[0]));

  // Random combination effect: Select random combinations of Orange and Pink pins with groups
  int randomIndex;
  randomIndex = random(0, 3);
  digitalWrite(orangePins[randomIndex], HIGH);
  
  randomIndex = random(0, 2);
  digitalWrite(pinkPins[randomIndex], HIGH);

  // Delay to match the beat
  delay(beatInterval);
  
  // Turn off the randomly selected pins
  digitalWrite(orangePins[randomIndex], LOW);
  digitalWrite(pinkPins[randomIndex], LOW);
}