processChar(char c);;
parseSentence(char *sentence);;
verifyChecksum(const char *sentence) const;;
parseGGA(char *sentence);;
parseRMC(char *sentence);;
updateTimeFromToken(const char *token);;
parseCoordinate(const char *value, char hemisphere) const;;
gnss(Serial1);;
begin(115200);;
while (!Serial) {;
delay(10);;
begin(GNSS_BAUDRATE);;
begin();;
update();;
getPosition(pos);;
getTime(time);;
print("Lat: ");;
print(pos.latitude, 6);;
print(" Lon: ");;
print(pos.longitude, 6);;
print(" Alt: ");;
print(pos.altitudeMeters);;
print(" UTC: ");;
print(time.hour);;
print(":");;
print(time.minute);;
print(":");;
println(time.second);;

                    

            double latitude;
double longitude;
float  altitudeMeters;
uint8_t satellites;
uint16_t year;
uint8_t  month;
uint8_t  day;
uint8_t  hour;
uint8_t  minute;
uint8_t  second;
uint8_t _bufferIndex;
bool    _fixValid;
bool    _timeValid;
bool    _dateValid;
GNSS_Position _position;
GNSS_Time     _time;

                    

        #pragma once
#include <Arduino.h>

#include "../StatusDevice.h"

namespace crepp::drivers {

/*
 * =========================
 * Position GNSS
 * =========================
 * Regroupe les informations de localisation issues de la trame GGA.
 */
struct GNSS_Position {
    double latitude;       // degrés décimaux, positif = Nord, négatif = Sud
    double longitude;       // degrés décimaux, positif = Est, négatif = Ouest
    float  altitudeMeters;  // altitude au-dessus du niveau moyen de la mer (m)
    uint8_t satellites;     // nombre de satellites utilisés pour le fix
};

/*
 * =========================
 * Heure GNSS
 * =========================
 * Regroupe la date (trame RMC) et l'heure UTC (trame GGA/RMC).
 */
struct GNSS_Time {
    uint16_t year;   // ex: 2026
    uint8_t  month;  // 1-12
    uint8_t  day;    // 1-31
    uint8_t  hour;   // 0-23 (UTC)
    uint8_t  minute; // 0-59
    uint8_t  second; // 0-59
};

/*
 * =========================
 * Driver GNSS (u-blox)
 * -------------------------
 * Récupération d'une position GNSS (latitude/longitude/altitude) et de
 * l'heure UTC à partir des trames NMEA émises par un module u-blox
 * (NEO-6M, NEO-8M, ...) sur une liaison série (UART).
 *
 * @badge driver
 * @badge experimental
 *
 * Fonctionnalités :
 * - Lecture et parsing des trames NMEA GGA (position, altitude, nb satellites)
 * - Lecture et parsing des trames NMEA RMC (date, statut du fix)
 * - Accès à la dernière position et heure valides connues
 * =========================
 */
class GNSS_Handler {
public:
    /*
     * =========================
     * Constructeur
     * =========================
     * @param serialPort : flux série connecté au module GNSS (HardwareSerial
     *                     ou SoftwareSerial). Le port doit être ouvert
     *                     (begin(baudrate)) par l'appelant avant/dans begin().
     */
    explicit GNSS_Handler(Stream &serialPort);

    /*
     * =========================
     * Méthode begin()
     * =========================
     * Réinitialise l'état interne du parseur NMEA.
     * @return true (toujours, il n'y a pas de négociation possible en NMEA pur)
     */
    bool begin();

    /*
     * =========================
     * Méthode update()
     * =========================
     * Consomme les octets disponibles sur le port série et met à jour
     * la position/heure internes dès qu'une trame NMEA complète et valide
     * (checksum correct) est reçue.
     * A appeler le plus souvent possible dans loop() (sans délai bloquant).
     */
    void update();

    /*
     * =========================
     * Méthode hasFix()
     * =========================
     * @return true si le dernier statut GNSS connu indique une position valide
     */
    bool hasFix() const;

    /*
     * =========================
     * Méthode getPosition()
     * =========================
     * @param position : structure remplie avec la dernière position connue
     * @return true si la position renvoyée correspond à un fix valide
     */
    bool getPosition(GNSS_Position &position) const;

    /*
     * =========================
     * Méthode getTime()
     * =========================
     * @param time : structure remplie avec la dernière date/heure UTC connue
     * @return true si une heure valide a été reçue (la date peut rester à 0
     *         tant qu'aucune trame RMC n'a été reçue)
     */
    bool getTime(GNSS_Time &time) const;

private:
    Stream *_serial;

    char    _buffer[96];
    uint8_t _bufferIndex;

    bool    _fixValid;
    bool    _timeValid;
    bool    _dateValid;

    GNSS_Position _position;
    GNSS_Time     _time;

    void processChar(char c);
    void parseSentence(char *sentence);
    bool verifyChecksum(const char *sentence) const;

    void parseGGA(char *sentence);
    void parseRMC(char *sentence);

    void updateTimeFromToken(const char *token);
    double parseCoordinate(const char *value, char hemisphere) const;
};

/*
@example

@include
#include <crepp/drivers/GNSS_Handler.h>
@end_include

@macro
#define GNSS_BAUDRATE 9600
@end_macro

@instance
crepp::drivers::GNSS_Handler gnss(Serial1);
@end_instance

@setup
  Serial.begin(115200);
  while (!Serial) {
    delay(10); // Attente de la connexion série
  }

  Serial1.begin(GNSS_BAUDRATE);
  gnss.begin();

@end_setup

@loop
  gnss.update();

  if (gnss.hasFix()) {
    crepp::drivers::GNSS_Position pos;
    crepp::drivers::GNSS_Time time;
    gnss.getPosition(pos);
    gnss.getTime(time);

    Serial.print("Lat: ");
    Serial.print(pos.latitude, 6);
    Serial.print(" Lon: ");
    Serial.print(pos.longitude, 6);
    Serial.print(" Alt: ");
    Serial.print(pos.altitudeMeters);
    Serial.print(" UTC: ");
    Serial.print(time.hour);
    Serial.print(":");
    Serial.print(time.minute);
    Serial.print(":");
    Serial.println(time.second);
  }
@end_loop

@end_example
*/

} // namespace crepp::drivers