// ============================================================================
// FICHIER      : NTPClient.cpp
// DESCRIPTION  : Client NTP pour Arduino - Implementation
// Version      : 99.0.0 (base NTPClient 3.2.1 officielle - FIX v1.1)
// ============================================================================
//
// LIB D'ORIGINE : NTPClient v3.2.1 par Fabrice Weinberg (2015)
// Depot GitHub  : https://github.com/arduino-libraries/NTPClient
// Licence       : MIT
//
// Voir NTPClient.h pour :
//   - Principe de fonctionnement NTP
//   - Structure du paquet UDP 48 bytes
//   - Machine d'etat update() / forceUpdate()
//   - Empreinte memoire par instance
//   - Historique complet des versions (FIX v1.0, FIX v1.1)
//
// Voir __DOC_NTPClient.txt pour la documentation detaillee de chaque fonction.
// ============================================================================

#include "NTPClient.h"

NTPClient::NTPClient(UDP& udp) {
  this->_udp            = &udp;
}

NTPClient::NTPClient(UDP& udp, int timeOffset) {
  this->_udp            = &udp;
  this->_timeOffset     = timeOffset;
}

NTPClient::NTPClient(UDP& udp, const char* poolServerName) {
  this->_udp            = &udp;
  this->_poolServerName = poolServerName;
}

NTPClient::NTPClient(UDP& udp, const char* poolServerName, int timeOffset) {
  this->_udp            = &udp;
  this->_timeOffset     = timeOffset;
  this->_poolServerName = poolServerName;
}

NTPClient::NTPClient(UDP& udp, const char* poolServerName, int timeOffset, unsigned long updateInterval) {
  this->_udp            = &udp;
  this->_timeOffset     = timeOffset;
  this->_poolServerName = poolServerName;
  this->_updateInterval = updateInterval;
}

void NTPClient::begin() {
  this->begin(NTP_DEFAULT_LOCAL_PORT);
}

void NTPClient::begin(int port) {
  this->_port = port;

  this->_udp->begin(this->_port);

  this->_udpSetup = true;
}

// ============================================================================
// FONCTION     : isValid()
// ENTREE       : ntpPacket  - pointeur vers buffer paquet NTP recu (48 bytes)
// SORTIE       : bool       - true si paquet valide, false sinon
// VARIABLES    : aucune modifiee (lecture seule du buffer)
// ----------------------------------------------------------------------------
// DESCRIPTION  :
//   Verifie la coherence des champs cles du paquet NTP recu afin de rejeter
//   les paquets corrompus, reponses non-NTP ou serveurs non synchronises.
//
// ORGANIGRAMME DE VALIDATION :
//
//   [Byte 0, bits 7-6]  LI == 0b11 ?
//          OUI → return false   (serveur non synchronise = UNSYNC)
//          NON ↓
//   [Byte 0, bits 5-3]  Version < 4 ?
//          OUI → return false   (version NTP insuffisante)
//          NON ↓
//   [Byte 0, bits 2-0]  Mode != 0b100 ?
//          OUI → return false   (pas une reponse serveur)
//          NON ↓
//   [Byte 1]  Stratum < 1 ou > 15 ?
//          OUI → return false   (stratum invalide ou non reference)
//          NON ↓
//   [Bytes 16-23]  ReferenceTimestamp tous a zero ?
//          OUI → return false   (serveur pas encore synchronise)
//          NON ↓
//   return true
//
// FIX v1.1 : CORRECTION bug byte[22] compare deux fois (ntpPacket[22]==0
//            && ntpPacket[22]==0) → corrige en ntpPacket[22] && [23]
//            Impact : le 8eme byte du ReferenceTimestamp n'etait jamais
//            verifie, permettant a un paquet partiellement nul de passer.
// ============================================================================
bool NTPClient::isValid(byte * ntpPacket)
{
  //Perform a few validity checks on the packet
  if((ntpPacket[0] & 0b11000000) == 0b11000000)    //Check for LI=UNSYNC
    return false;

  if((ntpPacket[0] & 0b00111000) >> 3 < 0b100)     //Check for Version >= 4
    return false;

  if((ntpPacket[0] & 0b00000111) != 0b100)         //Check for Mode == Server
    return false;

  if((ntpPacket[1] < 1) || (ntpPacket[1] > 15))    //Check for valid Stratum
    return false;

  if( ntpPacket[16] == 0 && ntpPacket[17] == 0 &&
      ntpPacket[18] == 0 && ntpPacket[19] == 0 &&
      ntpPacket[20] == 0 && ntpPacket[21] == 0 &&
      ntpPacket[22] == 0 && ntpPacket[23] == 0)    //FIX v1.1 : corrige [22][22] → [22][23] (ReferenceTimestamp 8 bytes)
    return false;

  return true;
}

// ============================================================================
// FONCTION     : forceUpdate()
// ENTREE       : aucune
// SORTIE       : bool - true si synchro reussie, false si timeout (> 1000ms)
// VARIABLES    : _lastUpdate, _currentEpoc, _packetBuffer
// ----------------------------------------------------------------------------
// DESCRIPTION  :
//   Force une synchronisation immediate avec le serveur NTP,
//   independamment de l'intervalle _updateInterval.
//
// ORGANIGRAMME :
//
//   +------------------------------------+
//   | Flush file UDP existante           |  FIX v1.1 : evite paquets residuels
//   | while(parsePacket != 0) flush()    |
//   +------------------+-----------------+
//                      |
//   +------------------+-----------------+
//   | sendNTPPacket()                    |
//   | construit + envoie requete 48 bytes|
//   +------------------+-----------------+
//                      |
//   +------------------+-----------------+  <-----------+
//   | delay(10ms)                        |              |
//   | cb = udp->parsePacket()            |   cb==0      |
//   | if(timeout > 100) return false     +-- et         |
//   | timeout++                          |   timeout<=100→+
//   +------------------+-----------------+
//                      | cb > 0
//   +------------------+-----------------+
//   | udp->read(_packetBuffer, 48)       |
//   +------------------+-----------------+
//                      |
//   +------------------+-----------------+
//   | isValid(_packetBuffer) ?           |
//   |   NON → cb = 0 ────────────────────+-->  (reboucle)
//   |   OUI ↓                            |
//   +------------------+-----------------+
//                      |
//   _lastUpdate  = millis() - (10 * (timeout + 1))
//   highWord     = packetBuffer[40] << 8 | packetBuffer[41]
//   lowWord      = packetBuffer[42] << 8 | packetBuffer[43]
//   secsSince1900= highWord << 16 | lowWord
//   _currentEpoc = secsSince1900 - SEVENZYYEARS
//   return true
// ============================================================================
bool NTPClient::forceUpdate() {
  #ifdef DEBUG_NTPClient
    Serial.println("Update from NTP Server");
  #endif

  // FIX v1.1 : flush des paquets UDP residuels avant envoi de la requete
  //            garantit que la reponse lue correspond bien a la requete courante
  while(this->_udp->parsePacket() != 0)
    this->_udp->flush();

  this->sendNTPPacket();

  // Wait till data is there or timeout...
  byte timeout = 0;
  int cb = 0;
  do {
    delay ( 10 );
    cb = this->_udp->parsePacket();

    if(cb > 0)
    {
      this->_udp->read(this->_packetBuffer, NTP_PACKET_SIZE);
      if(!this->isValid(this->_packetBuffer))
        cb = 0;
    }

    if (timeout > 100) return false; // timeout after 1000 ms
    timeout++;
  } while (cb == 0);

  this->_lastUpdate = millis() - (10 * (timeout + 1)); // Account for delay in reading the time

  unsigned long highWord = word(this->_packetBuffer[40], this->_packetBuffer[41]);
  unsigned long lowWord = word(this->_packetBuffer[42], this->_packetBuffer[43]);
  // combine the four bytes (two words) into a long integer
  // this is NTP time (seconds since Jan 1 1900):
  unsigned long secsSince1900 = highWord << 16 | lowWord;

  this->_currentEpoc = secsSince1900 - SEVENZYYEARS;

  return true;
}

// ============================================================================
// FONCTION     : update()
// ENTREE       : aucune
// SORTIE       : bool - true si heure valide (synchro OK ou pas necessaire)
//                       false si forceUpdate() a echoue (timeout)
// VARIABLES    : aucune directement (delegue a forceUpdate())
// ----------------------------------------------------------------------------
// MACHINE D'ETAT :
//
//   [APPEL update()]
//         |
//   _lastUpdate == 0 ?   OUI ──────────────────────────+
//         |                                             |
//        NON                                            |
//         |                                             |
//   millis()-_lastUpdate >= _updateInterval ?           |
//        OUI ──────────────────────────────────────────-+
//         |                                             |
//        NON                                            v
//         |                            _udpSetup == false ? → begin()
//   return true                                         |
//   (pas de maj necessaire)                      forceUpdate()
//                                                        |
//                                            return true / false
// ============================================================================
bool NTPClient::update() {
  if ((millis() - this->_lastUpdate >= this->_updateInterval)     // Update after _updateInterval
    || this->_lastUpdate == 0) {                                // Update if there was no update yet.
    if (!this->_udpSetup) this->begin();                         // setup the UDP client if needed
    return this->forceUpdate();
  }
  return true;
}

// ============================================================================
// FONCTION     : isTimeSet()
// ENTREE       : aucune
// SORTIE       : bool - true si _lastUpdate != 0
// VARIABLES    : aucune modifiee
// ----------------------------------------------------------------------------
// _lastUpdate est mis a zero a l'init et mis a jour par forceUpdate() apres
// chaque synchro reussie. Permet de savoir si l'heure a ete synchronisee
// au moins une fois depuis le demarrage avant d'afficher l'heure.
//
// Usage : if (ntp.isTimeSet()) { Serial.println(ntp.getFormattedTime()); }
//
// FIX v1.1 : ajout de cette fonction
// ============================================================================
bool NTPClient::isTimeSet() const {
  return (this->_lastUpdate != 0);  //FIX v1.1 : ajout isTimeSet()
}

// ============================================================================
// FONCTION     : getEpochTime()
// ENTREE       : aucune
// SORTIE       : unsigned long - secondes depuis 01/01/1970 00:00:00 UTC
// VARIABLES    : aucune modifiee
// ----------------------------------------------------------------------------
// Calcul : _timeOffset + _currentEpoc + (millis() - _lastUpdate) / 1000
//          ^^^^^^^^^^^^   ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//          fuseau horaire  NTP converti   derive depuis la derniere synchro
// ============================================================================
unsigned long NTPClient::getEpochTime() {
  return this->_timeOffset + // User offset
         this->_currentEpoc + // Epoc returned by the NTP server
         ((millis() - this->_lastUpdate) / 1000); // Time since last update
}

int NTPClient::getDay() {
  return (((this->getEpochTime()  / 86400L) + 4 ) % 7); //0 is Sunday
}
int NTPClient::getHours() {
  return ((this->getEpochTime()  % 86400L) / 3600);
}
int NTPClient::getMinutes() {
  return ((this->getEpochTime() % 3600) / 60);
}
int NTPClient::getSeconds() {
  return (this->getEpochTime() % 60);
}

// ============================================================================
// FONCTION     : getFormattedTime()
// ENTREE       : secs - timestamp epoch a formater (0 = heure courante)
// SORTIE       : String format "HH:MM:SS"
// VARIABLES    : aucune modifiee
// ----------------------------------------------------------------------------
// rawTime = secs ? secs : getEpochTime()
// hours   = (rawTime % 86400) / 3600
// minutes = (rawTime % 3600)  / 60
// seconds =  rawTime % 60
// ============================================================================
String NTPClient::getFormattedTime(unsigned long secs) {
  unsigned long rawTime = secs ? secs : this->getEpochTime();
  unsigned long hours = (rawTime % 86400L) / 3600;
  String hoursStr = hours < 10 ? "0" + String(hours) : String(hours);

  unsigned long minutes = (rawTime % 3600) / 60;
  String minuteStr = minutes < 10 ? "0" + String(minutes) : String(minutes);

  unsigned long seconds = rawTime % 60;
  String secondStr = seconds < 10 ? "0" + String(seconds) : String(seconds);

  return hoursStr + ":" + minuteStr + ":" + secondStr;
}

// ============================================================================
// FONCTION     : getFormattedDate()
// ENTREE       : secs - timestamp epoch a formater (0 = date courante)
// SORTIE       : String format "JJ/MM/AAAA"
// VARIABLES    : aucune modifiee (calcul local uniquement)
// ----------------------------------------------------------------------------
// ATTENTION : utilise UTC - ne tient pas compte de _timeOffset.
//             Pour date locale : passer getEpochTime() + _timeOffset en secs.
//
// ORGANIGRAMME :
//
//   rawTime = epoch / 86400  (jours depuis 01/01/1970)
//              |
//   +------------------------------------------+
//   | year = 1970                              |
//   | TANT QUE days += (LEAP_YEAR ? 366 : 365) |
//   |              <= rawTime                  |
//   |   year++                                 |
//   +------------------------------------------+
//   rawTime -= jours annees precedentes → jours dans l'annee courante
//              |
//   +------------------------------------------+
//   | POUR month = 0 a 11                      |
//   |   si fevrier : 29 si LEAP_YEAR, 28 sinon |
//   |   SI rawTime < longueur mois → break     |
//   |   rawTime -= longueur mois               |
//   +------------------------------------------+
//              |
//   month++  (janvier = 1)
//   rawTime++ (jour base 1)
//   return "JJ/MM/AAAA"
//
// Based on https://github.com/PaulStoffregen/Time/blob/master/Time.cpp
// FIX v1.0 : reintegre (supprime dans lib officielle upstream)
// ============================================================================
String NTPClient::getFormattedDate(unsigned long secs) {  //FIX v1.0 : reintegre
  unsigned long rawTime = (secs ? secs : this->getEpochTime()) / 86400L;  // in days
  unsigned long days = 0, year = 1970;
  uint8_t month;
  static const uint8_t monthDays[]={31,28,31,30,31,30,31,31,30,31,30,31};

  while((days += (LEAP_YEAR(year) ? 366 : 365)) <= rawTime)
    year++;
  rawTime -= days - (LEAP_YEAR(year) ? 366 : 365); // now it is days in this year, starting at 0
  days=0;
  for (month=0; month<12; month++) {
    uint8_t monthLength;
    if (month==1) { // february
      monthLength = LEAP_YEAR(year) ? 29 : 28;
    } else {
      monthLength = monthDays[month];
    }
    if (rawTime < monthLength) break;
    rawTime -= monthLength;
  }
  String monthStr = ++month < 10 ? "0" + String(month) : String(month); // jan is month 1
  String dayStr = ++rawTime < 10 ? "0" + String(rawTime) : String(rawTime); // day of month
  //return String(year) + "-" + monthStr + "-" + dayStr + "T" + this->getFormattedTime(secs ? secs : 0) + "Z";
  return String(dayStr + "/" + monthStr + "/" +(year) );
}

void NTPClient::end() {
  this->_udp->stop();

  this->_udpSetup = false;
}

void NTPClient::setTimeOffset(int timeOffset) {
  this->_timeOffset     = timeOffset;
}

void NTPClient::setUpdateInterval(unsigned long updateInterval) {
  this->_updateInterval = updateInterval;
}

// ============================================================================
// FONCTION     : setPoolServerName()
// ENTREE       : poolServerName - nom du serveur NTP en chaine C
// SORTIE       : aucune
// VARIABLES    : _poolServerName
// ----------------------------------------------------------------------------
// Permet de changer le serveur NTP a la volee sans reconstruire l'objet.
// Exemples : "fr.pool.ntp.org", "time.google.com", "time.cloudflare.com"
//
// Usage pour serveur de secours :
//   if (!ntp.forceUpdate()) {
//     ntp.setPoolServerName("time.google.com");
//     ntp.forceUpdate();
//   }
//
// FIX v1.1 : ajout de cette fonction
// ============================================================================
void NTPClient::setPoolServerName(const char* poolServerName) {  //FIX v1.1 : ajout setPoolServerName()
  this->_poolServerName = poolServerName;
}

// ============================================================================
// FONCTION     : sendNTPPacket()  [private]
// ENTREE       : aucune
// SORTIE       : aucune
// VARIABLES    : _packetBuffer (ecrase)
// ----------------------------------------------------------------------------
// Construit et envoie un paquet NTP de 48 bytes au serveur UDP port 123.
//
// CONTENU DU PAQUET EMIS :
//   [0]    = 0b11100011  LI=11 (non sync), Version=4, Mode=3 (client)
//   [1]    = 0           Stratum unspecified
//   [2]    = 6           Poll Interval
//   [3]    = 0xEC        Precision (-20)
//   [4..11]= 0           Root Delay + Root Dispersion
//   [12]   = 0x49 'I'
//   [13]   = 0x4E 'N'    Reference Identifier = "INIT"
//   [14]   = 0x49 'I'
//   [15]   = 0x52 'R'
//   [16..47]= 0          Timestamps (non renseignes en mode client)
// ============================================================================
void NTPClient::sendNTPPacket() {
  // set all bytes in the buffer to 0
  memset(this->_packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  this->_packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  this->_packetBuffer[1] = 0;     // Stratum, or type of clock
  this->_packetBuffer[2] = 6;     // Polling Interval
  this->_packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  this->_packetBuffer[12]  = 0x49;
  this->_packetBuffer[13]  = 0x4E;
  this->_packetBuffer[14]  = 0x49;
  this->_packetBuffer[15]  = 0x52;

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  this->_udp->beginPacket(this->_poolServerName, 123); //NTP requests are to port 123
  this->_udp->write(this->_packetBuffer, NTP_PACKET_SIZE);
  this->_udp->endPacket();
}

// ============================================================================
// FONCTION     : setEpochTime()
// ENTREE       : secs - timestamp Unix (secondes depuis 01/01/1970)
// SORTIE       : aucune
// VARIABLES    : _currentEpoc
// ----------------------------------------------------------------------------
// Injecte manuellement un timestamp dans _currentEpoc sans passer par NTP.
// Utile pour restaurer l'heure depuis une RTC apres un redemarrage.
//
// NOTE : _lastUpdate n'est PAS mis a jour → isTimeSet() reste false.
//        L'heure sera diffusee via getEpochTime() mais update() declenchera
//        quand meme une synchro NTP au prochain cycle (car _lastUpdate == 0).
//
// Exemple RTC :
//   DateTime now = rtc.now();
//   ntp.setEpochTime(now.unixtime());
//
// FIX v1.0 : reintegre (supprime dans lib officielle upstream)
// ============================================================================
void NTPClient::setEpochTime(unsigned long secs) {  //FIX v1.0 : reintegre
  this->_currentEpoc = secs;
}
