// Define pins for LEDs
const int led1Pin = 8;
const int led2Pin = 9;
const int led3Pin = 10;

// Define pins for RGB LEDs
const int rgb1RedPin = 2;
const int rgb1GreenPin = 3;
const int rgb1BluePin = 4;
const int rgb2RedPin = 5;
const int rgb2GreenPin = 6;
const int rgb2BluePin = 7;

// Define pins for shift registers
const int sr1DataPin = 11;
const int sr1ClockPin = 12;
const int sr1LatchPin = 13;
const int sr2DataPin = 14;
const int sr2ClockPin = 15;
const int sr2LatchPin = 16;

// 7-segment display patterns (common anode, LOW turns ON segments)
// Bit position: 7 6 5 4 3 2 1 0
// Segment:      DP G F E D C B A
const byte digitPatterns[] = {
  0b00000011,  // 0 (segments A-F ON, G OFF)
  0b10011111,  // 1 (segments B,C ON)
  0b00100101,  // 2 (segments A,B,D,E,G ON)
  0b00001101,  // 3 (segments A,B,C,D,G ON)
  0b10011001,  // 4 (segments B,C,F,G ON)
  0b01001001,  // 5 (segments A,C,D,F,G ON)
  0b01000001,  // 6 (segments A,C,D,E,F,G ON)
  0b00011111,  // 7 (segments A,B,C ON)
  0b00000001,  // 8 (all segments ON)
  0b00001001   // 9 (segments A,B,C,D,F,G ON)
};

// RGB LED colors
const byte RED[] = {255, 0, 0};
const byte GREEN[] = {0, 255, 0};
const byte BLUE[] = {0, 0, 255};
const byte WHITE[] = {255, 255, 255};
const byte OFF[] = {0, 0, 0};

// System variables
int countdown = 9;
unsigned long lastUpdateTime = 0;
const unsigned long updateInterval = 2000;  // 2 seconds
int currentLEDIndex = 0;
int currentRGBColorIndex = 0;

void setup() {
  // Initialize single-color LED pins
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);
  pinMode(led3Pin, OUTPUT);
  
  // Initialize RGB LED pins
  pinMode(rgb1RedPin, OUTPUT);
  pinMode(rgb1GreenPin, OUTPUT);
  pinMode(rgb1BluePin, OUTPUT);
  pinMode(rgb2RedPin, OUTPUT);
  pinMode(rgb2GreenPin, OUTPUT);
  pinMode(rgb2BluePin, OUTPUT);
  
  // Initialize shift register pins
  pinMode(sr1DataPin, OUTPUT);
  pinMode(sr1ClockPin, OUTPUT);
  pinMode(sr1LatchPin, OUTPUT);
  pinMode(sr2DataPin, OUTPUT);
  pinMode(sr2ClockPin, OUTPUT);
  pinMode(sr2LatchPin, OUTPUT);
  
  // Initialize all LEDs to OFF
  digitalWrite(led1Pin, LOW);
  digitalWrite(led2Pin, LOW);
  digitalWrite(led3Pin, LOW);
  
  setRGBColor(rgb1RedPin, rgb1GreenPin, rgb1BluePin, OFF);
  setRGBColor(rgb2RedPin, rgb2GreenPin, rgb2BluePin, OFF);
  
  // Initialize 7-segment displays to show "99"
  updateDisplay(9, 9);
  
  // Initialize timer
  lastUpdateTime = millis();
}

void loop() {
  // Check if it's time to update the countdown
  if (millis() - lastUpdateTime >= updateInterval) {
    lastUpdateTime = millis();
    
    // Update countdown
    if (countdown > 0) {
      countdown--;
    } else {
      // When countdown reaches 0 and completes display time, reset system
      countdown = 9;
      currentLEDIndex = 0;
      currentRGBColorIndex = 0;
    }
    
    // Update displays and LEDs
    updateDisplay(countdown, countdown);
    updateLEDs();
    updateRGBLEDs();
  }
}

void updateDisplay(int value1, int value2) {
  // Update first 7-segment display
  digitalWrite(sr1LatchPin, LOW);
  shiftOut(sr1DataPin, sr1ClockPin, MSBFIRST, digitPatterns[value1]);
  digitalWrite(sr1LatchPin, HIGH);
  
  // Update second 7-segment display
  digitalWrite(sr2LatchPin, LOW);
  shiftOut(sr2DataPin, sr2ClockPin, MSBFIRST, digitPatterns[value2]);
  digitalWrite(sr2LatchPin, HIGH);
}

void updateLEDs() {
  // Turn OFF all single-color LEDs
  digitalWrite(led1Pin, LOW);
  digitalWrite(led2Pin, LOW);
  digitalWrite(led3Pin, LOW);
  
  // If countdown is at 0, all single-color LEDs should remain OFF
  if (countdown == 0) {
    return;
  }
  
  // Turn ON the current LED based on sequence
  if (currentLEDIndex == 0) {
    digitalWrite(led1Pin, HIGH);
  } else if (currentLEDIndex == 1) {
    digitalWrite(led2Pin, HIGH);
  } else if (currentLEDIndex == 2) {
    digitalWrite(led3Pin, HIGH);
  }
  
  // Advance to next LED in sequence
  currentLEDIndex = (currentLEDIndex + 1) % 3;
}

void updateRGBLEDs() {
  if (countdown == 0) {
    // At countdown 0, both RGB LEDs should be WHITE
    setRGBColor(rgb1RedPin, rgb1GreenPin, rgb1BluePin, WHITE);
    setRGBColor(rgb2RedPin, rgb2GreenPin, rgb2BluePin, WHITE);
    return;
  }
  
  // Cycle through colors: red, green, blue
  const byte* currentColor;
  if (currentRGBColorIndex == 0) {
    currentColor = RED;
  } else if (currentRGBColorIndex == 1) {
    currentColor = GREEN;
  } else {
    currentColor = BLUE;
  }
  
  // Set both RGB LEDs to the current color
  setRGBColor(rgb1RedPin, rgb1GreenPin, rgb1BluePin, currentColor);
  setRGBColor(rgb2RedPin, rgb2GreenPin, rgb2BluePin, currentColor);
  
  // Advance to next color in sequence
  currentRGBColorIndex = (currentRGBColorIndex + 1) % 3;
}

void setRGBColor(int redPin, int greenPin, int bluePin, const byte* color) {
  analogWrite(redPin, color[0]);
  analogWrite(greenPin, color[1]);
  analogWrite(bluePin, color[2]);
}