FSPersistence.h

#ifndef FSPersistence_h
#define FSPersistence_h

#include <StatefulService.h>
#include <FS.h>

template <class T>
class FSPersistence {
 public:
  FSPersistence(JsonStateReader<T> stateReader,
                JsonStateUpdater<T> stateUpdater,
                StatefulService<T>* statefulService,
                FS* fs,
                const char* filePath,
                size_t bufferSize = DEFAULT_BUFFER_SIZE) :
      _stateReader(stateReader),
      _stateUpdater(stateUpdater),
      _statefulService(statefulService),
      _fs(fs),
      _filePath(filePath),
      _bufferSize(bufferSize),
      _updateHandlerId(0) {
    enableUpdateHandler();
  }

  void readFromFS() {
    File settingsFile = _fs->open(_filePath, "r");

    if (settingsFile) {
      DynamicJsonDocument jsonDocument = DynamicJsonDocument(_bufferSize);
      DeserializationError error = deserializeJson(jsonDocument, settingsFile);
      if (error == DeserializationError::Ok && jsonDocument.is<JsonObject>()) {
        JsonObject jsonObject = jsonDocument.as<JsonObject>();
        _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
        settingsFile.close();
        return;
      }
      settingsFile.close();
    }

    // If we reach here we have not been successful in loading the config and hard-coded defaults are now applied.
    // The settings are then written back to the file system so the defaults persist between resets. This last step is
    // required as in some cases defaults contain randomly generated values which would otherwise be modified on reset.
    applyDefaults();
    writeToFS();
  }

  //     void readFromFS() {
  //     File settingsFile = _fs->open(_filePath, "r");

  //     if (!settingsFile) {
  //         Serial.println("Failed to open settings file for reading");
  //     } else {
  //         DynamicJsonDocument jsonDocument(_bufferSize);
  //         DeserializationError error = deserializeJson(jsonDocument, settingsFile);
  //         if (error) {
  //             Serial.print("Failed to deserialize JSON: ");
  //             Serial.println(error.c_str());
  //         } else {
  //             Serial.println("JSON Deserialized successfully:");
  //             serializeJsonPretty(jsonDocument, Serial);  // Print the JSON data to the serial port in a pretty
  //             format

  //             if (jsonDocument.is<JsonObject>()) {
  //                 JsonObject jsonObject = jsonDocument.as<JsonObject>();
  //                 _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
  //             } else {
  //                 Serial.println("JSON is not an object");
  //             }
  //         }
  //         settingsFile.close();
  //     }

  //     // If we reach here we have not been successful in loading the config
  //     Serial.println("Applying defaults and writing them to FS.");
  //     applyDefaults();
  //     writeToFS();
  // }

  bool writeToFS() {
    // create and populate a new json object
    DynamicJsonDocument jsonDocument = DynamicJsonDocument(_bufferSize);
    JsonObject jsonObject = jsonDocument.to<JsonObject>();
    _statefulService->read(jsonObject, _stateReader);

    // make directories if required
    mkdirs();

    // serialize it to filesystem
    File settingsFile = _fs->open(_filePath, "w");

    // failed to open file, return false
    if (!settingsFile) {
      return false;
    }

    // serialize the data to the file
    serializeJson(jsonDocument, settingsFile);
    settingsFile.close();
    return true;
  }

  void disableUpdateHandler() {
    if (_updateHandlerId) {
      _statefulService->removeUpdateHandler(_updateHandlerId);
      _updateHandlerId = 0;
    }
  }

  void enableUpdateHandler() {
    if (!_updateHandlerId) {
      _updateHandlerId = _statefulService->addUpdateHandler([&](const String& originId) { writeToFS(); });
    }
  }

 private:
  JsonStateReader<T> _stateReader;
  JsonStateUpdater<T> _stateUpdater;
  StatefulService<T>* _statefulService;
  FS* _fs;
  const char* _filePath;
  size_t _bufferSize;
  update_handler_id_t _updateHandlerId;

  // We assume we have a _filePath with format "/directory1/directory2/filename"
  // We create a directory for each missing parent
  void mkdirs() {
    String path(_filePath);
    int index = 0;
    while ((index = path.indexOf('/', index + 1)) != -1) {
      String segment = path.substring(0, index);
      if (!_fs->exists(segment)) {
        _fs->mkdir(segment);
      }
    }
  }

 protected:
  // We assume the updater supplies sensible defaults if an empty object
  // is supplied, this virtual function allows that to be changed.
  virtual void applyDefaults() {
    DynamicJsonDocument jsonDocument = DynamicJsonDocument(_bufferSize);
    JsonObject jsonObject = jsonDocument.as<JsonObject>();
    _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
  }
};

#endif  // end FSPersistence