PersistentSetting.h

#pragma once

#include <Arduino.h>
#include <MutilaDebug.h>
#include <stdint.h>
#include <EEPROM.h>

extern uint16_t PersistentSettingOffset;

template <class T>
class PersistentSetting {
public:
    PersistentSetting(T minimum, T maximum, T defaultValue, uint8_t copies=1, int32_t eepromOffset=-1) : 
        _eepromOffset(eepromOffset),
        _copies(copies),
        _minimum(minimum),
        _maximum(maximum),
        _defaultValue(defaultValue)
    {
        if (eepromOffset < 0) {
            _eepromOffset = PersistentSettingOffset;
        } else {
            _eepromOffset = eepromOffset;
        }
        PersistentSettingOffset = _eepromOffset + size();
        this->load();
    }

    bool isValid(T v) {
        return v >= _minimum && v <= _maximum;
    }

    void reset(bool saveIt=false) {
        _value = _defaultValue;
        if (saveIt) {
            save();
        }
    }

    T getValueAt(uint16_t address) {
#if defined(ESP8266) or defined(ESP32)
#warning ESP EEPROM functionality not yet implemented
#else
        T value;
        for (uint8_t i=0; i<sizeof(T); i++) {
            *((uint8_t*)&value+i) = EEPROM.read(address+i);
        }
        return value;
#endif
    }

    uint16_t counterOffset(uint8_t idx) {
        return _eepromOffset + ((uint16_t)idx * (sizeof(T) + sizeof(uint8_t)));
    }

    uint16_t dataOffset(uint8_t idx) {
        return counterOffset(idx) + (_copies < 2 ? 0 : 1);
    }

    uint8_t getCurrentIdx() {
#if defined(ESP8266) or defined(ESP32)
#warning ESP EEPROM functionality not yet implemented
#else
        uint8_t i = 0;
        for (uint8_t thisCount = EEPROM.read(counterOffset(i)); 
             i < _copies; 
             i++) {
            uint8_t nextCount = EEPROM.read(counterOffset((i+1)%_copies));
            if ((uint8_t)(nextCount - thisCount) != 1) {
                return i;
            }
            thisCount = nextCount;
        }
        return 0;
#endif
    }

    T load() {
        // work out in which wear-levelling slot the last value was written
        uint8_t idx = getCurrentIdx();
        _value = getValueAt(dataOffset(idx));
        if (!isValid(_value)) {
            _value = _defaultValue;
        }
        return _value;
    }

    void save()
    {
#if defined(ESP8266) or defined(ESP32)
#warning ESP EEPROM functionality not yet implemented
#else
        uint8_t idx = getCurrentIdx();
        if (getValueAt(dataOffset(idx)) == _value) {
            return;
        }

        uint16_t address;
        if (_copies < 2) {
            // no wear levelling counters or any of that stuff, just a value
            address = _eepromOffset;
        } else {
            // handle wear levelling
            uint8_t counter = EEPROM.read(counterOffset(idx)); 
            idx = (idx + 1) % _copies;
            ++counter;
            address = counterOffset(idx);
            EEPROM.update(address++, counter);
        }

        //DB(F(" EEPROM write at: "));
        //DBLN(address);
        for (uint8_t i=0; i<sizeof(T); i++) {
            EEPROM.update(address++, *((uint8_t*)&_value+i));
        }
#endif
    }

    T get() { return _value; }

    T getMinimum() { return _minimum; }

    T getMaximum() { return _maximum; }

    T getDefault() { return _defaultValue; }

    T operator=(T v) { if (isValid(v)) { _value = v; } return _value; }

    bool set(T v, bool saveIt=false) { 
        if (isValid(v)) { 
            _value = v; 
            if (saveIt) { 
                save();
            } 
            return true; 
        } else { 
            return false; 
        } 
    }

    uint16_t size() { 
        if (_copies < 2) { 
            /* when we only have 1 instance, we don't store counters at all, just the value. */
            return sizeof(T); 
        } else { 
            /* we have one counter byte + one data item per wear-level instance. */
            return ( sizeof(uint8_t) + sizeof(T) ) * _copies;
        }
    }

    void dump() {
        DB(F("off=0x"));
        DB(_eepromOffset, HEX);
        DB(F(" sz="));
        DB(size());
        DB(F(" min="));
        DB(_minimum);
        DB(F(" max="));
        DB(_maximum);
        DB(F(" val="));
        DBLN(_value);
    }

private:
    uint16_t _eepromOffset;
    uint8_t _copies;

protected:
    T _value;
    T _minimum;
    T _maximum;
    T _defaultValue;
};

/* Sometimes it is nice to have a name attached to a PersistentSetting, but the String
 * class is a little heavy for many sketches. NamedPersistentSetting adds a name for
 * a PersistentSetting, with the accociated overhead, so only use this if you need the 
 * name.
 */
template <class T>
class NamedPersistentSetting : public PersistentSetting<T> {
public:
    NamedPersistentSetting(T minimum, T maximum, T defaultValue, const char* name, uint8_t copies=1, int32_t eepromOffset=-1) :
        PersistentSetting<T>(minimum, maximum, defaultValue, copies, eepromOffset),
        _name(name) {
    }

    const String& getName() { return _name; }
    void dump() {
        DB(_name);
        DB(": ");
        PersistentSetting<T>::dump();
    }

private:
    String _name;
};