pushLine(const char *text, Emoji::Type icon);;
redraw();;
drawGraph();;
begin(9600);;
println("Erreur d'initialisation de l'ecran OLED !");;
while (1);;
println("Terminal OLED pret");;
println(EmojiType::EMOJI_SUN, "24C");;
delay(1500);;
println(EmojiType::EMOJI_RAIN, "14C");;
delay(1500);;
println(EmojiType::EMOJI_SETTINGS, "Config");;
delay(1500);;
println("Message sans icone");;
delay(1500);;
begin(9600);;
println("Erreur d'initialisation de l'ecran OLED !");;
while (1);;
configureGraph(crepp::tools::OLED::GraphType::GRAPH_BAR, 0.0f, 3300.0f, 64);;
addPoint(milliVolts);;
delay(100);;

                    

            Adafruit_SSD1306 _display;

                    

        #pragma once
#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "Emoji.h"

namespace crepp::tools {

/*
 * =========================
 * Terminal OLED (0.96")
 * -------------------------
 * Affiche le dernier message reçu, avec un pictogramme Emoji optionnel
 * (voir crepp::tools::Emoji) en 64x64 px, à gauche du texte. A cette
 * taille, le pictogramme occupe toute la hauteur de l'écran : une seule
 * ligne de contenu est visible à la fois (pas de défilement multi-lignes).
 * S'appuie sur Adafruit_GFX / Adafruit_SSD1306 pour le rendu, et sur la
 * classe Emoji pour le dessin des pictogrammes.
 *
 * @badge driver
 * @badge experimental
 *
 * Fonctionnalités :
 * - Initialisation de l'écran (I2C)
 * - Affichage d'une ligne de texte (println)
 * - Affichage d'un pictogramme Emoji (météo ou système) avec un libellé
 * - Effacement de l'écran
 * =========================
 */
class OLED {
public:
    static constexpr uint8_t MAX_LINES       = 1;  // 64px / 64px : une seule ligne visible (icône pleine hauteur)
    static constexpr uint8_t MAX_LINE_LENGTH = 21; // 128px / 6px par caractère, lignes SANS icône
    static constexpr uint8_t ICON_SIZE        = 64; // icônes carrées 64x64 px, pleine hauteur d'écran
    static constexpr uint8_t ICON_TEXT_OFFSET = 66; // décalage du texte quand une icône est affichée
    static constexpr uint8_t LINE_HEIGHT       = 64; // hauteur d'une ligne (calée sur la taille de l'icône)

    // Capacité max du buffer de points du graphe (RAM : 4 octets x 128 = 512 o)
    static constexpr uint16_t GRAPH_CAPACITY = 128;

    /*
     * =========================
     * Type de graphe
     * =========================
     */
    enum class GraphType : uint8_t {
        GRAPH_BAR,   // barres verticales
        GRAPH_POINT  // nuage de points
    };

    /*
     * =========================
     * Constructeur
     * =========================
     * @param screenWidth  : largeur de l'écran en pixels (128 par défaut)
     * @param screenHeight : hauteur de l'écran en pixels (64 par défaut, 0.96")
     * @param resetPin     : broche RESET matérielle si utilisée, -1 sinon (partagée avec le MCU)
     */
    explicit OLED(uint8_t screenWidth = 128, uint8_t screenHeight = 64, int8_t resetPin = -1);

    /*
     * =========================
     * Méthode begin()
     * =========================
     * Initialise la communication I2C avec l'écran et efface l'affichage.
     * @param i2cAddress : adresse I2C de l'écran (0x3C par défaut sur la plupart des 0.96")
     * @return true si l'écran a été détecté et initialisé correctement
     */
    bool begin(uint8_t i2cAddress = 0x3C);

    /*
     * =========================
     * Méthode println()
     * =========================
     * Affiche une ligne de texte (efface le contenu précédent : à cette
     * taille d'icône, une seule ligne tient sur l'écran).
     * @param text : message à afficher (tronqué à MAX_LINE_LENGTH caractères)
     */
    void println(const char *text);
    void println(const String &text);

    /*
     * =========================
     * Méthode println() avec pictogramme Emoji
     * =========================
     * Identique à println(), mais affiche un pictogramme Emoji (64x64 px,
     * météo ou système, cf. crepp::tools::Emoji::Type) à gauche du texte.
     * @param icon : pictogramme à afficher (Emoji::Type::EMOJI_NONE = comportement identique à println())
     * @param text : message à afficher (tronqué, plus court qu'une ligne sans icône vu la place prise)
     */
    void println(Emoji::Type icon, const char *text);
    void println(Emoji::Type icon, const String &text);

    /*
     * =========================
     * Méthode clear()
     * =========================
     * Efface l'écran et vide l'historique des lignes.
     */
    void clear();

    /*
     * =========================
     * Méthode configureGraph()
     * =========================
     * Configure un graphe (barres ou points) qui occupera tout l'écran au
     * prochain addPoint(). Réinitialise les données déjà accumulées.
     * @param type : rendu du graphe (GRAPH_BAR ou GRAPH_POINT)
     * @param minValue : valeur minimale attendue (mappée en bas de l'écran)
     * @param maxValue : valeur maximale attendue (mappée en haut de l'écran)
     * @param maxPoints : nombre de points affichés simultanément (borné à GRAPH_CAPACITY)
     */
    void configureGraph(GraphType type, float minValue, float maxValue, uint16_t maxPoints = GRAPH_CAPACITY);

    /*
     * =========================
     * Méthode addPoint()
     * =========================
     * Ajoute une valeur au graphe et redessine l'écran. Une fois le
     * nombre de points configuré atteint, les données défilent : la plus
     * ancienne valeur est supprimée pour faire de la place à la nouvelle.
     * @param value : valeur à ajouter (bornée à [minValue, maxValue] à l'affichage)
     */
    void addPoint(float value);

    /*
     * =========================
     * Méthode clearGraph()
     * =========================
     * Vide les données du graphe (conserve le type et les bornes min/max
     * configurés par configureGraph()).
     */
    void clearGraph();

private:
    Adafruit_SSD1306 _display;
    char _lines[MAX_LINES][MAX_LINE_LENGTH + 1];
    Emoji::Type _lineIcons[MAX_LINES];

    void pushLine(const char *text, Emoji::Type icon);
    void redraw();

    // --- Graphe ---
    GraphType _graphType     = GraphType::GRAPH_BAR;
    float     _graphMin      = 0.0f;
    float     _graphMax      = 100.0f;
    uint16_t  _graphMaxPoints = GRAPH_CAPACITY;
    uint16_t  _graphCount     = 0;
    float     _graphBuffer[GRAPH_CAPACITY];

    void drawGraph();
};

/*
@example

@include
#include <crepp/tools/OLED.h>
@end_include

@instance
crepp::tools::OLED console;
@end_instance

@setup
  Serial.begin(9600);

  if (!console.begin()) {
    Serial.println("Erreur d'initialisation de l'ecran OLED !");
    while (1);
  }
  console.println("Terminal OLED pret");
@end_setup

@loop
  using EmojiType = crepp::tools::Emoji::Type;

  console.println(EmojiType::EMOJI_SUN, "24C");
  delay(1500);
  console.println(EmojiType::EMOJI_RAIN, "14C");
  delay(1500);
  console.println(EmojiType::EMOJI_SETTINGS, "Config");
  delay(1500);
  console.println("Message sans icone"); // fonctionne toujours comme avant
  delay(1500);
@end_loop

@end_example

@example
// Variante : graphe défilant (ex: tension d'un capteur au fil du temps)

@include
#include <crepp/tools/OLED.h>
@end_include

@instance
crepp::tools::OLED console;
@end_instance

@setup
  Serial.begin(9600);

  if (!console.begin()) {
    Serial.println("Erreur d'initialisation de l'ecran OLED !");
    while (1);
  }

  // Graphe en barres, valeurs attendues entre 0 et 3300 mV, 64 points affichés
  console.configureGraph(crepp::tools::OLED::GraphType::GRAPH_BAR, 0.0f, 3300.0f, 64);
@end_setup

@loop
  float milliVolts = analogRead(A0) * (3300.0f / 4095.0f);
  console.addPoint(milliVolts); // fait défiler automatiquement une fois les 64 points atteints
  delay(100);
@end_loop

@end_example
*/

} // namespace crepp::tools