FakeGatoHistoryService.cpp

/*
 Copyright (c) 2025 David Carson (dacarson)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

 Based on Eve History Protocol documented here:
 https://github.com/An00bIS47/Homekit/blob/3908e0799cc9fae23791c562420145f8f8491269/docs/eve/Elgato-Eve-History-Protocol.md
 and Eve History implementation here:
 https://github.com/simont77/fakegato-history
 */

#define CUSTOM_CHAR_HEADER
#include "FakeGatoHistoryService.h"

#define LOG_ENTRY_FREQ_TEN_MIN 600000
#define LOG_ENTRY_FREQ_ONE_MIN  60000
#define HISTORY_FILE "/history.bin"

FakeGatoHistoryService::FakeGatoHistoryService() 
  : Service::FakeGatoHistoryData(), logInterval(LOG_ENTRY_FREQ_TEN_MIN) {
    Serial.println(F("Configuring Eve History Service"));

    if (!LittleFS.begin(true)) {
      Serial.println("LittleFS Mount Failed");
    }

    memset(&historyStatusData, 0, sizeof(HistoryStatusData));
    historyStatusData.status.paramCount = 0x5;
    uint8_t tempSignature[10] = {0x01, 0x02, 0x11, 0x02, 0x10, 0x01, 0x12, 0x01, 0x1D, 0x01};
    memcpy(historyStatusData.status.signature, tempSignature, sizeof(tempSignature));
    uint16_t memSize = store.historySize;
    memcpy(&historyStatusData.raw_data[25], &memSize, sizeof(uint16_t));
    historyStatusData.raw_data[35] = 0x01;
    historyStatusData.raw_data[36] = 0x01;

    if (loadHistory()) {
        Serial.println("Restored History from file");
        // Validate the refTime and correct if necessary
        time_t currentRefTime = store.refTime + EPOCH_OFFSET;
        struct tm *gmtTime = gmtime(&currentRefTime);
        //Serial.printf("refTime %s\n", asctime(gmtTime));
        if (gmtTime->tm_year+1900 < 2025) {
          Serial.printf("Bad refTime, attempting repair %s", asctime(gmtTime));

          // Calculate starting entry based on length
          int firstEntry = store.firstEntry;
          int lastEntry = store.lastEntry;
          int startEntry = max(lastEntry, firstEntry);
  
          // Find the oldest valid timestamp, and use that for refTime
          for (int i = startEntry; i <= lastEntry; i++) { 
            auto entry = store.history[i % store.historySize];
            time_t val = entry.time;
            struct tm *timeinfo = gmtime(&val);
            if (timeinfo->tm_year + 1900 >= 2025) {
              store.refTime = entry.time - EPOCH_OFFSET;

              currentRefTime = store.refTime + EPOCH_OFFSET;
              gmtTime = gmtime(&currentRefTime);
              Serial.printf("Set refTime to (GMT) %s", asctime(gmtTime));
            }
          }
        }

    } else {
        Serial.println("Failed to restore History from file, using empty history.");
    }

    updateAndSetHistoryStatus();
    historyEntries.setData(0, 0);
}

void FakeGatoHistoryService::accumulateLogEntry(float currentTemp, float targetTemp, uint8_t valvePercent, uint8_t thermoTarget, uint8_t openWindow) {
    bool isDuplicate = ((uint16_t)(currentTemp * 100) == previousEntry.currentTemp &&
                        (uint16_t)(targetTemp * 100) == previousEntry.targetTemp &&
                        valvePercent == previousEntry.valvePercent &&
                        thermoTarget == previousEntry.thermoTarget &&
                        openWindow == previousEntry.openWindow);

    // Store current values for next duplicate check
    previousEntry.currentTemp = (uint16_t)(currentTemp * 100);
    previousEntry.targetTemp = (uint16_t)(targetTemp * 100);
    previousEntry.valvePercent = valvePercent;
    previousEntry.thermoTarget = thermoTarget;
    previousEntry.openWindow = openWindow;

    // Check if this is the first entry
    if (!store.lastEntry || store.history[store.lastEntry % store.historySize].time == 0) {
        addHistoryEntry(currentTemp, targetTemp, valvePercent, thermoTarget, openWindow);
        return;
    }

    // Check if key values changed
    bool keyValueChanged = ((uint16_t)(targetTemp * 100) != store.history[store.lastEntry % store.historySize].targetTemp ||
                           thermoTarget != store.history[store.lastEntry % store.historySize].thermoTarget ||
                           valvePercent > 0);

    // If key values changed, check if enough time has passed since last entry
    if (keyValueChanged) {
        time_t now = time(nullptr);
        time_t lastEntryTime = store.history[store.lastEntry % store.historySize].time;
        
        // Only log if enough time has passed (at least 1 minute)
        if (now - lastEntryTime >= 60) {
            // If we have accumulated data, log it first
            if (avgLog.count > 0) {
                generateTimedHistoryEntry();
            }
            // Log the new state immediately
            addHistoryEntry(currentTemp, targetTemp, valvePercent, thermoTarget, openWindow);
            
            // Switch to 1-minute logging if valve is open
            if (valvePercent > 0 && logInterval == LOG_ENTRY_FREQ_TEN_MIN) {
                logInterval = LOG_ENTRY_FREQ_ONE_MIN;
            }
            return;
        }
    }

    // Ignore duplicates after giving key-change timing logic a chance to log.
    if (isDuplicate) {
        return;
    }

    // If valve closed and in 1-minute mode, switch back to 10-minute mode
    if (valvePercent == 0 && logInterval == LOG_ENTRY_FREQ_ONE_MIN) {
        logInterval = LOG_ENTRY_FREQ_TEN_MIN;
    }

    // Accumulate data for time-based logging
    avgLog.totalTemp += currentTemp;
    avgLog.totalTargetTemp += targetTemp;
    avgLog.totalValvePos += valvePercent;
    avgLog.lastThermoTarget = thermoTarget;
    avgLog.lastOpenWindow = openWindow;
    avgLog.count++;
}

void FakeGatoHistoryService::generateTimedHistoryEntry() {
    if (avgLog.count > 0) {
        // Calculate averages for time-based entries
        float avgTemp = avgLog.totalTemp / avgLog.count;
        float avgTargetTemp = avgLog.totalTargetTemp / avgLog.count;
        uint8_t avgValvePos = avgLog.totalValvePos / avgLog.count;
        
        // Use the last values for thermoTarget and openWindow since they are state values
        addHistoryEntry(avgTemp, avgTargetTemp, avgValvePos, avgLog.lastThermoTarget, avgLog.lastOpenWindow);
    } else if (store.lastEntry && store.history[store.lastEntry % store.historySize].time != 0) {
        // If no accumulated data but we have a previous entry, copy it
        float avgTemp = store.history[store.lastEntry % store.historySize].currentTemp / 100.0;
        float avgTargetTemp = store.history[store.lastEntry % store.historySize].targetTemp / 100.0;
        uint8_t avgValvePos = store.history[store.lastEntry % store.historySize].valvePercent;
        uint8_t thermoTarget = store.history[store.lastEntry % store.historySize].thermoTarget;
        uint8_t openWindow = store.history[store.lastEntry % store.historySize].openWindow;
        addHistoryEntry(avgTemp, avgTargetTemp, avgValvePos, thermoTarget, openWindow);
    }
    
    // Reset accumulation for next interval
    avgLog.totalTemp = 0;
    avgLog.totalTargetTemp = 0;
    avgLog.totalValvePos = 0;
    avgLog.lastThermoTarget = 0;
    avgLog.lastOpenWindow = 0;
    avgLog.count = 0;

    updateAndSetHistoryStatus();
}

void FakeGatoHistoryService::addHistoryEntry(float currentTemp, float targetTemp, uint8_t valvePercent, uint8_t thermoTarget, uint8_t openWindow) {
    if (store.usedMemory < store.historySize) {
      store.usedMemory++;
      store.firstEntry = 0;
      store.lastEntry = store.usedMemory;
    } else {
      store.firstEntry++;
      store.lastEntry = store.firstEntry + store.usedMemory;
      if (restarted) {
        store.history[store.lastEntry % store.historySize].time = 0; // send a store.refTime 0x81 history entry
        store.firstEntry++;
        store.lastEntry = store.firstEntry + store.usedMemory;
        restarted = false;
      }
    }
    
    if (store.refTime == 0) {
      store.refTime =  time(nullptr) - EPOCH_OFFSET;
      store.history[store.lastEntry % store.historySize].time = 0; // send a store.refTime 0x81 history entry
      store.lastEntry++;
      store.usedMemory++;
    }
    
    store.history[store.lastEntry % store.historySize].time = time(nullptr);
    store.history[store.lastEntry % store.historySize].currentTemp = (uint16_t)(currentTemp * 100);
    store.history[store.lastEntry % store.historySize].targetTemp = (uint16_t)(targetTemp * 100);
    store.history[store.lastEntry % store.historySize].valvePercent = valvePercent;
    store.history[store.lastEntry % store.historySize].thermoTarget = thermoTarget;
    store.history[store.lastEntry % store.historySize].openWindow = openWindow;

    saveHistory();
    
}

void FakeGatoHistoryService::printData(uint8_t *data, int len) {
  Serial.printf(F("Data %d "), len);
  for (int i = 0; i < len; i++) {
    if (data[i] < 0x10)
        Serial.printf(F("0%x "), data[i]);
    else
      Serial.printf(F("%x "), data[i]);
  }
  Serial.println("");
}

bool FakeGatoHistoryService::saveHistory() {
    File file = LittleFS.open(HISTORY_FILE, "w");
    if (!file) return false;
    size_t written = file.write((uint8_t*)&store, sizeof(PersistHistoryData));
    file.close();
    return written == sizeof(PersistHistoryData);
}

bool FakeGatoHistoryService::loadHistory() {
    File file = LittleFS.open(HISTORY_FILE, "r");
    if (!file) return false;
    size_t readBytes = file.read((uint8_t*)&store, sizeof(PersistHistoryData));
    file.close();
    return readBytes == sizeof(PersistHistoryData);
}

void FakeGatoHistoryService::eraseHistory() {
      memset((uint8_t*)&store, 0, sizeof(PersistHistoryData));
      saveHistory();
      Serial.println("History data erased");
  }

  void FakeGatoHistoryService::sendHistory(uint32_t currentEntry) {
    if (currentEntry == 0)
        currentEntry = 1;
    
    uint8_t historySendBuffer[256];  // 11 entries max (10 data + 1 time ref) × 21 bytes = 231 bytes worst case
    int sendBufferLen = 0;
    
    //WEBLOG("Send History currentEntry %d store.lastEntry %d\n", currentEntry, store.lastEntry);
    if (currentEntry <= store.lastEntry) {
      uint32_t memoryAddress = currentEntry % store.historySize;
      
      // Build up the history send buffer
      for (int i = 0; i < 11; i++) {
        Serial.printf(F("MemoryAddress %d\n"), memoryAddress);
        if ((store.history[memoryAddress].time == 0) || (sendTime) || currentEntry == store.firstEntry + 1) { // Its a store.refTime entry or we need to set the time
          Serial.println(F("Sending special Ref Time history entry"));
          uint8_t refEntry[21];
          memset(refEntry, 0, 21);
          refEntry[0] = 21; // entry length
          memcpy(&refEntry[1], &currentEntry, sizeof(uint32_t)); // Current Entry
          refEntry[5] = 0x1; // Secs since reference time set
          refEntry[9] = 0x81;
          memcpy(&refEntry[10], &store.refTime, sizeof(uint32_t));
          
          sendTime = false;
          memcpy(&historySendBuffer[sendBufferLen], &refEntry, 21);
          sendBufferLen += 21;
        } else {
          uint8_t dataEntry[17];
          dataEntry[0] = 17; // entry length
          memcpy(&dataEntry[1], &currentEntry, sizeof(uint32_t));
          // Don't allow negative offsets as the variable is unsigned.
          uint32_t refOffset = 0;
          if ((store.history[memoryAddress].time - EPOCH_OFFSET) >=  store.refTime) {
            refOffset = (store.history[memoryAddress].time - EPOCH_OFFSET) - store.refTime;
          } else {
            time_t currentRefTime = store.refTime + EPOCH_OFFSET;
            struct tm *gmtTime = gmtime(&currentRefTime);
            Serial.printf("Bad - negative history data Offset %u refTime %u %s\n", (store.history[memoryAddress].time - EPOCH_OFFSET), store.refTime, asctime(gmtTime));
          }
          memcpy(&dataEntry[5], &refOffset, sizeof(uint32_t));
          dataEntry[9] = 0x1f;
          memcpy(&dataEntry[10], &store.history[memoryAddress].currentTemp, sizeof(uint16_t));
          memcpy(&dataEntry[12], &store.history[memoryAddress].targetTemp, sizeof(uint16_t));
          dataEntry[14] = store.history[memoryAddress].valvePercent;
          dataEntry[15] = store.history[memoryAddress].thermoTarget;
          dataEntry[16] = store.history[memoryAddress].openWindow;
          memcpy(&historySendBuffer[sendBufferLen], &dataEntry, 17);
          sendBufferLen += 17;
        }
        currentEntry++;
        memoryAddress = currentEntry % store.historySize;
        if (currentEntry > store.lastEntry)
            break;
      }
      Serial.println(F("Sending History"));
      printData(historySendBuffer, sendBufferLen);
      historyEntries.setData(historySendBuffer, sendBufferLen);
    } else {
      Serial.println(F("No History To Send"));
      historyEntries.setData(0, 0);
    }
  }

void FakeGatoHistoryService::updateAndSetHistoryStatus() {
    historyStatusData.status.timeSinceLastUpdate = (time(nullptr) - EPOCH_OFFSET) - store.refTime;
    historyStatusData.status.refTime = time(nullptr) < EPOCH_OFFSET ? 0 : store.refTime;
    
    uint16_t uMem = store.usedMemory < store.historySize ? store.usedMemory + 1 : store.usedMemory;
    memcpy(&historyStatusData.raw_data[23], &uMem, sizeof(uint16_t));
    uint32_t first = store.usedMemory < store.historySize ? store.firstEntry : store.firstEntry + 1;
    memcpy(&historyStatusData.raw_data[27], &first, sizeof(uint32_t));
    
    Serial.printf(F("Updating History Status store.usedMemory %d store.lastEntry %d\n"), store.usedMemory, store.lastEntry);
    //printData(historyStatusData.raw_data, sizeof(historyStatusData.raw_data));
    
    // Don't notify everytime history is updated, causes un-neccesary noise. Eve app will fetch it when it wants it.
    historyStatus.setData(historyStatusData.raw_data, sizeof(historyStatusData.raw_data), false);
}

void FakeGatoHistoryService::loop() {
    if (historyStatus.timeVal() >= logInterval) {
      Serial.printf("Triggering HistoryEntry creation timeVal:%u\n", historyStatus.timeVal());
      generateTimedHistoryEntry();
    }
}

boolean FakeGatoHistoryService::update() {
    
    if (historyRequest.updated()) {
      int len = historyRequest.getNewData(0, 0);
      uint8_t* data = new uint8_t[len];
      historyRequest.getNewData(data, len);
      uint32_t address = *(uint32_t*)&data[2];
      
      Serial.printf(F("History Service Request %d\n"), address);
      sendHistory(address);
      delete[] data;
    }
    
    if (setTime.updated()) {
      int len = setTime.getNewData(0, 0);
      uint8_t* data = new uint8_t[len];
      setTime.getNewData(data, len);
      Serial.print(F("History Service Set Time (LocalTime) "));
      uint32_t eveTimestamp = *(uint32_t*)data;
      delete[] data;
      
      time_t currentTime = eveTimestamp + EPOCH_OFFSET;  // Convert to Unix timestamp (since 1970)
      
      struct tm *timeInfo = localtime(&currentTime);          // Convert to time structure
      Serial.printf(F("%02d:%02d %02d/%02d/%04d\n"),
              timeInfo->tm_hour, timeInfo->tm_min,
              timeInfo->tm_mon + 1, timeInfo->tm_mday,  // tm_mon is 0-based
              timeInfo->tm_year + 1900);               // tm_year is years since 1900
      
      uint32_t before = time(nullptr);

      Serial.print(F("Checking the clock. Before: "));
      Serial.print(before);
      Serial.print(F(", After: "));
      Serial.print(currentTime);
      Serial.print(F(", Elapsed: "));
      Serial.println(currentTime - before);

      if (currentTime - before > 5) {
        Serial.println(F("Updating local clock"));
        
        // set the clock
        struct timeval tv;
        tv.tv_sec = currentTime;
        tv.tv_usec = 0;
        settimeofday(&tv, NULL);

        // Check to see if the reference time was set, but the clock had not been set yet.
        // If so, then we need to correct it
        if (store.refTime != 0 && store.refTime > currentTime ) {
          Serial.printf(F("Fixing refTime %u to %u\n"), store.refTime, eveTimestamp);
          store.refTime = eveTimestamp - (store.refTime + EPOCH_OFFSET);
          Serial.printf(F("Fixed refTime %u\n"), store.refTime);

          // Fix up history entries
          for (int i = 1; i <= store.lastEntry; i++) {
            if (store.history[i].time != 0) { // Skip store.refTime 0x81 history entries
              //Serial.printf("Fixing history entry %d from %u to %u\n", i, store.history[i].time, store.history[i].time + currentTime - before);
              store.history[i].time += (currentTime - before);
            }
          }
        }
      }
      updateAndSetHistoryStatus();
    }
    
    return true;
  }