begin(115200);;
println("Erreur d'initialisation de la carte SD !");;
while (1);;
println("Carte SD prête.");;
readFile("/log.txt");;
println(content);;
delay(5000);;

                    

            return _status;
File _readFile;

                    

        #pragma once

#include <Arduino.h>
#include "../StatusDevice.h"
#include <SD.h>
#include <SPI.h>

namespace crepp::data {

/**
 * @class DataStorage
 * @brief Gestion du stockage sur carte SD via SPI (Pico 2W)
 *
 * Cette classe encapsule l'accès à une carte SD (lecture, écriture,
 * suppression de fichiers, listage de répertoire).
 *
 * L'initialisation est volontairement séparée de la construction
 * afin de laisser le contrôle total à l'utilisateur.
 *
 * Brochage SPI par défaut pour le Pico 2W :
 *   - MISO : GPIO 16
 *   - MOSI : GPIO 19
 *   - SCK  : GPIO 18
 *   - CS   : GPIO 17 (configurable)
 *
 * @badge tool
 * @badge stable
 */
class DataStorage
{

public:
    /**
     * @brief Constructeur
     *
     * La carte SD n'est pas initialisée ici.
     */
    DataStorage();

    /**
     * @brief Destructeur
     */
    ~DataStorage() = default;

    /**
     * @brief Initialise la carte SD avec configuration SPI explicite (requis sur Pico 2W)
     * @param csPin   Broche Chip Select (CS/SS) du module SD (défaut : 17)
     * @param misoPin Broche MISO (défaut : 16)
     * @param mosiPin Broche MOSI (défaut : 19)
     * @param sckPin  Broche SCK  (défaut : 18)
     * @return true si l'initialisation réussit, false sinon
     */
    bool begin(uint8_t csPin   = 17,
               uint8_t misoPin = 16,
               uint8_t mosiPin = 19,
               uint8_t sckPin  = 18);

    /**
     * @brief Écrit une ligne dans un fichier (crée le fichier si inexistant)
     * @param filename Chemin du fichier (ex: "/data.txt")
     * @param data     Données à écrire
     * @param append   true = ajoute à la fin, false = écrase le fichier
     * @return true si l'écriture réussit
     */
    bool writeLine(const String &filename, const String &data, bool append = true);

    /**
     * @brief Lit l'intégralité d'un fichier
     * @param filename Chemin du fichier
     * @return Contenu du fichier, chaîne vide si erreur
     */
    String readFile(const String &filename) const;

    /**
     * @brief Lit la prochaine ligne non lue d'un fichier
     * @param filename Chemin du fichier
     * @param line     Ligne lue en sortie
     * @return true si une ligne a été lue, false si fin de fichier ou erreur
     */
    bool readLine(const String &filename, String &line);

    /**
     * @brief Supprime un fichier
     * @param filename Chemin du fichier
     * @return true si la suppression réussit
     */
    bool removeFile(const String &filename);

    /**
     * @brief Vérifie si un fichier existe
     * @param filename Chemin du fichier
     * @return true si le fichier existe
     */
    bool exists(const String &filename) const;

    /**
     * @brief Retourne la taille d'un fichier en octets
     * @param filename Chemin du fichier
     * @return Taille en octets, -1 si erreur
     */
    int32_t fileSize(const String &filename) const;

    /**
     * @brief Liste les fichiers d'un répertoire
     * @param path Chemin du répertoire (ex: "/")
     * @return Chaîne formatée avec la liste des fichiers
     */
    String listDir(const String &path = "/") const;

    /**
     * @brief Crée un répertoire
     * @param path Chemin du répertoire à créer
     * @return true si la création réussit
     */
    bool mkdir(const String &path);

    /**
     * @brief Retourne l'espace total de la carte en octets
     * @return Espace total en octets
     */
    uint64_t totalBytes() const;

    /**
     * @brief Retourne l'espace utilisé en octets
     * @return Espace utilisé en octets
     */
    uint64_t usedBytes() const;

    /**
     * @brief Retourne l'état de la carte SD.
     * @return DEVICE_OK si begin() a réussi, DEVICE_ERROR_INIT sinon.
     */
    StatusDevice getStatus() const { return _status; }

private:
    bool     _initialized = false;
    uint8_t  _csPin       = 22;

    // Instance SPI dédiée pour le Pico 2W (SPI1 sur les pins 16-19)
    SPIClassRP2040 *_spi = nullptr;

    // Fichier ouvert en lecture séquentielle (readLine)
    mutable File _readFile;
    mutable String _readFilename = "";

    StatusDevice _status = StatusDevice::DEVICE_ERROR_INIT;
};

/*
@example

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

@macro
// Brochage SPI1 sur Pico 2W
#define SD_CS_PIN   17
#define SD_MISO_PIN 16
#define SD_MOSI_PIN 19
#define SD_SCK_PIN  18
@end_macro

@instance
crepp::data::DataStorage storage;
@end_instance

@isr
@end_isr

@function
@end_function

@setup
  Serial.begin(115200);
  if (!storage.begin(SD_CS_PIN, SD_MISO_PIN, SD_MOSI_PIN, SD_SCK_PIN)) {
      Serial.println("Erreur d'initialisation de la carte SD !");
      while (1);
  }
  Serial.println("Carte SD prête.");
  Serial.println(storage.listDir("/"));
@end_setup

@loop
  storage.writeLine("/log.txt", "température: " + String(25.3) + " °C");
  String content = storage.readFile("/log.txt");
  Serial.println(content);
  delay(5000);
@end_loop

@end_example
*/

} // namespace crepp::data