#include <WiFi.h>
#include <NetworkClientSecure.h> // to work with WiFi or Ethernet

// depuis le site RTE:
// le jour J entre 0h00 et 6h00, on obtient uniquement 1 seule info de couleur, c'est la couleur qui sera valide pour le Jour J a partir de 6h00
// la couleur entre 0h et 6h était dispo avant 0h00, On n'est plus disponible dans le json
// la couleur qui sera applicable le lendemain a partir de 6h sera disponible vers 6h00 ce jour
// enchainement de trames au fil des jours:
// trame RTE le 26/12 entre disponibilité couleur demain (~6h06) et 23h59:59
// {"values":{"2025-12-27":"WHITE","2025-12-26":"WHITE","2025-12-26-fallback":"false","2025-12-27-fallback":"false"}}

// trame RTE le 27/12 entre 0h00 et un peu plus que 6h  (couleur facturation jusque 6h00 = BLANC(obtenu la veille) / couleur facturation apres 6h00 = BLANC)
// {"values":{"2025-12-27":"WHITE","2025-12-27-fallback":"false"}}
// trame RTE le 27/12 entre disponibilité couleur demain (~6h06) et 23h59:59
// {"values":{"2025-12-27":"WHITE","2025-12-28-fallback":"false","2025-12-28":"BLUE","2025-12-27-fallback":"false"}}

// trame RTE le 28/12 entre 0h00 et un peu plus que 6h (couleur facturation jusque 6h00 = BLANC / couleur facturation apres 6h00 = BLEU)
// {"values":{"2025-12-28-fallback":"false","2025-12-28":"BLUE"}}
// trame RTE le 28/12 entre disponibilité couleur demain (~6h06) et 23h59:59
// {"values":{"2025-12-29":"RED","2025-12-28-fallback":"false","2025-12-28":"BLUE","2025-12-29-fallback":"false"}}

// trame RTE le 29/12 entre 0h00 et un peu plus que 6h (couleur facturation jusque 6h00 = BLEU / couleur facturation apres 6h00 = ROUGE)
// {"values":{"2025-12-29-fallback":"false","2025-12-29":"RED"}}



#define MAX_SIZE_T 80
#define StockMessage Serial.println
byte TempoRTEon = 1;         // actualisation couleurs tempo depuis site RTE
byte ModeReseau = 0;         // acces internet
String Source = "UneSource"; // n'importe quelle source sauf Linky et Ext
String LTARF = "NON_DEFINI";
int LastHeureRTE = -1;
int16_t HeureCouranteDeci = 0;

// MODExxx associé a ModePara
#define MODEBASIC          0 // mode parametrage simplié
#define MODEEXPERT         1 // mode parametrage expert
uint8_t ModePara = MODEEXPERT;

// variables globales actualisées :
String STGEt = "";  //Status Tempo uniquement RTE
String RTE_Jour = "NON_DEFINI";
String RTE_Demain = "NON_DEFINI";
bool HeureValide = false;


// extrait d'une structure json la réponse associé au nom
// nom est encadré par double quote, recherche la premiere occurrence nom
// réponse étant de type String entre double quote depuis le séparateur : jusqua la prochaine double quote
// double quote de la réponse exclus du retour   // ne fonctionne pas sur structure réponse contenant des doubles quote interne !
String StringJson(String nom, String Json) {
  int p;
  if ((p = Json.indexOf("\"" + nom + "\":")) < 0) return ""; else Json = Json.substring(p); // localise "nom"
  if ((p = Json.indexOf(":"))  < 0) return ""; else Json = Json.substring(p + 1); // avance jusqu'au : séparatif
  if ((p = Json.indexOf("\"")) < 0) return ""; else Json = Json.substring(p + 1); // avance jusqu'a la premiere double quote suivant le :
  if ((p = Json.indexOf("\"")) < 0) return ""; else return Json.substring(0, p);  // avance jusqu'a la prochaine double quote
}

// attend une chaine texte Date: conforme RFC 7231 (§7.1.1.2, §7.1.1.1 Prefererd format) obtenu de l'entete d'un serveur
// si la chaine est correct, avec une date postérieur a 2025, et qu'il y a une écart de plus de 2mn avec la l'heure en RTC, on ajuste RTC
// retourne :
// 1 si mise a jour de la RTC
// 0 si tout va bien sans modif RTC
// -3, -4, -5, -6 si problème pour exploiter la chaine
int ajustRTCDeLineDate(String lineDate, bool verbose = false) {
  if (lineDate.indexOf("Date: ") == 0 && lineDate.indexOf(" GMT") >= 0) {
    // Date: Thu, 29 Jan 2026 16:40:27 GMT
    lineDate = lineDate.substring(lineDate.indexOf("Date: ") + 11, lineDate.indexOf("Date: ") + 35); // 20 Dec 2025 14:39:38 GMT
    time_t tSecCurrentTime; // nombre de seconde écoulé depuis le 1er janvier 1970, d'apres le serveur
    char monthStr[4] = {0,0,0,0};
    struct tm tmServ; // charge une structure tm avec la date et l'heure du fuseau GMT avec les infos du serveur
    if (sscanf(lineDate.c_str(), "%d %s %d %d:%d:%d", &tmServ.tm_mday, &monthStr, &tmServ.tm_year, &tmServ.tm_hour , &tmServ.tm_min, &tmServ.tm_sec) != 6) return -4; // chaine mal formatée
    if (tmServ.tm_year < 2025) return -5; //date avant 2025 depuis le serveur ?
    tmServ.tm_year -= 1900;
    const char* months = "JanFebMarAprMayJunJulAugSepOctNovDec";
    char* m = strstr(months, monthStr);
    if (!m) return -6;  // pas de correspondance mois dans la date obtenue de l'entete
    tmServ.tm_mon = (m - months) / 3;
    //Serial.println(&tmServ, "%d/%m/%Y %H:%M:%S Greenwich Mean Time\n"); // date/heure GMT tel que recupéré (heure hiver en angleterre)
    // a quelques secondes près c'est une datage temporelle de l'instant
    char* oldTZ = getenv("TZ"); // on a un timestamp GMT → utiliser mktime en mode Universal Time Coordinated 
    char backupTZ[64] = {0};
    if (oldTZ) strncpy(backupTZ, oldTZ, sizeof(backupTZ)-1);
    //setenv("TZ", "GMT", 1);// On force temporairement TZ=GMT
    setenv("TZ", "UTC", 1);// On force temporairement TZ=UTC
    tzset();
    tSecCurrentTime = mktime(&tmServ);
    if (oldTZ) setenv("TZ", backupTZ, 1); else unsetenv("TZ");
    tzset();
    struct tm timeRTC;
    getLocalTime(&timeRTC);
    if (abs(tSecCurrentTime - mktime(&timeRTC)) > 120) {  // si besoin ajuste l'horloge RTC de l'ESP avec ce qu'on a obtenu du serveur
      struct timeval tv = { .tv_sec = tSecCurrentTime };
      settimeofday(&tv, NULL);
      if (verbose) {
        Serial.print("Date/Heure en RTC avant actualisation : "); Serial.println(&timeRTC, "%d/%m/%Y %H:%M:%S");
        Serial.print("Date/Heure extrait de "); Serial.println(lineDate);
        getLocalTime(&timeRTC);
        Serial.print("actualisation Date/Heure RTC de l'ESP : "); Serial.println(&timeRTC, "%d/%m/%Y %H:%M:%S\n");
      }
      return 1; // tout c'est bien passé, RTC a était mise a jour
    }
  } else return -3; // La chaine reçu n'est pas conforme a l'attendu
  return 0; // tout c'est bien passé, RTC n'a pas était mise a jour
}

// tente d'obtenir une date/heure depuis le serveur en parametre de la fonction
// retourne :
// 1 si actualisation de la RTC
// 0 si pas de changement d'heure en RTC
// -1 si probleme pour contacté le serveur
// -2 si timeout reception données depuis le serveur
// -3 le serveur ne donne pas Date: dans son entete
// autre = probleme avec la chaine obtenu du serveur
int AjustRTCDeServeur(String serv, bool verbose = false) {
  NetworkClientSecure client;  // Use clientSecu class to create TCP connections
  client.setInsecure();     // skip verification

  if (!client.connect(serv.c_str(), 443)) {
    if (verbose) Serial.println("Fail to connect " + serv);
    return -1; //Connection failed to server
  } else {
    String command = "GET / HTTP/1.0\r\nHost: " + serv + "\r\nConnection: close\r\n\r\n"; // HTTP/1.0 pour éviter transfer chunked
    client.print(command.c_str());
    uint32_t timeout = millis();
    while (client.available() == 0) {  // attend la reception du premier octet
      if (millis() - timeout > 5000) { // abandone si rien après 5 secondes
        client.stop();
        if (verbose) Serial.println("Problem avec \n" + command);
        return -2;  // pas de retour du serveur
      }
      delay(1);  // laisse un peu d'air au systeme pour faire autre chose
    }
    String lineDate = "";
    timeout = millis();
    
    while (client.connected() && (millis() - timeout < 5000)) {  // Lecture des données brutes distantes
      String line = client.readStringUntil('\n');
      if (line.indexOf("Date: ") == 0 && line.indexOf(" GMT") >= 0) {  // Date selon RFC7231
        lineDate = line;
        break;  // on a ce qui nous interresse, abandonne le reste
      }
      delay(1);  // laisse un peu d'air au systeme pour faire autre chose
    }
    client.stop();
    if (lineDate == "") return -3;
    if (verbose) Serial.println("Heure obtenue de " + serv + " : " + lineDate);
    return ajustRTCDeLineDate(lineDate, verbose);
  }
}

// retourne 0 si on a obtenu Date du jour et information(s) Couleurs disponible au moment de l'appel, sinon c'est un numérique négatif qui indique la raison de l'échec
// ajuste l'horloge RTC de l'ESP s'il y a plus de 120s d'écart avec le site RTE
// met a jour les variable globales :
// HeureValide = true si changement ajustement de l'horloge RTC
// STGEt exactement même codage que 7 ieme caractere de STGE (partant de droite) provenant du linky (une lettre hexa [0..F], en binaire 2 bits bas pour la couleur du jour / 2 bits haut pour demain)
// RTE_Jour comme : NON_DEFINI, TEMPO_BLEU TEMPO_BLANC TEMPO_ROUGE
// RTE_Demain comme : NON_DEFINI, TEMPO_BLEU TEMPO_BLANC TEMPO_ROUGE
// entre 0h et 6h00, la couleur de facturation actuelle n'est pas fournit, si l'ESP a démarré et obtenu l'info la veille, on l'utilise
int Call_RTE_data2(bool verbose = false) {
  NetworkClientSecure clientSecuRTE;  // Use clientSecu class to create TCP connections
  const String adr_RTE_Host = "www.services-rte.com";
  const String urlJSON = "/cms/open_data/v1/tempoLight";
  clientSecuRTE.setInsecure();  //skip verification
  RTE_Jour =  "NON_DEFINI";  // reset contenu variables, au cas où on obtient pas la couleur
  RTE_Demain = "NON_DEFINI";
  STGEt = "0";

  if (!clientSecuRTE.connect(adr_RTE_Host.c_str(), 443)) {
    if (verbose) Serial.println("Fail to connect " + adr_RTE_Host);
    return -1; //Connection failed to RTE server
  } else {
    String command = "GET " + urlJSON + " HTTP/1.0\r\nHost: " + adr_RTE_Host + "\r\nConnection: close\r\n\r\n"; // HTTP/1.0 pour éviter transfer chunked
    clientSecuRTE.print(command.c_str());
    uint32_t timeout = millis();
    while (clientSecuRTE.available() == 0) { // attend la reception du premier octet
      if (millis() - timeout > 5000) {       // abandone si rien après 5 secondes
        clientSecuRTE.stop();
        if (verbose) Serial.println("Problem avec \n" + command);
        return -2;  // pas de retour du site RTE ...
      }
      delay(1);  // laisse un peu d'air au systeme pour faire autre chose
    }
    String lineDate = "";
    String lineJson = "";
    timeout = millis();
    // Lecture des données brutes distantes
    while ((clientSecuRTE.connected() || clientSecuRTE.available()) && (millis() - timeout < 5000)) { // lecture Date dans l'entete
      if (clientSecuRTE.available()) {
        String line = clientSecuRTE.readStringUntil('\n'); // chaque ligne d'entete fini par \r\n
        if (line.indexOf("Date: ") == 0 && line.indexOf(" GMT") >= 0) lineDate = line; // Date selon RFC dans l'entete depuis site RTE
        if (line == "\r" || line == "") break; // on lit jusque la fin de l'entête 
      } else delay(1);  // laisse un peu d'air au systeme pour faire autre chose
    }
    while (clientSecuRTE.available() == 0 && millis() - timeout < 5000) delay(1); // On attend un tout petit peu que le corps arrive dans le buffer
    if (clientSecuRTE.available()) { // lecture json dans le corps du message, il n'y a pas de \r a la fin du message de RTE
      int len = clientSecuRTE.available();
      char* tempBuf = (char*)malloc(len + 1);
      if (tempBuf) {
        clientSecuRTE.readBytes(tempBuf, len);
        tempBuf[len] = '\0';
        lineJson = String(tempBuf);
        free(tempBuf);
      }
    }
    if (lineJson.indexOf("{") >= 0 && lineJson.indexOf("}}") >= 0)   // la chaine json avec les datas attendus
      lineJson = lineJson.substring(lineJson.indexOf("{"), lineJson.indexOf("}}") + 2);
    clientSecuRTE.stop();
    if (lineJson == "") return -3;  // pas de data a exploiter
    if (lineDate != "") ajustRTCDeLineDate(lineDate); // après cette fonction, le contenu de l'horloge RTC devrait être correct
    if (verbose) {
      struct tm timeinfo;
      getLocalTime(&timeinfo);
      Serial.print("Date/Heure en RTC : "); Serial.println(&timeinfo, "%d/%m/%Y %H:%M:%S");
      Serial.println("Date/Heure entete réponse de RTE (fuseau GMT): " + lineDate);
      Serial.println(lineJson);
    }
    // la ligne JSON contient une info avec date du moment au format YYYY-MM-DD :
    //   il est entre 0h00 et 6h00, c'est la couleur de facturation qui sera appliquée après 6h00 (la couleur de demain)
    //   il est plus que 6h00, c'est la couleur de facturation actuelle (la couleur actuelle)
    // la ligne JSON contient une info avec date + 1 jour que le moment actuel au format YYYY-MM-DD :
    //   c'est la couleur de facturation qui sera appliquée après le prochain passage à 6h00 (la couleur de demain)

    char buffer[MAX_SIZE_T];
    time_t tSecCurrentTime = time(NULL);
    struct tm * pTime = localtime(&tSecCurrentTime); // nombre de seconde écoulé depuis le 1er janvier 1970
    strftime(buffer, MAX_SIZE_T, "%Y-%m-%d", pTime);
    String dateDuJour = String(buffer);
    String txtColDuJour = StringJson(dateDuJour, lineJson);
    time_t tSecCurrentTimeplus24h = tSecCurrentTime + 24 * 60 * 60;  //  ajoute nb secondes pour 24h afin d'obtenir la date j + 1
    pTime = localtime(&tSecCurrentTimeplus24h);
    strftime(buffer, MAX_SIZE_T, "%Y-%m-%d", pTime);
    String dateDemain = String(buffer);
    String txtColNextJour = StringJson(dateDemain, lineJson);
    #define UNKN 0b00
    #define BLEU 0b01
    #define BLAN 0b10
    #define ROUG 0b11
    int binSTGEDuJour = UNKN;
    int binSTGEDemain = UNKN;
    static int8_t storeFromYesterday = -1;  // négatif = pas d'info de la veille, mémoire du code couleur 'demain' pour usage entre 0h et 6h
    Serial.println("Hour = |" + String(pTime->tm_hour) + "| / From Yesterday = |" + String(storeFromYesterday) + "| / txtColDuJour : |" + txtColDuJour + "| / txtColNextJour = |" + txtColNextJour + "|");
    if (pTime->tm_hour < 6) { //Serial.print("<");//Serial.println(" entre 0 et 5:59:59 ");
      // entre 0h et 6h, la couleur associé a la date ne commencera qu'a partir de 6h
      if (txtColDuJour == "BLUE") binSTGEDemain = BLEU;
      else if (txtColDuJour == "WHITE") binSTGEDemain = BLAN;
      else if (txtColDuJour == "RED") binSTGEDemain = ROUG;
      else binSTGEDemain = UNKN;
      if (storeFromYesterday > 0) binSTGEDuJour = storeFromYesterday; else binSTGEDuJour = UNKN; // si on a la couleur obtenue la veille
    } else { //Serial.print(">");//Serial.println(" entre 6h00:00 et 23h59:59 ");
      if (txtColDuJour == "BLUE") {binSTGEDuJour = BLEU; storeFromYesterday = binSTGEDuJour;} // memorise l'info pour usage entre 0h et 6h
      else if (txtColDuJour == "WHITE") {binSTGEDuJour = BLAN; storeFromYesterday = binSTGEDuJour;} // memorise l'info pour usage entre 0h et 6h
      else if (txtColDuJour == "RED") {binSTGEDuJour = ROUG; storeFromYesterday = binSTGEDuJour;} // memorise l'info pour usage entre 0h et 6h
      else binSTGEDuJour = UNKN;
      if (txtColNextJour == "BLUE") binSTGEDemain = BLEU;
      else if (txtColNextJour == "WHITE") binSTGEDemain = BLAN;
      else if (txtColNextJour == "RED") binSTGEDemain = ROUG;
      else binSTGEDemain = UNKN;
    }
    // chose sûre, le Dimanche 6h00 au lundi 6h00 c'est toujours bleu
    tSecCurrentTime = time(NULL);
    pTime = localtime(&tSecCurrentTime);
    // si samedi et heure > 6 et binSTGEDemain = 0b00 alors demain sera bleu : binSTGEDemain = 0b01
    if (binSTGEDemain == UNKN && (pTime->tm_wday == 6 && pTime->tm_hour > 6) || (pTime->tm_wday == 0 && pTime->tm_hour < 6)) binSTGEDemain = BLEU;
    // si dimanche et heure > 6 et  binSTGEDuJour = UNKN alors ce jour est bleu : binSTGEDuJour = 0b01
    if (binSTGEDuJour == UNKN && (pTime->tm_wday == 0 && pTime->tm_hour > 6) || (pTime->tm_wday == 1 && pTime->tm_hour < 6)) binSTGEDuJour = BLEU;
    String binColToText[4] = {"NON_DEFINI", "TEMPO_BLEU", "TEMPO_BLANC", "TEMPO_ROUGE"};
    RTE_Jour = binColToText[binSTGEDuJour];
    RTE_Demain = binColToText[binSTGEDemain];
    STGEt = String((binSTGEDemain << 2) | binSTGEDuJour , HEX);  // compose le caractere STGE codant les couleurs du jour et de 'demain'
    STGEt.toUpperCase();
    // remet dateDuJour et dateDemain au format lisible jour/mois
    dateDuJour = dateDuJour.substring(8,10) + "/" +  dateDuJour.substring(5,7);
    dateDemain = dateDemain.substring(8,10) + "/" +  dateDemain.substring(5,7); 
    StockMessage("TEMPO Periode du " + dateDuJour + " 6h au " + dateDemain + " 6h : " + (RTE_Jour.substring(0,6) != "TEMPO_" ? "?" : RTE_Jour.substring(6)) + " | 'Demain' : " +  (RTE_Demain.substring(0,6) != "TEMPO_" ? "?" : RTE_Demain.substring(6)) + "\n");
    return 0;
  }
}

// pour cohérence avec fonction Call_RTE_data du RMS:
// ajuste LTARF comme RTE_Jour
// ajuste STGEt uniquement avec la couleur de demain
void Call_RTE_data() {
  char buffer[MAX_SIZE_T];
  int Hcour = HeureCouranteDeci / 2;  //Par pas de 72secondes pour faire 2 appels si un bug
  int LastH = LastHeureRTE / 2;

// il faut éviter de questionner l'URL tempo light si on a déjà les infos qui nous intéressent...
  //bool couleur_lendemain = (String(strtoul(STGEt.c_str(),0,16) & 0b1100) != "0";  // true si couleur du lendemain connue
  bool couleur_lendemain = (String(strtoul(STGEt.c_str(),NULL,16) & 0b1100) == "4" || String(strtoul(STGEt.c_str(),NULL,16) & 0b1100) == "8" || String(strtoul(STGEt.c_str(),NULL,16) & 0b1100) == "C" );              // true si couleur du lendemain connue
  //bool couleur_jour =    (String(strtoul(STGEt.c_str(),NULL,16) & 0b11) == "1" || String(strtoul(STGEt.c_str(),NULL,16) & 0b11) == "2" || String(strtoul(STGEt.c_str(),NULL,16) & 0b11) == "3" );              // true si couleur du lendemain connue
  bool couleur_jour      = (LTARF == "TEMPO_BLEU" || LTARF == "TEMPO_BLANC" || LTARF == "TEMPO_ROUGE"); // true si couleur du jour connu

  // traitement du changement de couleur tempo à 6h00, avec ré-initialisation de la couleur du lendemain
  // à 6h00 précises, la couleur tempo du lendemain devient la couleur du jour. Celle du lendemain n'est à priori pas encore connue
  // Cela permet de continuer à fonctionner de manière nominale même si le site RTE n'est pas encore renseigné
  // && (LTARF != "") pour ne pas passer dans cette boucle au reset si fait à 6h00 du matin...
  // && (STGEt <> "")  pour éviter de passer plusieurs fois ( 3 à 4 ) dans cette boucle à cause du Hcour/2
  if ( (Hcour == 300) && (LTARF != "") && (STGEt != "") ) {  
    if       (STGEt == "4") LTARF = "TEMPO_BLEU";  
    else if  (STGEt == "8") LTARF = "TEMPO_BLANC"; 
    else if  (STGEt == "C") LTARF = "TEMPO_ROUGE";
    else LTARF = "NON_DEFINI";
    STGEt=""; 
    couleur_lendemain = false; // on ne connait plus la couleur du lendemain. Cela forcera la lecture sur le site RTE 
    if (LTARF != "" && TempoRTEon == 1 && ModeReseau == 0) {  
      StockMessage("TEMPO depuis 6h00 : " + (LTARF.substring(0,6) != "TEMPO_" ? "?" : LTARF.substring(6)) + ", demain ? ");
      RTE_Jour = (LTARF.substring(0,6) != "TEMPO_" ? "NON_DEFINI" : LTARF.substring(6));
      RTE_Jour = "NON_DEFINI";  // on a pas confirmation du site RTE pour le moment
      RTE_Demain = "NON_DEFINI";
    }
  }  

  // appel au site RTE seulement si : 
  // (!(couleur_lendemain && couleur_jour )) = on n'a pas les couleur du jour et couleur demain
  // (LastH != Hcour) = on a pas déja obtenu les informations
  // on est sur un des créneaux horaire prévu ou ) || (LastHeureRTE < 0) = on a jamais obtenue les info
  // [302 = 6h02:24 * 306 = 6h07:12 * 307 = 6h08:24] * 310 = 6h12 * 530 = 10h36 * 560 = 11h12 * 600 = 12h00 * 900 = 18h00 * 1150 = 23h00
  //Serial.println("Couleur du jour ou demain inconnue : " + String(!(couleur_lendemain && couleur_jour)));
  //Serial.println("Heure interrogation précédente différente de maintenant: " + String((LastH != Hcour)));
  //Serial.println("Une des heures ou on interroge volontairement : " + String((Hcour == 305) || (Hcour == 310) || (Hcour == 530) || (Hcour == 560) || (Hcour == 600) || (Hcour == 900) || (Hcour == 1150)));
  //Serial.println("on a jamais obtenu d'info depuis RTE : " + String(LastHeureRTE < 0));
  if (Hcour == 529) {
    STGEt = "0";  //  ajustement avant tentative lecture de 10h36, on force l'actualisation pour obtenir la couleur confirmée pour le lendemain
    Serial.println("Clear mémoire couleur demain pour actualisation");
  }
  if ((!(couleur_lendemain && couleur_jour )) && ((LastH != Hcour) && ((Hcour == 307) || (Hcour == 310) || (Hcour == 530) || (Hcour == 560) || (Hcour == 600) || (Hcour == 900) || (Hcour == 1150))) || (LastHeureRTE < 0)) {
    if (TempoRTEon == 1 && ModeReseau == 0) { // souhaite obtenir les couleurs depuis le site RTE et accepte acces sur Internet
      int r = Call_RTE_data2(ModePara == MODEEXPERT);  // coeur de la fonction qui utilise le datage donné par RTE pour interpreter la couleur tarification actuelle et celle a venir
      struct tm timeinfo;
      getLocalTime(&timeinfo);
      if (!r) {  // retour = 0 si tout est Ok
        HeureCouranteDeci = timeinfo.tm_hour * 100 + timeinfo.tm_min * 10 / 6;
        // LastHeureRTE = HeureCouranteDeci;  //commenté pour test, a activer en prod
        LTARF = RTE_Jour;
        STGEt = String(STGEt.toInt() & ~0b11, HEX);  // supprime l'information couleur du jour
        STGEt.toUpperCase();
      } else {
        StockMessage(String(timeinfo.tm_year + 1900) + "-" + String(timeinfo.tm_mon + 1) + "-" + String(timeinfo.tm_mday) + " : Date et/ou données RTE non valides " + String(r));
      }
    } else {
      if (Source != "Linky" && Source != "Ext") {
        LTARF = "";
        STGEt = "0";
      }
    }
  }
}

void setup() {
  setenv("TZ", "CET-1CEST,M3.5.0/2,M10.5.0/3", 1);  // équivalent, en plus court de : CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00
  tzset();
  Serial.begin(115200);
  Serial.print("Connecting to WiFi");
  WiFi.begin("Wokwi-GUEST", "", 6);
  while (WiFi.status() != WL_CONNECTED) {
    delay(250);
    Serial.print(".");
  }
  Serial.println(" Connected!");
  struct tm timeinfo;
  getLocalTime(&timeinfo);
  if (timeinfo.tm_year < 125) {
    Serial.print("Horloge RTC non cohérente ! Date/Heure connue : ");
    Serial.println(&timeinfo, "%d/%m/%Y %H:%M:%S\n");
    // AjustRTCDeServeur(WiFi.gatewayIP().toString()); // ne fonctionne pas sur wokwi, pas de service http sur 10.0.0.1
    AjustRTCDeServeur("8.8.8.8", true);  // va chercher l'heure chez Google
  }
  Call_RTE_data();  // 1er appel au site RTE, mettera la RTC a l'heure si non cohérent
}

void loop() {
  delay(20000);
  Call_RTE_data();
}