system-control/components/insa/include/common/IPersistenceManager.h

#pragma once

#include <string>
#include <type_traits>

/**
 * @interface IPersistenceManager
 * @brief Abstract interface for platform-independent persistence management
 * @details This interface defines the contract for key-value storage and retrieval
 *          systems across different platforms (Desktop/SDL3 and ESP32).
 */
class IPersistenceManager
{
public:
    virtual ~IPersistenceManager() = default;

    /**
     * @brief Template methods for type-safe setting and retrieving of values
     * @tparam T The type of value to set (must be one of: bool, int, float, double, std::string)
     * @param key The key to associate with the value
     * @param value The value to store
     */
    template<typename T>
    void SetValue(const std::string& key, const T& value) {
        static_assert(std::is_same_v<T, bool> || 
                     std::is_same_v<T, int> || 
                     std::is_same_v<T, float> || 
                     std::is_same_v<T, double> || 
                     std::is_same_v<T, std::string>,
                     "Unsupported type for IPersistenceManager");
        SetValueImpl(key, value);
    }

    /**
     * @brief Template method for type-safe retrieval of values
     * @tparam T The type of value to retrieve
     * @param key The key to look up
     * @param defaultValue The default value to return if key is not found
     * @return The stored value or default value if key doesn't exist
     */
    template<typename T>
    T GetValue(const std::string& key, const T& defaultValue = T{}) const {
        return GetValueImpl<T>(key, defaultValue);
    }

    /**
     * @brief Convenience methods for setting specific types
     */
    void SetBool(const std::string& key, bool value) { SetValue(key, value); }
    void SetInt(const std::string& key, int value) { SetValue(key, value); }
    void SetFloat(const std::string& key, float value) { SetValue(key, value); }
    void SetDouble(const std::string& key, double value) { SetValue(key, value); }
    void SetString(const std::string& key, const std::string& value) { SetValue(key, value); }

    /**
     * @brief Convenience methods for getting specific types with default values
     */
    bool GetBool(const std::string& key, bool defaultValue = false) const { 
        return GetValue(key, defaultValue); 
    }
    int GetInt(const std::string& key, int defaultValue = 0) const { 
        return GetValue(key, defaultValue); 
    }
    float GetFloat(const std::string& key, float defaultValue = 0.0f) const { 
        return GetValue(key, defaultValue); 
    }
    double GetDouble(const std::string& key, double defaultValue = 0.0) const { 
        return GetValue(key, defaultValue); 
    }
    std::string GetString(const std::string& key, const std::string& defaultValue = "") const { 
        return GetValue(key, defaultValue); 
    }

    /**
     * @brief Utility methods for key management
     */
    virtual bool HasKey(const std::string& key) const = 0; ///< Check if a key exists
    virtual void RemoveKey(const std::string& key) = 0; ///< Remove a key-value pair
    virtual void Clear() = 0; ///< Clear all stored data
    virtual size_t GetKeyCount() const = 0; ///< Get the number of stored keys

    /**
     * @brief Persistence operations
     */
    virtual bool Save() = 0; ///< Save data to persistent storage
    virtual bool Load() = 0; ///< Load data from persistent storage

protected:
    /**
     * @brief Template-specific implementations that must be overridden by derived classes
     * @details These methods handle the actual storage and retrieval of different data types
     */
    virtual void SetValueImpl(const std::string& key, bool value) = 0;
    virtual void SetValueImpl(const std::string& key, int value) = 0;
    virtual void SetValueImpl(const std::string& key, float value) = 0;
    virtual void SetValueImpl(const std::string& key, double value) = 0;
    virtual void SetValueImpl(const std::string& key, const std::string& value) = 0;

    virtual bool GetValueImpl(const std::string& key, bool defaultValue) const = 0;
    virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
    virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
    virtual double GetValueImpl(const std::string& key, double defaultValue) const = 0;
    virtual std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const = 0;

private:
    /**
     * @brief Template dispatch methods for type-safe value retrieval
     * @tparam T The type to retrieve
     * @param key The key to look up
     * @param defaultValue The default value to return
     * @return The retrieved value or default if not found
     */
    template<typename T>
    T GetValueImpl(const std::string& key, const T& defaultValue) const
    {
        if constexpr (std::is_same_v<T, bool>) {
            return GetValueImpl(key, defaultValue);
        } else if constexpr (std::is_same_v<T, int>) {
            return GetValueImpl(key, defaultValue);
        } else if constexpr (std::is_same_v<T, float>) {
            return GetValueImpl(key, defaultValue);
        } else if constexpr (std::is_same_v<T, double>) {
            return GetValueImpl(key, defaultValue);
        } else if constexpr (std::is_same_v<T, std::string>) {
            return GetValueImpl(key, defaultValue);
        } else {
            static_assert(std::is_same_v<T, bool> || 
                         std::is_same_v<T, int> || 
                         std::is_same_v<T, float> || 
                         std::is_same_v<T, double> || 
                         std::is_same_v<T, std::string>,
                         "Unsupported type for IPersistenceManager");
            return defaultValue; // This line will never be reached, but satisfies compiler
        }
    }
};