wheel(uint8_t pos);;
lerp(uint8_t a, uint8_t b, float t);;

                    

            Adafruit_NeoPixel _strip;
uint32_t _fadeStartColor;
uint32_t _fadeTargetColor;
long _fadeStartTime;
uint16_t _fadeDuration;

                    

        #pragma once

#include <Arduino.h>
#include <Adafruit_NeoPixel.h>
#include "../StatusDevice.h"

#ifndef CREPP_LED_PIN
#define CREPP_LED_PIN 17
#endif

#ifndef CREPP_LED_COUNT
#define CREPP_LED_COUNT 8   //Nombre de LEDs dans la bande
#endif

namespace crepp::drivers {

/*
 * =========================
 * Driver: LED_Handler
 * -------------------------
 * Pilote d'un bandeau de LEDs adressables (NeoPixel / WS2812).
 *
 * @badge driver
 * @badge stable
 *
 * Fonctionnalités :
 * - Contrôle individuel des pixels (couleur RGB ou valeur 32 bits)
 * - Réglage de la luminosité globale
 * - Effet arc-en-ciel animé (non bloquant, piloté via update())
 * - Fondu de couleur progressif (non bloquant, piloté via update())
 *
 * @note begin() doit être appelé une fois dans setup(), et update() doit
 *       être appelée à chaque tour de loop() pour faire progresser les
 *       effets animés (rainbow / fade). Sans appel régulier à update(),
 *       les animations démarrées restent figées.
 * =========================
 */
class LED_Handler {
public:
    /**
     * @brief Construit le bandeau de LEDs.
     * @param pin Broche de données du bandeau (défaut: macro LED_PIN)
     * @param count Nombre de LEDs du bandeau (défaut: macro LED_COUNT)
     */
    LED_Handler(uint8_t pin = CREPP_LED_PIN, uint16_t count = CREPP_LED_COUNT);
    ~LED_Handler();

    /**
     * @brief Initialise le bandeau et l'éteint (toutes LEDs à noir).
     */
    void begin();

    /**
     * @brief Fait progresser les animations en cours (rainbow / fade).
     *        A appeler à chaque tour de loop().
     */
    void update();   // à appeler dans loop()

    // Contrôle individuel
    /**
     * @brief Définit la couleur d'un pixel à partir de ses composantes RGB.
     * @param index Indice du pixel (0 à count-1)
     * @param r Composante rouge (0-255)
     * @param g Composante verte (0-255)
     * @param b Composante bleue (0-255)
     */
    void setPixel(uint16_t index, uint8_t r, uint8_t g, uint8_t b);

    /**
     * @brief Définit la couleur d'un pixel à partir d'une valeur 32 bits (0xRRGGBB).
     * @param index Indice du pixel (0 à count-1)
     * @param color Couleur au format 0xRRGGBB
     */
    void setPixel(uint16_t index, uint32_t color);

    /**
     * @brief Éteint tous les pixels du bandeau (noir).
     */
    void clear();

    // Luminosité globale
    /**
     * @brief Règle la luminosité globale du bandeau.
     * @param brightness Luminosité (0 = éteint, 255 = maximum)
     */
    void setBrightness(uint8_t brightness);

    // Effets
    /**
     * @brief Démarre un effet arc-en-ciel animé et non bloquant.
     * @param speed Délai entre 2 pas de l'animation, en ms (défaut: 10)
     * @note Nécessite des appels réguliers à update() pour progresser.
     */
    void startRainbow(uint16_t speed = 10);

    /**
     * @brief Arrête l'effet arc-en-ciel en cours.
     */
    void stopRainbow();

    /**
     * @brief Lance un fondu progressif et non bloquant vers une couleur cible.
     * @param r Composante rouge cible (0-255)
     * @param g Composante verte cible (0-255)
     * @param b Composante bleue cible (0-255)
     * @param duration Durée totale du fondu, en ms
     * @note Nécessite des appels réguliers à update() pour progresser.
     */
    void smoothToColor(uint8_t r, uint8_t g, uint8_t b, uint16_t duration);



private:
    Adafruit_NeoPixel _strip;

    // === Rainbow ===
    bool _rainbowActive = false;
    uint16_t _rainbowOffset = 0;
    uint16_t _rainbowSpeed = 10;
    unsigned long _lastRainbowUpdate = 0;

    // === Smooth Fade ===
    bool _fadeActive = false;
    uint32_t _fadeStartColor;
    uint32_t _fadeTargetColor;
    unsigned long _fadeStartTime;
    uint16_t _fadeDuration;

    /// Convertit une position (0-255) en une couleur de la roue chromatique (utilisé par l'effet rainbow)
    uint32_t wheel(uint8_t pos);
    /// Interpolation linéaire entre deux valeurs d'octet, pour une fraction t (0.0 à 1.0)
    uint8_t lerp(uint8_t a, uint8_t b, float t);
};

} // namespace crepp::drivers