const uint8_t sensorPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15};
const uint8_t lazerPins[] = {38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53};
float sensVal[16] = {0}; // Change to 16
float gameVal[16] = {0}; // Change to 16
float valTot = 1500;
float runTot = 1500;
int life = 3; // Change to int for whole number values

const uint8_t tuned = 23;
const uint8_t easySwitch = 21; // Easy difficulty switch
const uint8_t hardSwitch = 22; // Hard difficulty switch

bool easyMode = false; // Flag for easy mode
bool hardMode = false; // Flag for hard mode
bool mediumMode = false; // Flag for medium mode

bool prevEasyMode = false; // Store previous easy mode state
bool prevMediumMode = false; // Store previous medium mode state
bool prevHardMode = false; // Store previous hard mode state

unsigned long lastToggleTime = 0;
unsigned long toggleOptions[] = {1000, 2500, 4000, 5500, 500};
unsigned long halfSecondDelay = 500; // Half-second delay between toggles

int mediumLaserCount = 8; // Number of lasers to toggle in medium mode
int mediumLaserIndex = 0; // Index for toggling lasers in medium mode
int easyLaserIndex = 0; // Index for toggling lasers in easy mode

void baseline() {
  while (digitalRead(tuned) == HIGH) {
    for (byte i = 0; i < 16; i++) { // Change to 16
      sensVal[i] = analogRead(sensorPins[i]);
      Serial.println(sensVal[i]);
      gameVal[i] = sensVal[i]; // Corrected assignment
    }
  }
}

void toggleAllLasers() {
  for (byte i = 0; i < 16; i++) { // Change to 16
    digitalWrite(lazerPins[i], !digitalRead(lazerPins[i]));
  }
}

void lossLife() {
  // Store current game mode before toggling lasers
  prevEasyMode = easyMode;
  prevMediumMode = mediumMode;
  prevHardMode = hardMode;

  life -= 1; // Decrement life count


  // Restore previous game mode after the flashing effect
  easyMode = prevEasyMode;
  mediumMode = prevMediumMode;
  hardMode = prevHardMode;

  // Reset life count to 3 when it reaches 0
}

void setLaserPinsHigh() {
  // Toggle different set of lasers for each easy mode iteration
  for (byte i = 0; i < 16; i++) { // Iterate through laser pins
    digitalWrite(lazerPins[i], LOW); // Set all laser pins LOW initially
  }

  for (byte i = easyLaserIndex; i < easyLaserIndex + 5; i++) {
    digitalWrite(lazerPins[i % 16], HIGH); // Set five consecutive laser pins to HIGH
  }

  easyLaserIndex = (easyLaserIndex + 1) % 16; // Move to the next set of lasers for the next iteration
}



void setMediumLaserPins() {
  static unsigned long lastCycleEndTime = 0;
  static unsigned long toggleInterval = 1000; // Initial interval of 1 second

  if (millis() - lastToggleTime >= toggleInterval) {
    // Turn off all lasers
    for (byte i = 0; i < 16; i++) {
      digitalWrite(lazerPins[i], LOW);
    }

    // Randomly select 8 lasers to turn on
    for (int i = 0; i < 8; i++) {
      int randomIndex = random(16);
      digitalWrite(lazerPins[randomIndex], HIGH);
    }

    // Add a delay to allow lasers to stabilize before resuming sensor checks
    delay(200); // Adjust this delay as needed

    lastToggleTime = millis();

    // Randomly select a toggle time from the options
    toggleInterval = toggleOptions[random(sizeof(toggleOptions) / sizeof(toggleOptions[0]))];

    lastCycleEndTime = lastToggleTime + toggleInterval;
  }

  // Implement any logic or delays needed within the cycle here

  // Implement any logic or delays needed within the cycle here

  Serial.println(toggleInterval);


  // Implement any logic or delays needed within the cycle here
}

void beamBreakCheck() {
  bool flashed = false; // Flag to track if a laser has flashed

  if (easyMode) {
    for (byte i = easyLaserIndex; i < easyLaserIndex + 5; i++) {
      if (digitalRead(lazerPins[i % 16]) == HIGH) {
        gameVal[i % 16] = analogRead(sensorPins[i % 16]); // Read sensor value only when the laser is unbroken
        if (gameVal[i % 16] > (sensVal[i % 16] + 10)) {
          lossLife();
          flashed = true;
          digitalWrite(lazerPins[i % 16], HIGH); // Turn on the laser corresponding to the broken beam
          delay(125); // Delay for 125 milliseconds
          digitalWrite(lazerPins[i % 16], LOW); // Turn off the laser after the first flash
          delay(125); // Delay for 125 milliseconds before the second flash
          digitalWrite(lazerPins[i % 16], HIGH); // Turn on the laser again
          delay(125); // Delay for 125 milliseconds before the third flash
          // Delay for 125 milliseconds before returning to game state
        }
      }
    }
  } else if (mediumMode || hardMode) {
    for (byte i = 0; i < 16; i++) {
      if (digitalRead(lazerPins[i]) == HIGH) {
        gameVal[i] = analogRead(sensorPins[i]); // Read sensor value only when the laser is unbroken
        if (gameVal[i] > (sensVal[i] + 10)) {
          lossLife();
          flashed = true;
          digitalWrite(lazerPins[i], HIGH); // Turn on the laser corresponding to the broken beam
          delay(125); // Delay for 125 milliseconds
          digitalWrite(lazerPins[i], LOW); // Turn off the laser after the first flash
          delay(125); // Delay for 125 milliseconds before the second flash
          digitalWrite(lazerPins[i], HIGH); // Turn on the laser again
          delay(125); // Delay for 125 milliseconds before the third flash
          // Delay for 125 milliseconds before returning to game state
        }
      }
    }
  }

  // Return to game state if no laser has flashed
  if (!flashed) {
    // Implement return to game state logic here
  }
}



void setup() {
  Serial.begin(115200);
  pinMode(tuned, INPUT_PULLUP);

  for (byte i = 0; i < 16; i++) { // Change to 16
    pinMode(lazerPins[i], OUTPUT);
  }

  pinMode(easySwitch, INPUT_PULLUP);
  pinMode(hardSwitch, INPUT_PULLUP);
}

void loop() {
  baseline();
  life = 3;
  if (digitalRead(easySwitch) == LOW) {
    easyMode = true; // Set easy mode
    hardMode = false;
    mediumMode = false;
  } else if (digitalRead(hardSwitch) == LOW) {
    easyMode = false;
    hardMode = true; // Set hard mode
    mediumMode = false;
  } else {
    easyMode = false;
    hardMode = false;
    mediumMode = true; // Set medium mode if neither easy nor hard is chosen
  }

  if (easyMode) {
    setLaserPinsHigh(); // Set lasers according to easy mode sequence
  } else if (mediumMode) {
    setMediumLaserPins(); // Toggle medium mode lasers
  } else if (hardMode) {
    setLaserPinsHigh(); // Set all lasers to HIGH for hard mode
  }

  while (life > 0) {
    if (easyMode) {
      setLaserPinsHigh(); // Set lasers according to easy mode sequence
    } else if (mediumMode) {
      setMediumLaserPins(); // Toggle medium mode lasers
      beamBreakCheck(); // Check for intact beams as long as there are remaining lives
    } else if (hardMode) {
      setLaserPinsHigh(); // Set all lasers to HIGH for hard mode
      beamBreakCheck(); // Check for intact beams as long as there are remaining lives
    }
  }

  // Implement game logic here based on the chosen difficulty mode
}