#include <LiquidCrystal_I2C.h>

// Définition de l'adresse I2C de l'écran LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

unsigned long previousMillis = 0;  // Stocke le dernier moment où l'écran a été mis à jour
unsigned long interval = 1000;     // Intervalle de mise à jour du timer (1 seconde)
int timer = 30;                   // Timer commençant à 100 secondes

// Variables de jeu
const int ledBlue1 = 2;
const int ledBlue2 = 3;
const int ledRed1 = 4;
const int ledRed2 = 5;
const int ledYellow1 = 6;
const int ledYellow2 = 7;

const int buttonBlue = 8;
const int buttonRed = 9;
const int buttonYellow = 10;

const int buttonSpecialYellow1 = 11;
const int buttonSpecialYellow2 = 12;
const int buttonSpecialBlue = 13;

const int potPin = A0;  // Pin pour le potentiomètre

int currentLed1, currentLed2;
int prevPotValue, potValue;  // Valeur précédente du potentiomètre
int potThreshold = 50;  // Seuil pour une rotation significative du potentiomètre

// Variables de score
int score = 0;  // Score initial
unsigned long lastResponseTime = 0; // Temps de réponse pour le calcul du score

void setup() {
  lcd.init();              // Initialisation de l'écran LCD
  lcd.clear();             // Effacer l'écran
  lcd.backlight();         // Allumer le rétroéclairage

  lcd.setCursor(0, 0);     // Définir le curseur à la première ligne
  lcd.print("Time: ");     // Afficher le texte "Time:"
    lcd.setCursor(0, 3);     // Définir le curseur pour afficher le score
  lcd.print("Score: 0");

  pinMode(ledBlue1, OUTPUT);
  pinMode(ledBlue2, OUTPUT);
  pinMode(ledRed1, OUTPUT);
  pinMode(ledRed2, OUTPUT);
  pinMode(ledYellow1, OUTPUT);
  pinMode(ledYellow2, OUTPUT);

  pinMode(buttonBlue, INPUT_PULLUP);
  pinMode(buttonRed, INPUT_PULLUP);
  pinMode(buttonYellow, INPUT_PULLUP);
  pinMode(buttonSpecialYellow1, INPUT_PULLUP);
  pinMode(buttonSpecialYellow2, INPUT_PULLUP);
  pinMode(buttonSpecialBlue, INPUT_PULLUP);

  randomSeed(analogRead(0));
  newRound();
  Serial.begin(9600);  // Dans setup()
}

bool anyOtherAction(int correctButton1 = -1, int correctButton2 = -1) {
  return (digitalRead(buttonBlue) == LOW && buttonBlue != correctButton1 && buttonBlue != correctButton2) ||
         (digitalRead(buttonRed) == LOW && buttonRed != correctButton1 && buttonRed != correctButton2) ||
         (digitalRead(buttonYellow) == LOW && buttonYellow != correctButton1 && buttonYellow != correctButton2) ||
         (digitalRead(buttonSpecialYellow1) == LOW && buttonSpecialYellow1 != correctButton1 && buttonSpecialYellow1 != correctButton2) ||
         (digitalRead(buttonSpecialYellow2) == LOW && buttonSpecialYellow2 != correctButton1 && buttonSpecialYellow2 != correctButton2) ||
         (digitalRead(buttonSpecialBlue) == LOW && buttonSpecialBlue != correctButton1 && buttonSpecialBlue != correctButton2);
}

void loop() {
  if (timer <= 0) {
    // Afficher le score final
    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("Final Score: ");
    lcd.print(score);
    delay(10000); // Attendre 10 secondes

    // Réinitialiser le jeu
    resetGame();
    return;
  }

  unsigned long currentMillis = millis();  // Obtenir le temps écoulé depuis le démarrage de l'Arduino

  // Vérifier si une seconde s'est écoulée
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;  // Sauvegarder le temps actuel
    timer--;  // Décrémenter le timer

    // Effacer l'ancienne valeur du timer sur l'écran
    lcd.setCursor(6, 0);  // Se positionner à la position après "Time: "
    lcd.print("    ");     // Effacer l'affichage précédent (espaces pour effacer)

    // Afficher le timer actuel
    lcd.setCursor(6, 0);
    lcd.print(timer);    // Afficher le nombre de secondes restantes
  }

  prevPotValue = potValue;
  delay(100);
  potValue = analogRead(potPin);
  int potChange = abs(potValue - prevPotValue);  // Calculer l'écart de rotation du potentiomètre
  Serial.println(potChange);  // Dans loop()

  if (isDoubleYellow()) {
    if (digitalRead(buttonSpecialYellow1) == LOW && digitalRead(buttonSpecialYellow2) == LOW) {
      correctAnswer();
    } else if (anyOtherAction(buttonSpecialYellow1, buttonSpecialYellow2) || potChange > potThreshold) {
      wrongAnswer();
    }
  } else if (isDoubleBlue()) {
    if (digitalRead(buttonSpecialBlue) == LOW) {
      correctAnswer();
    } else if (anyOtherAction(buttonSpecialBlue) || potChange > potThreshold) {
      wrongAnswer();
    }
  } else if (isDoubleRed()) {
    // Si le potentiomètre a changé de façon significative (écart > 50), c'est une réponse correcte
    if (potChange > 100) {
      correctAnswer();
    } else if (anyOtherAction()) {
      wrongAnswer();
    }
  } else {
    checkRegularButtons();
    if (potChange > 100) {
      wrongAnswer();
    }
  }

   // Mettre à jour la valeur précédente du potentiomètre
}

void newRound() {
  turnOffAllLeds();

  int line1Leds[] = {ledBlue1, ledRed1, ledYellow1};
  currentLed1 = line1Leds[random(0, 3)];

  int line2Leds[] = {ledBlue2, ledRed2, ledYellow2};
  currentLed2 = line2Leds[random(0, 3)];

  digitalWrite(currentLed1, HIGH);
  digitalWrite(currentLed2, HIGH);
  lastResponseTime = millis();  // Réinitialiser le temps de réponse
}

void checkRegularButtons() {
  int correctButton = determineCorrectButton();

  if (digitalRead(correctButton) == LOW) {
    correctAnswer();
  } else if (anyOtherAction(correctButton)) {
    wrongAnswer();
  }
}

int determineCorrectButton() {
  if ((isRedLed(currentLed1) && isYellowLed(currentLed2)) ||       (isYellowLed(currentLed1) && isRedLed(currentLed2))) {
    return buttonBlue;
  }
  if ((isBlueLed(currentLed1) && isYellowLed(currentLed2)) ||       (isYellowLed(currentLed1) && isBlueLed(currentLed2))) {
    return buttonRed;
  }
  if ((isBlueLed(currentLed1) && isRedLed(currentLed2)) ||       (isRedLed(currentLed1) && isBlueLed(currentLed2))) {
    return buttonYellow;
  }
  if (isBlueLed(currentLed1) || isBlueLed(currentLed2)) {
    return buttonBlue;
  }
  if (isRedLed(currentLed1) || isRedLed(currentLed2)) {
    return buttonRed;
  }
  return buttonYellow;
}

bool isDoubleBlue() {
  return isBlueLed(currentLed1) && isBlueLed(currentLed2);
}

bool isDoubleRed() {
  return isRedLed(currentLed1) && isRedLed(currentLed2);
}

bool isDoubleYellow() {
  return isYellowLed(currentLed1) && isYellowLed(currentLed2);
}

bool isBlueLed(int led) {
  return (led == ledBlue1 || led == ledBlue2);
}

bool isRedLed(int led) {
  return (led == ledRed1 || led == ledRed2);
}

bool isYellowLed(int led) {
  return (led == ledYellow1 || led == ledYellow2);
}

void correctAnswer() {
  unsigned long reactionTime = millis() - lastResponseTime;  // Calcul du temps de réaction
  int points = 333 - reactionTime / 10;  // Réduction : 10 ms = -1 point, maximum 300 points
  points = max(0, points);  // Assurer que le score ne tombe pas en dessous de 0

  score += points;

  blinkAllLeds(5);  // Clignotement des LEDs pour signaler une réponse correcte
  newRound();       // Commencer un nouveau tour
  updateScore();    // Mettre à jour l'affichage du score
}

void wrongAnswer() {
  turnOnAllLeds();
  delay(2000);
  newRound();
}

void turnOffAllLeds() {
  digitalWrite(ledBlue1, LOW);
  digitalWrite(ledBlue2, LOW);
  digitalWrite(ledRed1, LOW);
  digitalWrite(ledRed2, LOW);
  digitalWrite(ledYellow1, LOW);
  digitalWrite(ledYellow2, LOW);
}

void turnOnAllLeds() {
  digitalWrite(ledBlue1, HIGH);
  digitalWrite(ledBlue2, HIGH);
  digitalWrite(ledRed1, HIGH);
  digitalWrite(ledRed2, HIGH);
  digitalWrite(ledYellow1, HIGH);
  digitalWrite(ledYellow2, HIGH);
}

void blinkAllLeds(int times) {
  for (int i = 0; i < times; i++) {
    turnOffAllLeds();
    delay(200);
    turnOnAllLeds();
    delay(200);
  }
}

void updateScore() {
  lcd.setCursor(7, 3);  // Se positionner sur la ligne 4 (index 3)
  lcd.print("    ");     // Effacer l'affichage précédent
  lcd.setCursor(7, 3);  // Repositionner le curseur
  lcd.print(score);      // Afficher le score actuel
}

void resetGame() {
  timer = 30;  // Réinitialiser le timer
  score = 0;    // Réinitialiser le score
  lcd.clear();  // Effacer l'écran
  lcd.setCursor(0, 0);
  lcd.print("Time: 30");  // Réafficher le timer initial
  lcd.setCursor(0, 3);
  lcd.print("Score: 0");  // Réinitialiser l'affichage du score
  newRound();   // Recommencer un nouveau tour
}