#include <EEPROM.h>

// Pin definitions for RGB lamps (PWM capable pins)
const int middleRGB[] = {9, 10, 11};  // Red, Green, Blue for the middle lamp
const int playerRGB[4][3] = {
  {2, 3, 4},    // Player 1 RGB
  {5, 6, 7},    // Player 2 RGB
  {8, A0, A1},  // Player 3 RGB
  {A2, A3, A4}   // Player 4 RGB
};
// Button pins for each player
const int buttons[4][3] = { 
  {22, 23, 24}, // Player 1: Red, Green, Blue buttons
  {25, 26, 27}, // Player 2: Red, Green, Blue buttons
  {28, 29, 30}, // Player 3: Red, Green, Blue buttons
  {31, 32, 33}  // Player 4: Red, Green, Blue buttons
};
const int numberOfPlayers = 4; // Define the number of players
bool activePlayers[numberOfPlayers]; // Array to track active players

// Game settings
const int level0PatternLength = 4; // Fixed pattern length for Level 0
const int level1PatternLength = 4; // Fixed pattern length for Level 1
const int level2PatternLength = 6; // Fixed pattern length for Level 2
const int level3PatternLength = 6; // Fixed pattern length for Level 3
const int level4PatternLength = 6; // Fixed pattern length for Level 4

int level0Pattern[level0PatternLength]; // Array to hold random pattern for Level 0
int level1Pattern[level1PatternLength]; // Array to hold random pattern for Level 1
int level2Pattern[level2PatternLength]; // Array to hold random pattern for Level 2
int level3Pattern[level3PatternLength]; // Array to hold random pattern for Level 3
int level4Pattern[level4PatternLength]; // Array to hold random pattern for Level 4

bool gameWon = false; // Tracks if a player has won
int playerPressCount[4] = {0, 0, 0, 0}; // Track number of presses for each player
int playerInput[4][level4PatternLength]; // Store inputs for each player
bool playerFinished[4] = {false, false, false, false}; // Track if each player has finished

// Delays for showing patterns for hardness control
const int level0Delay = 700; // Delay for Level 0 pattern display
const int level1Delay = 600; // Delay for Level 1 pattern display
const int level2Delay = 600; // Delay for Level 2 pattern display
const int level3Delay = 500; // Delay for Level 3 pattern display
const int level4Delay = 400; // Delay for Level 4 pattern display


void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(0)); // Seed the random number generator

  // Set up RGB lamps and buttons as outputs and inputs
  for (int i = 0; i < 3; i++) {
    pinMode(middleRGB[i], OUTPUT);
    for (int j = 0; j < 4; j++) {
      pinMode(playerRGB[j][i], OUTPUT);
      pinMode(buttons[j][i], INPUT_PULLUP); // Buttons for each player
    }
  }
  Serial.println("Start of Level 0 (Tutorial)"); // Indicate start of Level 0
  runLevel0();
}

void loop() {
  // Code that runs repeatedly goes here
}

// Generates a random pattern of colors for Level 0 (Red and Green)
void generateRandomPatternLevel0() {
  for (int i = 0; i < level0PatternLength; i++) {
    level0Pattern[i] = random(0, 2); // Randomly select 0 (Red) or 1 (Green)
  }
}

// Displays the pattern using the middle RGB lamp for Level 0
void showPatternLevel0() {
  Serial.println("Level 0 Pattern:"); // Print header to Serial Monitor
  for (int i = 0; i < level0PatternLength; i++) {
    if (level0Pattern[i] == 0) {
      Serial.println("Red"); // Print "Red" if 0
    } else {
      Serial.println("Green"); // Print "Green" if 1
    }
    
    setMiddleRGB(level0Pattern[i]); // Display the color for Level 0
    delay(level0Delay); // Display color for Level 0 pattern delay
    setMiddleRGB(-1);  // Turn off
    delay(200); // Delay before showing the next color
  }
  Serial.println("Pattern display completed."); // Indicate end of pattern
}
// Generates a random pattern of colors for Level 1 (RGB)
void generateRandomPatternLevel1() {
  for (int i = 0; i < level1PatternLength; i++) {
    level1Pattern[i] = random(0, 3); // Randomly select 0 (Red), 1 (Green), or 2 (Blue)
  }
}

// Displays the pattern using the middle RGB lamp for Level 1
void showPatternLevel1() {
  Serial.println("Level 1 Pattern:"); // Print header to Serial Monitor
  for (int i = 0; i < level1PatternLength; i++) {
    if (level1Pattern[i] == 0) {
      Serial.println("Red"); // Print "Red" if 0
    } else if (level1Pattern[i] == 1) {
      Serial.println("Green"); // Print "Green" if 1
    } else {
      Serial.println("Blue"); // Print "Blue" if 2
    }
    
    setMiddleRGB(level1Pattern[i]); // Display the color for Level 1
    delay(level1Delay); // Display color for Level 1 pattern delay
    setMiddleRGB(-1);  // Turn off
    delay(200); // Delay before showing the next color
  }
  Serial.println("Pattern display completed."); // Indicate end of pattern
}


// Generates a random pattern of colors for Level 2 (RGB)
void generateRandomPatternLevel2() {
  for (int i = 0; i < level2PatternLength; i++) {
    level2Pattern[i] = random(0, 3); // Randomly select 0 (Red), 1 (Green), or 2 (Blue)
  }
}

// Displays the pattern using the middle RGB lamp for Level 2
void showPatternLevel2() {
  Serial.println("Level 2 Pattern:"); // Print header to Serial Monitor
  for (int i = 0; i < level2PatternLength; i++) {
    if (level2Pattern[i] == 0) {
      Serial.println("Red"); // Print "Red" if 0
    } else if (level2Pattern[i] == 1) {
      Serial.println("Green"); // Print "Green" if 1
    } else {
      Serial.println("Blue"); // Print "Blue" if 2
    }
    
    setMiddleRGB(level2Pattern[i]); // Display the color for Level 2
    delay(level2Delay); // Display color for Level 2 pattern delay
    setMiddleRGB(-1);  // Turn off
    delay(200); // Delay before showing the next color
  }
  Serial.println("Pattern display completed."); // Indicate end of pattern
}


// Generates a random pattern of colors for Level 3 (RGB)
void generateRandomPatternLevel3() {
  for (int i = 0; i < level3PatternLength; i++) {
    level3Pattern[i] = random(0, 3); // Randomly select 0 (Red), 1 (Green), or 2 (Blue)
  }
}

// Displays the pattern using the middle RGB lamp for Level 3
void showPatternLevel3() {
  Serial.println("Level 3 Pattern:"); // Print header to Serial Monitor
  for (int i = 0; i < level3PatternLength; i++) {
    if (level3Pattern[i] == 0) {
      Serial.println("Red"); // Print "Red" if 0
    } else if (level3Pattern[i] == 1) {
      Serial.println("Green"); // Print "Green" if 1
    } else {
      Serial.println("Blue"); // Print "Blue" if 2
    }
    
    setMiddleRGB(level3Pattern[i]); // Display the color for Level 3
    delay(level3Delay); // Display color for Level 3 pattern delay
    setMiddleRGB(-1);  // Turn off
    delay(200); // Delay before showing the next color
  }
  Serial.println("Pattern display completed."); // Indicate end of pattern
}


// Generates a random pattern of colors for Level 4 (RGB)
void generateRandomPatternLevel4() {
  for (int i = 0; i < level4PatternLength; i++) {
    level4Pattern[i] = random(0, 3); // Randomly select 0 (Red), 1 (Green), or 2 (Blue)
  }
}

// Displays the pattern using the middle RGB lamp for Level 4
void showPatternLevel4() {
  Serial.println("Level 4 Pattern:"); // Print header to Serial Monitor
  for (int i = 0; i < level4PatternLength; i++) {
    if (level4Pattern[i] == 0) {
      Serial.println("Red"); // Print "Red" if 0
    } else if (level4Pattern[i] == 1) {
      Serial.println("Green"); // Print "Green" if 1
    } else {
      Serial.println("Blue"); // Print "Blue" if 2
    }
    
    setMiddleRGB(level4Pattern[i]); // Display the color for Level 4
    delay(level4Delay); // Display color for Level 4 pattern delay
    setMiddleRGB(-1);  // Turn off
    delay(200); // Delay before showing the next color
  }
  Serial.println("Pattern display completed."); // Indicate end of pattern
}

// Define a variable to track the timing of your pattern display
unsigned long previousMillis = 0; // Store the last time pattern was updated
const long interval = 100; // Interval for checking player presses

// Run Level 0 (Tutorial)
void runLevel0() {
    // Ensure all players are active before starting Level 0
    for (int player = 0; player < 4; player++) {
        activePlayers[player] = true; // Mark all players as active at the start of the tutorial
    }

    resetAllLamps(); // Reset lamps for Level 0
    generateRandomPatternLevel0(); // Generate random pattern for Level 0
    showwhite(); // Show white on all lamps
    showPatternLevel0(); // Display the pattern for Level 0
    delay(1000); // Give some time to view the pattern
    resetAllLamps(); // Reset lamps again

    resetPlayerPresses(); // Reset player press counts for Level 0
    gameWon = false; // Reset game state for Level 0

    unsigned long startTime = millis(); // Start timing for Level 0
    while (!gameWon) {
        unsigned long currentMillis = millis(); // Get the current time

        // Check player button presses frequently
        checkPlayerButtonslvl0(); // Check button presses for all players

        // Check if a player has finished their presses and update lamp colors
        for (int player = 0; player < 4; player++) {
            if (playerPressCount[player] == level0PatternLength) {
                showwhite(player);  // Turn this player's lamp white if they finish their presses
            } else {
                setPlayerRGB(player, -1); // Turn off the lamp for other players
            }
        }

        // Check if all active players have finished
        if (areAllPlayersFinished()) {
            determineWinnerslvl0(); // Determine winners for Level 0
            gameWon = true; // Set the flag to indicate Level 0 is finished
        }

        // Non-blocking delay to allow other tasks to run
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; // Save the last time we checked
        }
    }

    // Show results for 3 seconds after all players have finished
    delay(3000); // Show results for 3 seconds
    // Transition to Level 1
    showPurple(5000); // Show purple for 5 seconds
    resetAllLamps(); // Reset lamps before Level 1
    Serial.println("Level 1 started ..."); // Indicate transition to Level 1
    runLevel1(); // Start Level 1
}

// Run Level 1
void runLevel1() {
    resetAllLamps(); // Reset lamps for Level 1
    generateRandomPatternLevel1(); // Generate random pattern for Level 1
    showwhite(); // Show white on all lamps
    showPatternLevel1(); // Display the pattern for Level 1
    delay(1000); // Give some time to view the pattern
    resetAllLamps(); // Reset lamps again

    resetPlayerPresses(); // Reset player press counts for Level 1
    gameWon = false; // Reset game state for Level 1

    unsigned long startTime = millis(); // Start timing for Level 1
    while (!gameWon) {
        unsigned long currentMillis = millis(); // Get the current time

        // Check player button presses frequently
        checkPlayerButtonslvl1(); // Check button presses for all players

        // Update lamp colors for active players
        for (int player = 0; player < 4; player++) { // Loop through all 4 players
            if (activePlayers[player]) { // Only consider active players
                if (playerPressCount[player] == level1PatternLength) { // Check against required presses for Level 1
                    showwhite(player);  // Turn this player's lamp white if they finish their presses
                } else {
                    setPlayerRGB(player, -1); // Turn off the lamp for other players
                }
            }
        }

        // Set lamps red for inactive players (losers from the previous level)
        for (int player = 0; player < 4; player++) {
            if (!activePlayers[player]) { // Only consider inactive players
                setPlayerRGB(player, 255, 0, 0); // Red for losers
                playerPressCount[player] = 0; // Ensure their presses are not counted
            }
        }

        // Check if all players have pressed their buttons (or reached their press limit)
        if (areAllPlayersFinished()) {
            determineWinnerslvl1(); // Determine winners for Level 1
            gameWon = true; // Set the flag to indicate Level 1 is finished
        }

        // Non-blocking delay to allow other tasks to run
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; // Save the last time we checked
            // You can do any other necessary checks or updates here if needed
        }
    }

    // Show results for 3 seconds after all players have finished
    delay(3000); // Show results for 3 seconds
    // Transition to Level 2
    showPurple(5000); // Show purple for 5 seconds
    resetAllLamps(); // Reset lamps before Level 2
    Serial.println("Level 2 started ..."); // Indicate transition to Level 2
    runLevel2(); // Start Level 2
}

// Run Level 2
void runLevel2() {
    resetAllLamps(); // Reset lamps for Level 2
    generateRandomPatternLevel2(); // Generate random pattern for Level 2
    showwhite(); // Show white on all lamps
    showPatternLevel2(); // Display the pattern for Level 2
    delay(1000); // Give some time to view the pattern
    resetAllLamps(); // Reset lamps again

    resetPlayerPresses(); // Reset player press counts for Level 2
    gameWon = false; // Reset game state for Level 2

    unsigned long startTime = millis(); // Start timing for Level 2
    while (!gameWon) {
        unsigned long currentMillis = millis(); // Get the current time

        // Check player button presses frequently
        checkPlayerButtonslvl2(); // Check button presses for all players

        // Update lamp colors for active players
        for (int player = 0; player < 4; player++) { // Loop through all 4 players
            if (activePlayers[player]) { // Only consider active players
                if (playerPressCount[player] == level2PatternLength) { // Check against required presses for Level 2
                    showwhite(player);  // Turn this player's lamp white if they finish their presses
                } else {
                    setPlayerRGB(player, -1); // Turn off the lamp for other players
                }
            }
        }

        // Set lamps red for inactive players (losers from the previous level)
        for (int player = 0; player < 4; player++) {
            if (!activePlayers[player]) { // Only consider inactive players
                setPlayerRGB(player, 255, 0, 0); // Red for losers
                playerPressCount[player] = 0; // Ensure their presses are not counted
            }
        }

        // Check if all players have pressed their buttons (or reached their press limit)
        if (areAllPlayersFinished()) {
        determineWinnerslvl2(); // Determine winners for Level 2
        if (allPlayersLost()) {
            Serial.println("Game Ended: All players have lost.");
            while (true); // Stop execution
        }
        gameWon = true; // Set the flag to indicate Level 2 is finished
    }


        // Non-blocking delay to allow other tasks to run
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; // Save the last time we checked
            // You can do any other necessary checks or updates here if needed
        }
    }

    // Show results for 3 seconds after all players have finished
    delay(3000); // Show results for 3 seconds
    // Transition to Level 3 (if applicable)
    showPurple(5000); // Show purple for 5 seconds
    resetAllLamps(); // Reset lamps before Level 3
    Serial.println("Level 3 started ..."); // Indicate transition to Level 3
    runLevel3(); // Start Level 3
}

// Run Level 3
void runLevel3() {
    resetAllLamps(); // Reset lamps for Level 3
    generateRandomPatternLevel3(); // Generate random pattern for Level 3
    showwhite(); // Show white on all lamps
    showPatternLevel3(); // Display the pattern for Level 3
    delay(1000); // Give some time to view the pattern
    resetAllLamps(); // Reset lamps again

    resetPlayerPresses(); // Reset player press counts for Level 3
    gameWon = false; // Reset game state for Level 3

    unsigned long startTime = millis(); // Start timing for Level 3
    while (!gameWon) {
        unsigned long currentMillis = millis(); // Get the current time

        // Check player button presses frequently
        checkPlayerButtonslvl3(); // Check button presses for all players

        // Update lamp colors for active players
        for (int player = 0; player < 4; player++) { // Loop through all 4 players
            if (activePlayers[player]) { // Only consider active players
                if (playerPressCount[player] == level3PatternLength) { // Check against required presses for Level 3
                    showwhite(player);  // Turn this player's lamp white if they finish their presses
                } else {
                    setPlayerRGB(player, -1); // Turn off the lamp for other players
                }
            }
        }

        // Set lamps red for inactive players (losers from the previous level)
        for (int player = 0; player < 4; player++) {
            if (!activePlayers[player]) { // Only consider inactive players
                setPlayerRGB(player, 255, 0, 0); // Red for losers
                playerPressCount[player] = 0; // Ensure their presses are not counted
            }
        }

        // Check if all players have pressed their buttons (or reached their press limit)
        if (areAllPlayersFinished()) {
        determineWinnerslvl3(); // Determine winners for Level 3
        if (allPlayersLost()) {
            Serial.println("Game Ended: All players have lost.");
            while (true); // Stop execution
        }
        gameWon = true; // Set the flag to indicate Level 3 is finished
    }

        // Non-blocking delay to allow other tasks to run
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; // Save the last time we checked
            // You can do any other necessary checks or updates here if needed
        }
    }

    // Show results for 3 seconds after all players have finished
    delay(3000); // Show results for 3 seconds
    // Transition to the next level (if applicable)
    showPurple(5000); // Show purple for 5 seconds
    resetAllLamps(); // Reset lamps before the next level
    Serial.println(" Level 4 started ..."); // Indicate transition to the next level
    runLevel4(); // Start the next level
}

  // Run Level 4
void runLevel4() {
    resetAllLamps(); // Reset lamps for Level 4
    generateRandomPatternLevel4(); // Generate random pattern for Level 4
    showwhite(); // Show white on all lamps
    showPatternLevel4(); // Display the pattern for Level 4
    delay(1000); // Give some time to view the pattern
    resetAllLamps(); // Reset lamps again

    resetPlayerPresses(); // Reset player press counts for Level 4
    gameWon = false; // Reset game state for Level 4

    unsigned long startTime = millis(); // Start timing for Level 4
    while (!gameWon) {
        unsigned long currentMillis = millis(); // Get the current time

        // Check player button presses frequently
        checkPlayerButtonslvl4(); // Check button presses for all players

        // Update lamp colors for active players
        for (int player = 0; player < 4; player++) { // Loop through all 4 players
            if (activePlayers[player]) { // Only consider active players
                if (playerPressCount[player] == level4PatternLength) { // Check against required presses for Level 4
                    showwhite(player);  // Turn this player's lamp white if they finish their presses
                } else {
                    setPlayerRGB(player, -1); // Turn off the lamp for other players
                }
            }
        }

        // Set lamps red for inactive players (losers from the previous level)
        for (int player = 0; player < 4; player++) {
            if (!activePlayers[player]) { // Only consider inactive players
                setPlayerRGB(player, 255, 0, 0); // Red for losers
                playerPressCount[player] = 0; // Ensure their presses are not counted
            }
        }

        // Check if all players have pressed their buttons (or reached their press limit)
        if (areAllPlayersFinished()) {
            determineWinnerslvl4(); // Determine winners for Level 4
            gameWon = true; // Set the flag to indicate Level 4 is finished
        }

        // Non-blocking delay to allow other tasks to run
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; // Save the last time we checked
            // You can do any other necessary checks or updates here if needed
        }
    }

    // Show results for 3 seconds after all players have finished
    delay(3000); // Show results for 3 seconds
    // Transition to the next level (if applicable)
    showPurple(5000); // Show purple for 5 seconds
    resetAllLamps(); // Reset lamps before the next level
    Serial.println("GAME ENDED ..."); // Indicate transition to the next level
}

// Resets the players' presses
void resetPlayerPresses() {
  for (int i = 0; i < 4; i++) {
    playerPressCount[i] = 0; // Reset the count for each player
    playerFinished[i] = false; // Reset the finished status
  }
}

// Checks if active players pressed buttons during Level 0
void checkPlayerButtonslvl0() {
  for (int player = 0; player < 4; player++) {
    // Only check for active players and players who haven't finished
    if (activePlayers[player] && !playerFinished[player]) {
      for (int i = 0; i < 3; i++) {
        if (digitalRead(buttons[player][i]) == LOW) { // Button is pressed
          // Light up player's lamp with pressed color
          int red = (i == 0) ? 255 : 0; // Red if button 1 pressed
          int green = (i == 1) ? 255 : 0; // Green if button 2 pressed
          int blue = (i == 2) ? 255 : 0; // Blue if button 3 pressed

          Serial.print("Player ");
          Serial.print(player + 1);
          Serial.print(" pressed ");
          Serial.print((i == 0) ? "Red" : (i == 1) ? "Green" : "Blue");
          Serial.println();

          setPlayerRGB(player, red, green, blue); // Use direct color values for player lamps
          delay(180); // Keep the lamp lit for 180 milliseconds
          setPlayerRGB(player, 0, 0, 0); // Turn off player's lamp after delay

          // Store the pressed button
          if (playerPressCount[player] < level0PatternLength) {
            playerInput[player][playerPressCount[player]] = i; // Store the pressed button index
            playerPressCount[player]++; // Increment the press count
            delay(180); // Small delay between presses
          }
        }
      }

      // Check if the player has completed the required presses
      if (playerPressCount[player] >= level0PatternLength) {
        playerFinished[player] = true; // Mark player as finished
      }
    }
  }
}

// Checks if active players pressed buttons during Level 1
void checkPlayerButtonslvl1() {
  for (int player = 0; player < 4; player++) {
    // Only check for active players and players who haven't finished
    if (activePlayers[player] && !playerFinished[player]) {
      for (int i = 0; i < 3; i++) {
        if (digitalRead(buttons[player][i]) == LOW) { // Button is pressed
          // Light up player's lamp with pressed color
          int red = (i == 0) ? 255 : 0; // Red if button 1 pressed
          int green = (i == 1) ? 255 : 0; // Green if button 2 pressed
          int blue = (i == 2) ? 255 : 0; // Blue if button 3 pressed

          Serial.print("Player ");
          Serial.print(player + 1);
          Serial.print(" pressed ");
          Serial.print((i == 0) ? "Red" : (i == 1) ? "Green" : "Blue");
          Serial.println();

          setPlayerRGB(player, red, green, blue); // Use direct color values for player lamps
          delay(180); // Keep the lamp lit for 180 milliseconds
          setPlayerRGB(player, 0, 0, 0); // Turn off player's lamp after delay

          // Store the pressed button
          if (playerPressCount[player] < level1PatternLength) {
            playerInput[player][playerPressCount[player]] = i; // Store the pressed button index
            playerPressCount[player]++; // Increment the press count
            delay(180); // Small delay between presses
          }
        }
      }

      // Check if the player has completed the required presses
      if (playerPressCount[player] >= level1PatternLength) {
        playerFinished[player] = true; // Mark player as finished
      }
    }
  }
}

// Checks if active players pressed buttons during Level 2
void checkPlayerButtonslvl2() {
  for (int player = 0; player < 4; player++) {
    // Only check for active players and players who haven't finished
    if (activePlayers[player] && !playerFinished[player]) {
      for (int i = 0; i < 3; i++) {
        if (digitalRead(buttons[player][i]) == LOW) { // Button is pressed
          // Light up player's lamp with pressed color
          int red = (i == 0) ? 255 : 0; // Red if button 1 pressed
          int green = (i == 1) ? 255 : 0; // Green if button 2 pressed
          int blue = (i == 2) ? 255 : 0; // Blue if button 3 pressed

          Serial.print("Player ");
          Serial.print(player + 1);
          Serial.print(" pressed ");
          Serial.print((i == 0) ? "Red" : (i == 1) ? "Green" : "Blue");
          Serial.println();

          setPlayerRGB(player, red, green, blue); // Use direct color values for player lamps
          delay(100); // Keep the lamp lit for 180 milliseconds
          setPlayerRGB(player, 0, 0, 0); // Turn off player's lamp after delay

          // Store the pressed button
          if (playerPressCount[player] < level2PatternLength) {
            playerInput[player][playerPressCount[player]] = i; // Store the pressed button index
            playerPressCount[player]++; // Increment the press count
            delay(50); // Small delay between presses
          }
        }
      }

      // Check if the player has completed the required presses
      if (playerPressCount[player] >= level2PatternLength) {
        playerFinished[player] = true; // Mark player as finished
      }
    }
  }
}

// Checks if active players pressed buttons during Level 3
void checkPlayerButtonslvl3() {
  for (int player = 0; player < 4; player++) {
    // Only check for active players and players who haven't finished
    if (activePlayers[player] && !playerFinished[player]) {
      for (int i = 0; i < 3; i++) {
        if (digitalRead(buttons[player][i]) == LOW) { // Button is pressed
          // Light up player's lamp with pressed color
          int red = (i == 0) ? 255 : 0; // Red if button 1 pressed
          int green = (i == 1) ? 255 : 0; // Green if button 2 pressed
          int blue = (i == 2) ? 255 : 0; // Blue if button 3 pressed

          Serial.print("Player ");
          Serial.print(player + 1);
          Serial.print(" pressed ");
          Serial.print((i == 0) ? "Red" : (i == 1) ? "Green" : "Blue");
          Serial.println();

          setPlayerRGB(player, red, green, blue); // Use direct color values for player lamps
          delay(100); // Keep the lamp lit for 180 milliseconds
          setPlayerRGB(player, 0, 0, 0); // Turn off player's lamp after delay

          // Store the pressed button
          if (playerPressCount[player] < level3PatternLength) {
            playerInput[player][playerPressCount[player]] = i; // Store the pressed button index
            playerPressCount[player]++; // Increment the press count
            delay(50); // Small delay between presses
          }
        }
      }

      // Check if the player has completed the required presses
      if (playerPressCount[player] >= level3PatternLength) {
        playerFinished[player] = true; // Mark player as finished
      }
    }
  }
}

// Checks if active players pressed buttons during Level 4
void checkPlayerButtonslvl4() {
  for (int player = 0; player < 4; player++) {
    // Only check for active players and players who haven't finished
    if (activePlayers[player] && !playerFinished[player]) {
      for (int i = 0; i < 3; i++) {
        if (digitalRead(buttons[player][i]) == LOW) { // Button is pressed
          // Light up player's lamp with pressed color
          int red = (i == 0) ? 255 : 0; // Red if button 1 pressed
          int green = (i == 1) ? 255 : 0; // Green if button 2 pressed
          int blue = (i == 2) ? 255 : 0; // Blue if button 3 pressed

          Serial.print("Player ");
          Serial.print(player + 1);
          Serial.print(" pressed ");
          Serial.print((i == 0) ? "Red" : (i == 1) ? "Green" : "Blue");
          Serial.println();

          setPlayerRGB(player, red, green, blue); // Use direct color values for player lamps
          delay(100); // Keep the lamp lit for 180 milliseconds
          setPlayerRGB(player, 0, 0, 0); // Turn off player's lamp after delay

          // Store the pressed button
          if (playerPressCount[player] < level4PatternLength) {
            playerInput[player][playerPressCount[player]] = i; // Store the pressed button index
            playerPressCount[player]++; // Increment the press count
            delay(50); // Small delay between presses
          }
        }
      }

      // Check if the player has completed the required presses
      if (playerPressCount[player] >= level4PatternLength) {
        playerFinished[player] = true; // Mark player as finished
      }
    }
  }
}

// Determine winners for lvl 0 based on player inputs
void determineWinnerslvl0() {
  for (int player = 0; player < 4; player++) {
    bool correct = true; // Assume the player's input is correct
    for (int i = 0; i < level0PatternLength; i++) {
      if (playerInput[player][i] != level0Pattern[i]) {
        correct = false; // Found an incorrect input
        break;
      }
    }
    // Show result for each player
    if (correct) {
      setPlayerRGB(player, 0, 255, 0); // Green for winner
      Serial.print("Player ");
      Serial.print(player + 1);
      Serial.println(" wins!");
      activePlayers[player] = true; // Mark this player as active (winner or not)
    } else {
      setPlayerRGB(player, 255, 0, 0); // Red for loser
      Serial.print("Player ");
      Serial.print(player + 1);
      Serial.println(" loses!");
      activePlayers[player] = true; // Mark this player as active (winner or not)
    }
  }
  // Add this line to indicate that Level 0 has ended
  Serial.println("LEVEL 0 ENDED"); // Indicate end of Level 0
}

// Determine winners for lvl 1 based on player inputs
void determineWinnerslvl1() {
    resetAllLamps(); // Reset all lamps at the start of the function
    int activeCount = 0; // To count active players
    for (int player = 0; player < 4; player++) {
        bool correct = true; // Assume the player's input is correct
        for (int i = 0; i < level1PatternLength; i++) {
            if (playerInput[player][i] != level1Pattern[i]) {
                correct = false; // Found an incorrect input
                break; // Exit the loop early if there's an error
            }
        }
        // Show result for each player
        if (correct) {
            setPlayerRGB(player, 0, 255, 0); // Green for winner
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" wins!");
            activePlayers[player] = true; // Mark this player as active (winner)
            activeCount++; // Increment active count for winners
        } else {
            setPlayerRGB(player, 255, 0, 0); // Red for loser
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" loses!");
            activePlayers[player] = false; // Mark this player as inactive (loser)
        }
    }
    // Indicate that Level 1 has ended
    Serial.println("LEVEL 1 ENDED"); // Indicate end of Level 1
    
    if (activeCount == 0) {
        Serial.println("Game Ended: All players have lost.");
        while (true); // Stop further execution
    }
}

// Determine winners for lvl 2 based on player inputs
void determineWinnerslvl2() {
    resetAllLamps(); // Reset all lamps at the start of the function
    int activeCount = 0; // To count active players
    for (int player = 0; player < 4; player++) {
        bool correct = true; // Assume the player's input is correct
        for (int i = 0; i < level2PatternLength; i++) {
            if (playerInput[player][i] != level2Pattern[i]) {
                correct = false; // Found an incorrect input
                break; // Exit the loop early if there's an error
            }
        }
        // Show result for each player
        if (correct) {
            setPlayerRGB(player, 0, 255, 0); // Green for winner
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" wins!");
            activePlayers[player] = true; // Mark this player as active (winner)
            activeCount++; // Increment active count for winners
        } else {
            setPlayerRGB(player, 255, 0, 0); // Red for loser
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" loses!");
            activePlayers[player] = false; // Mark this player as inactive (loser)
        }
    }
    // Indicate that Level 2 has ended
    Serial.println("LEVEL 2 ENDED"); // Indicate end of Level 2
    
    if (activeCount == 0) {
        Serial.println("Game Ended: All players have lost.");
        while (true); // Stop further execution
    }
}

// Determine winners for lvl 3 based on player inputs
void determineWinnerslvl3() {
    resetAllLamps(); // Reset all lamps at the start of the function
    int activeCount = 0; // To count active players
    for (int player = 0; player < 4; player++) {
        bool correct = true; // Assume the player's input is correct
        for (int i = 0; i < level3PatternLength; i++) {
            if (playerInput[player][i] != level3Pattern[i]) {
                correct = false; // Found an incorrect input
                break; // Exit the loop early if there's an error
            }
        }
        // Show result for each player
        if (correct) {
            setPlayerRGB(player, 0, 255, 0); // Green for winner
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" wins!");
            activePlayers[player] = true; // Mark this player as active (winner)
            activeCount++; // Increment active count for winners
        } else {
            setPlayerRGB(player, 255, 0, 0); // Red for loser
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" loses!");
            activePlayers[player] = false; // Mark this player as inactive (loser)
        }
    }
    // Indicate that Level 3 has ended
    Serial.println("LEVEL 3 ENDED"); // Indicate end of Level 3
    
    if (activeCount == 0) {
        Serial.println("Game Ended: All players have lost.");
        while (true); // Stop further execution
    }
}

// Determine winners for lvl 4 based on player inputs
void determineWinnerslvl4() {
  resetAllLamps(); // Reset all lamps at the start of the function
    for (int player = 0; player < 4; player++) {
        bool correct = true; // Assume the player's input is correct
        for (int i = 0; i < level4PatternLength; i++) {
            if (playerInput[player][i] != level4Pattern[i]) {
                correct = false; // Found an incorrect input
                break; // Exit the loop early if there's an error
            }
        }
        // Show result for each player
        if (correct) {
            setPlayerRGB(player, 0, 255, 0); // Green for winner
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" wins!");
            activePlayers[player] = true; // Mark this player as active (winner)
        } else {
            setPlayerRGB(player, 255, 0, 0); // Red for loser
            Serial.print("Player ");
            Serial.print(player + 1);
            Serial.println(" loses!");
            activePlayers[player] = false; // Mark this player as inactive (loser)
        }
    }
    // Indicate that Level 4 has ended
    Serial.println("LEVEL 4 ENDED"); // Indicate end of Level 4
}

// Resets all RGB lamps to off
void resetAllLamps() {
  setMiddleRGB(-1); // Middle lamp off
  for (int player = 0; player < 4; player++) {
    setPlayerRGB(player, 0, 0, 0); // Set player lamps to off
    playerFinished[player] = false; // Reset finished status
  }
}

// Check if all active players have finished
bool areAllPlayersFinished() {
  for (int player = 0; player < 4; player++) {
    if (activePlayers[player]) { // Only consider active players
      if (!playerFinished[player]) {
        return false; // At least one active player has not finished
      }
    }
  }
  return true; // All active players have finished
}

// Show purple on all lamps for the given duration
void showPurple(int duration) {
  // Set all lamps to purple
  for (int player = 0; player < 4; player++) {
    setPlayerRGB(player, 255, 0, 255); // Purple
  }
  setMiddleRGB(255); // Middle lamp purple

  delay(duration); // Hold the color for the specified duration

  // Reset lamps to off after the duration
  resetAllLamps();
}

// Set the middle RGB lamp color based on the index
void setMiddleRGB(int colorIndex) {
  if (colorIndex == 0) { // Red
    analogWrite(middleRGB[0], 255);
    analogWrite(middleRGB[1], 0);
    analogWrite(middleRGB[2], 0);
  } else if (colorIndex == 1) { // Green
    analogWrite(middleRGB[0], 0);
    analogWrite(middleRGB[1], 255);
    analogWrite(middleRGB[2], 0);
  } else if (colorIndex == 2) { // Blue
    analogWrite(middleRGB[0], 0);
    analogWrite(middleRGB[1], 0);
    analogWrite(middleRGB[2], 255);
  } else if (colorIndex == -1) { // Turn off
    analogWrite(middleRGB[0], 0);
    analogWrite(middleRGB[1], 0);
    analogWrite(middleRGB[2], 0);
  } else if (colorIndex == 255) { // Purple
    analogWrite(middleRGB[0], 255);
    analogWrite(middleRGB[1], 0);
    analogWrite(middleRGB[2], 255);
  }else if (colorIndex == 3) { // white
    analogWrite(middleRGB[0], 255);
    analogWrite(middleRGB[1], 255);
    analogWrite(middleRGB[2], 255);
  }
}

// Set the RGB lamp for a specific player
void setPlayerRGB(int player, int red, int green, int blue) {
  analogWrite(playerRGB[player][0], red);
  analogWrite(playerRGB[player][1], green);
  analogWrite(playerRGB[player][2], blue);
}

// Show white on players lamps for the given duration
void showwhite() {
  // Set all lamps to whtie
  for (int player = 0; player < 4; player++) {
    setPlayerRGB(player, 255, 255, 255); // white 
  }
}

void setPlayerRGB(int player, int colorIndex) {
  // Ensure player index is valid
  if (player < 0 || player >= 4) return;

  if (colorIndex == 0) { // Red
    analogWrite(playerRGB[player][0], 255); // Red
    analogWrite(playerRGB[player][1], 0);   // Green
    analogWrite(playerRGB[player][2], 0);   // Blue
  } else if (colorIndex == 1) { // Green
    analogWrite(playerRGB[player][0], 0);   // Red
    analogWrite(playerRGB[player][1], 255); // Green
    analogWrite(playerRGB[player][2], 0);   // Blue
  } else if (colorIndex == 2) { // Blue
    analogWrite(playerRGB[player][0], 0);   // Red
    analogWrite(playerRGB[player][1], 0);   // Green
    analogWrite(playerRGB[player][2], 255); // Blue
  } else if (colorIndex == -1) { // Turn off
    analogWrite(playerRGB[player][0], 0);   // Red
    analogWrite(playerRGB[player][1], 0);   // Green
    analogWrite(playerRGB[player][2], 0);   // Blue
  } else if (colorIndex == 255) { // Purple
    analogWrite(playerRGB[player][0], 255); // Red
    analogWrite(playerRGB[player][1], 0);   // Green
    analogWrite(playerRGB[player][2], 255); // Blue
  } else if (colorIndex == 3) { // White
    analogWrite(playerRGB[player][0], 255); // Red
    analogWrite(playerRGB[player][1], 255); // Green
    analogWrite(playerRGB[player][2], 255); // Blue
  }
}

void showwhite(int player) {
  // Set the specified player's lamp to white
  setPlayerRGB(player, 3); // Use color index 3 for white
}

bool allPlayersLost() {
    for (int player = 0; player < 4; player++) {
        if (activePlayers[player]) {
            return false; // At least one player is still active
        }
    }
    return true; // All players have lost
}