#include <DS1302.h> //Bibliotheque RTC
#include <Chrono.h> //Bibliotheque Chronometre

////////////////////////////////// PROGRAMMATION TEST ////////////////////////////////////

////////PIN ARDUINO////////////////////////////////////////////
int latchPin = 11;
int clockPin = 12;
int dataPin = 4;
int BUTTON_PIN_1 = 9;
int BUTTON_PIN_2 = 10;
DS1302 rtc(5, 7, 6); //Pin circuit temps réel

Time t;

    int hrsSet = 0;
    int minSet = 0;
    int secSet = 0; 
    int dayWeekSet = 0;
    int dayMonthSet = 0;
    int monthSet = 0;
    int yearSet = 0;

//////////////////Variable///////////////////////////////////
int mode = 0; // 0: Heure, 1: Date, 2: Chronomètre
int settingModeTime = 0; // 0: Heure, 1: Minute, 2: Seconde
int settingModeDate = 0; // 0: Jours, 1: Mois, 2: Année
int reading1 = HIGH;
int reading2 = HIGH;
bool bothButtonsPressed = (reading1 == LOW) && (reading2 == LOW);
int button1State = HIGH;
int button2State = HIGH;
int lastButton1State = HIGH;
int lastButton2State = HIGH;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;
unsigned long lastPressTime1 = 0;
unsigned long lastPressTime2 = 0;
const unsigned long longPressThreshold = 1500; // Ajustez la valeur en millisecondes selon vos besoins

const byte colDig[7] = // Masse des digits
{
    B01000000, // digit 1
    B00100000, // digit 2
    B00010000, // digit 3
    B00001000, // digit 4
    B00000100, // digit 5
    B00000010, // digit 6
    B00000001, // digit 7
};

const byte digit[10] = // Segments des digits
    {
        //CHIFFRES
        B00111111, // 0
        B00000110, // 1
        B01011011, // 2
        B01001111, // 3
        B01100110, // 4
        B01101101, // 5
        B01111101, // 6
        B00000111, // 7
        B01111111, // 8
        B01101111, // 9
};

const byte digitset[10] = // Segments des digits
    {
        //CHIFFRES
        B10111111, // 0
        B10000110, // 1
        B11011011, // 2
        B11001111, // 3
        B11100110, // 4
        B11101101, // 5
        B11111101, // 6
        B10000111, // 7
        B11111111, // 8
        B11101111, // 9
};

Chrono chronometre206;

void setup()
{
    Serial.begin(9600); // Initialise la communication série
    pinMode(latchPin, OUTPUT);
    pinMode(dataPin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(BUTTON_PIN_1, INPUT);
    pinMode(BUTTON_PIN_2, INPUT);
  
  // Set the clock to run-mode, and disable the write protection
  rtc.halt(false);
  rtc.writeProtect(false);
  // The following lines can be commented out to use the values already stored in the DS1302
  //rtc.setDOW(FRIDAY);        // Set Day-of-Week to FRIDAY
  //rtc.setTime(1, 18, 35);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(19, 2, 2024);   // Set the date to August 6th, 2010
  adjustVarTime();
  adjustVarDate();
  
  // Ne pas démarrer le chronomètre automatiquement
  chronometre206 = Chrono(Chrono::MILLIS, false);
 }

int Reffresh = 4; //Le rafraichissement agis sur la luminosité des digits 0 = min - 4 = max; au dessus les digits commence à scintiller
int Antirebond = 200;

////////////////////////////Fonctions/////////////////////////////
void displayTime() {
  //Serial.println("Mode displayTime()");

        adjustVarTime();
        updateShiftRegister(0, secSet % 10);
        updateShiftRegister(1, secSet / 10);
        updateShiftRegister(2, minSet % 10);
        updateShiftRegister(3, minSet / 10);
        updateShiftRegister(4, hrsSet % 10);
        updateShiftRegister(5, hrsSet / 10);
}

void adjustVarTime(){
  t = rtc.getTime();
    hrsSet = t.hour;
    minSet = t.min;
    secSet = t.sec; 
}

void displayDate() {
  //Serial.println("Mode displayDate()");

        adjustVarDate();
        updateShiftRegister(0, yearSet % 10);
        updateShiftRegister(1, yearSet / 1000);
        updateShiftRegister(2, monthSet % 10);
        updateShiftRegister(3, monthSet / 10);
        updateShiftRegister(4, dayMonthSet % 10);
        updateShiftRegister(5, dayMonthSet / 10);
}

void adjustVarDate(){
  t = rtc.getTime();
    dayMonthSet = t.date;
    monthSet = t.mon;
    yearSet = t.year;
}

void displayChrono() {
  //Serial.println("Mode displayChrono()");

  unsigned long elapsedTime = chronometre206.elapsed();
  int hoursDigit = elapsedTime / 3600000;
  int minutesDigit = (elapsedTime % 3600000) / 60000;
  int secondsDigit = (elapsedTime % 60000) / 1000;
  int millisDigit = (elapsedTime % 1000) / 100;
  int smillisDigit = (elapsedTime % 100) / 10;

        updateShiftRegister(0, smillisDigit % 10);
        updateShiftRegister(1, millisDigit % 10);
        updateShiftRegister(2, secondsDigit % 10);
        updateShiftRegister(3, secondsDigit / 10);
        updateShiftRegister(4, minutesDigit % 10);
        updateShiftRegister(5, minutesDigit / 10);
        updateShiftRegister(6, hoursDigit % 10);
}
//////////////////////////////////////////////////////////////////

void loop(){
    reading1 = digitalRead(BUTTON_PIN_1);
    reading2 = digitalRead(BUTTON_PIN_2);
    bool bothButtonsPressed = (reading1 == LOW) && (reading2 == LOW);

  // Mettez à jour l'état du bouton 1
  if (reading1 != lastButton1State) {
    lastDebounceTime = millis();
  }
  if (millis() - lastDebounceTime > debounceDelay) {
    if (reading1 != button1State) {
      button1State = reading1;

      if (button1State == LOW) {
        // Vérifier la durée d'appui
        if (millis() - lastPressTime1 < longPressThreshold) {
          // Appel de fonction ou action spécifique au bouton 1 enfoncé (court appui)
          if (mode == 0) {
            mode = 1; // Passer à la date
            delay(Antirebond); // Délai anti-rebond
          }
          else if (mode == 1) {
            mode = 2; // Passer au chronomètre
            delay(Antirebond); // Délai anti-rebond
          }
          else if (mode == 2) {
            mode = 0; // Revenir à l'heure
            delay(Antirebond); // Délai anti-rebond
          }
        }

        // Mettre à jour le temps du dernier appui
        lastPressTime1 = millis();
      }
    }
  }

  // Mettez à jour l'état du bouton 2
  if (reading2 != lastButton2State) {
    lastDebounceTime = millis();
  }
  if (millis() - lastDebounceTime > debounceDelay) {
    if (reading2 != button2State) {
      button2State = reading2;

      if (button2State == LOW) {
        // Vérifier la durée d'appui
        if (millis() - lastPressTime2 < longPressThreshold) {
          // Appel de fonction ou action spécifique au bouton 2 enfoncé (court appui)
                  // Bouton 2 : Démarrer/Pause
          if (mode == 2) {
            if (chronometre206.isRunning()) {
              // Si le chronomètre est en marche, le mettre en pause/arrêter
              chronometre206.stop();
            }
            else {
              // Si le chronomètre est arrêté, le lancer/reprendre
              chronometre206.resume();
            }
            delay(Antirebond); // Délai anti-rebond
          }
        }

        // Mettre à jour le temps du dernier appui
        lastPressTime2 = millis();
      }
    }
  }

  // Condition générale pour ajuster le temps ou la date
  if (bothButtonsPressed) {
    if (mode == 0) {
      adjustTime(); // Appeler la fonction d'ajustement de l'heure
      delay(Antirebond);
    } 
    else if (mode == 1) {
      adjustDate(); // Appeler la fonction d'ajustement de la date
      delay(Antirebond);
    } 
    else if (mode == 2) {
        if (chronometre206.isRunning()) {
          // Si le chronomètre est en marche, ne rien faire
        }
        else {
          // Si le chronomètre est arrêté, reset
          chronometre206.restart(0);
          chronometre206 = Chrono(Chrono::MILLIS, false);
        }
      delay(Antirebond);
    }
  }

  switch (mode) {
    case 0: // Heure
      displayTime();
      break;

    case 1: // Date
      displayDate();
      break;

    case 2: // Chronomètre
      displayChrono();  
      break;
    }
  lastButton1State = reading1;
  lastButton2State = reading2;
  }

void adjustTime() {
  displayTime();
    settingModeTime = 0; // 0: Heure, 1: Minute, 2: Seconde

  while (true) {
    switch (settingModeTime) {
      case 0: // Heure    
        updateShiftRegister(0, secSet % 10);
        updateShiftRegister(1, secSet / 10);
        updateShiftRegister(2, minSet % 10);
        updateShiftRegister(3, minSet / 10);
        updateShiftRegisterSet(4, hrsSet % 10);
        updateShiftRegisterSet(5, hrsSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeTime = 1; // Passer au Minutes
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            hrsSet = (hrsSet + 1) % 24;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setTime(hrsSet, minSet, secSet); // Save
            delay(Antirebond);
            return;
          }
        break;

      case 1: // Minute
        updateShiftRegister(0, secSet % 10);
        updateShiftRegister(1, secSet / 10);
        updateShiftRegisterSet(2, minSet % 10);
        updateShiftRegisterSet(3, minSet / 10);
        updateShiftRegister(4, hrsSet % 10);
        updateShiftRegister(5, hrsSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeTime = 2; // Passer au Secondes
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            minSet = (minSet + 1) % 60;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setTime(hrsSet, minSet, secSet); // Save
            delay(Antirebond);
            return;
          }
        break;

      case 2: // Seconde 
        updateShiftRegisterSet(0, secSet % 10);
        updateShiftRegisterSet(1, secSet / 10);
        updateShiftRegister(2, minSet % 10);
        updateShiftRegister(3, minSet / 10);
        updateShiftRegister(4, hrsSet % 10);
        updateShiftRegister(5, hrsSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeTime = 0; // Passer au Heures
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            secSet = (secSet + 1) % 60;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setTime(hrsSet, minSet, secSet); // Save
            delay(Antirebond);
            return;
          }
        break;
    }
  }
}

void adjustDate() {
  displayDate();
    settingModeDate = 0; // 0: Jours, 1: Mois, 2: Année
  while (true) {
    switch (settingModeDate) {
      case 0: // Jours
        updateShiftRegister(0, yearSet % 10);
        updateShiftRegister(1, yearSet / 1000);
        updateShiftRegister(2, monthSet % 10);
        updateShiftRegister(3, monthSet / 10);
        updateShiftRegisterSet(4, dayMonthSet % 10);
        updateShiftRegisterSet(5, dayMonthSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeDate = 1; // Passer au Mois
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            dayMonthSet = (dayMonthSet + 1) % 31;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setDate(dayMonthSet, monthSet, yearSet); // Save
            delay(Antirebond);
            return;
          }
        break;

      case 1: // Mois
        updateShiftRegister(0, yearSet % 10);
        updateShiftRegister(1, yearSet / 1000);
        updateShiftRegisterSet(2, monthSet % 10);
        updateShiftRegisterSet(3, monthSet / 10);
        updateShiftRegister(4, dayMonthSet % 10);
        updateShiftRegister(5, dayMonthSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeDate = 2; // Passer au Années
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            monthSet = (monthSet + 1) % 12;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setDate(dayMonthSet, monthSet, yearSet); // Save
            delay(Antirebond);
            return;
          }
        break;

      case 2: // Année
        updateShiftRegisterSet(0, yearSet % 10);
        updateShiftRegisterSet(1, yearSet / 1000);
        updateShiftRegister(2, monthSet % 10);
        updateShiftRegister(3, monthSet / 10);
        updateShiftRegister(4, dayMonthSet % 10);
        updateShiftRegister(5, dayMonthSet / 10);
          if (digitalRead(BUTTON_PIN_1) == LOW) {
            settingModeDate = 0; // Passer au Jours
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_2) == LOW) {
            yearSet = (yearSet + 1) % 100;
            delay(Antirebond); // Délai anti-rebond
          } 
          if (digitalRead(BUTTON_PIN_1) == LOW && digitalRead(BUTTON_PIN_2) == LOW) {
            rtc.setDate(dayMonthSet, monthSet, yearSet); // Save
            delay(Antirebond);
            return;
          }
        break;
    }
  }
}

void updateShiftRegister(int col, int num)
{
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, colDig[col]); // Activer le digit correspondant
    shiftOut(dataPin, clockPin, MSBFIRST, digit[num]); // Activer les segments correspondant
    delay(Reffresh);
    digitalWrite(latchPin, HIGH);
}

void updateShiftRegisterSet(int col, int num)
{
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, colDig[col]); // Activer le digit correspondant
    shiftOut(dataPin, clockPin, MSBFIRST, digitset[num]); // Activer les segments correspondant
    delay(Reffresh);
    digitalWrite(latchPin, HIGH);
}