FacePlant/src/app/App.cpp

#include "App.h"

#include "../util/Version.h"
#include "../util/BootTrigger.h"

#include "../settings/Settings.h"
#include "../net/WiFiManager.h"
#include "../net/WebUI.h"
#include "../net/OtaService.h"
#include "../net/WebhookService.h"

#include "../ui/Display.h"
#include "../sensors/MoistureSensor.h"
#include "../sensors/BatterySensor.h"
#include "../sensors/AmbientLightSensor.h"
#include "../ui/FaceRenderer.h"
#include <time.h>

static Settings settings;
static WiFiManager wifi;
static WebUI web;
static OtaService ota;
static WebhookService webhook;

static Display display;
static MoistureSensor moisture;
static BatterySensor battery;
static AmbientLightSensor ambient;
static FaceRenderer face;

static unsigned long bootMs = 0;

static FaceRenderer::Mood lastMood = FaceRenderer::HAPPY;
static bool lastDead = false;
static bool isNightMode = false;
static uint8_t lastContrast = 0xFF;
static bool ntpConfigured = false;
static bool timeValid = false;
static unsigned long nextTimeCheckMs = 0;
static bool lastScheduleSleep = false;

static constexpr float DIM_LUX_MIN = 0.0f;
static constexpr float DIM_LUX_MAX = 300.0f;
static constexpr uint8_t DIM_CONTRAST_MIN = 0x10;
static constexpr uint8_t DIM_CONTRAST_MAX = 0xFF;
static constexpr int BED_HOUR = 22;
static constexpr int BED_MINUTE = 0;
static constexpr int WAKE_HOUR = 7;
static constexpr int WAKE_MINUTE = 0;
static constexpr int ROUTINE_WINDOW_MIN = 5;

static PlantEventType moodToEvent(FaceRenderer::Mood m) {
  if (m == FaceRenderer::DRY) return EVT_DRY;
  if (m == FaceRenderer::TOO_WET) return EVT_TOO_WET;
  return EVT_OK;
}

static float clampFloat(float v, float lo, float hi) {
  if (v < lo) return lo;
  if (v > hi) return hi;
  return v;
}

static uint8_t luxToContrast(float lux) {
  float clamped = clampFloat(lux, DIM_LUX_MIN, DIM_LUX_MAX);
  float ratio = (DIM_LUX_MAX <= DIM_LUX_MIN) ? 1.0f
                                             : (clamped - DIM_LUX_MIN) / (DIM_LUX_MAX - DIM_LUX_MIN);
  int value = (int)(DIM_CONTRAST_MIN + ratio * (DIM_CONTRAST_MAX - DIM_CONTRAST_MIN));
  if (value < 0) value = 0;
  if (value > 255) value = 255;
  return (uint8_t)value;
}

struct ScheduleState {
  bool hasTime = false;
  bool sleeping = false;
  FaceRenderer::RoutineAnim routineAnim = FaceRenderer::ROUTINE_NONE;
  uint16_t routineProgressPermille = 0;
};

static int secondsOfDay(const tm& local) {
  return local.tm_hour * 3600 + local.tm_min * 60 + local.tm_sec;
}

static bool isInRangeSameDay(int sec, int startSec, int endSec) {
  return sec >= startSec && sec < endSec;
}

static bool isInOvernightRange(int sec, int startSec, int endSec) {
  return (sec >= startSec) || (sec < endSec);
}

static void maybeInitTimeSync(bool wifiConnected) {
  if (!wifiConnected || ntpConfigured) return;
  configTzTime(PB_TZ, "pool.ntp.org", "time.nist.gov");
  ntpConfigured = true;
  Serial.print("[Clock] NTP started, TZ=");
  Serial.println(PB_TZ);
}

static ScheduleState currentScheduleState() {
  ScheduleState s;
  time_t nowEpoch = time(nullptr);
  if (nowEpoch < 1700000000) return s; // not synced yet

  tm local {};
  if (!localtime_r(&nowEpoch, &local)) return s;
  s.hasTime = true;

  const int sec = secondsOfDay(local);
  const int bedSec = BED_HOUR * 3600 + BED_MINUTE * 60;
  const int wakeSec = WAKE_HOUR * 3600 + WAKE_MINUTE * 60;
  const int windDownStartSec = bedSec - ROUTINE_WINDOW_MIN * 60;
  const int wakeAnimEndSec = wakeSec + ROUTINE_WINDOW_MIN * 60;

  if (isInRangeSameDay(sec, windDownStartSec, bedSec)) {
    s.routineAnim = FaceRenderer::ROUTINE_SLEEPING_SOON;
    s.routineProgressPermille = (uint16_t)(((sec - windDownStartSec) * 1000L) / (ROUTINE_WINDOW_MIN * 60L));
    return s;
  }

  if (isInOvernightRange(sec, bedSec, wakeSec)) {
    s.sleeping = true;
    return s;
  }

  if (isInRangeSameDay(sec, wakeSec, wakeAnimEndSec)) {
    s.routineAnim = FaceRenderer::ROUTINE_WAKING_UP;
    s.routineProgressPermille = (uint16_t)(((sec - wakeSec) * 1000L) / (ROUTINE_WINDOW_MIN * 60L));
    return s;
  }

  return s;
}

static void updateScheduleState() {
  if ((long)(millis() - nextTimeCheckMs) < 0) return;
  nextTimeCheckMs = millis() + 1000;

  maybeInitTimeSync(wifi.connected());
  ScheduleState sched = currentScheduleState();
  timeValid = sched.hasTime;

  face.setRoutineAnimation(sched.routineAnim, sched.routineProgressPermille);

  bool shouldSleep = sched.sleeping;
  if (!sched.hasTime) shouldSleep = false; // fail-safe: stay awake until time sync exists

  if (shouldSleep != lastScheduleSleep) {
    Serial.print("[Clock] Schedule ");
    Serial.println(shouldSleep ? "sleep window entered" : "wake window entered");
    lastScheduleSleep = shouldSleep;
  }

  bool wasNightMode = isNightMode;
  isNightMode = shouldSleep;
  if (display.ok()) {
    display.setDisplayEnabled(!isNightMode);
    if (wasNightMode && !isNightMode) lastContrast = 0xFF; // force contrast refresh when waking
  }
}

static void updateAmbientDimming() {
  ambient.loop();
  if (!ambient.available() || !display.ok() || isNightMode || !display.displayEnabled()) return;

  float lux = ambient.filteredLux();
  uint8_t contrast = luxToContrast(lux);
  if (lastContrast == 0xFF || abs((int)contrast - (int)lastContrast) >= 4) {
    display.setContrast(contrast);
    lastContrast = contrast;
  }
}

void App::setup() {
  bootMs = millis();

  Serial.begin(115200);
  delay(100);
  Serial.println("\n\n=== FacePlant Starting ===");
  Serial.print("Firmware: ");
  Serial.println(PB_VERSION);

  settings.begin();
  bool forceSetup = BootTrigger::checkAndConsume();

  Serial.print("Force setup mode: ");
  Serial.println(forceSetup ? "YES" : "NO");
  Serial.print("Saved WiFi SSID: ");
  Serial.println(settings.hasWiFi() ? settings.wifiSsid() : "(none)");

  display.begin();
  display.showStatus("FacePlant", "Starting...");

  wifi.begin(settings, forceSetup);

  moisture.begin(settings);
  battery.begin();
  ambient.begin();
  face.begin(display, settings);

  webhook.begin(settings);

  web.begin(settings, wifi, moisture, face, webhook, bootMs);
  ota.begin(web.server(), &display);

  lastMood = face.mood();
  lastDead = face.isDeadMode();

  Serial.println("=== Setup Complete ===\n");
}

void App::loop() {
  static bool lastConnected = false;
  static unsigned long lastDisplayUpdate = 0;

  BootTrigger::clearAfterStableUptime();

  wifi.loop();
  web.loop();
  updateScheduleState();
  updateAmbientDimming();

  // Show WiFi status on display during connection attempts
  bool currentConnected = wifi.connected();
  if (currentConnected != lastConnected) {
    if (currentConnected) {
      Serial.println("[App] WiFi connected - showing on display");
      if (!isNightMode) {
        display.showStatus("WiFi Connected!", wifi.ssid().c_str());
        delay(2000);
      }
    } else if (wifi.mode() == NET_STA) {
      Serial.println("[App] WiFi disconnected");
      if (!isNightMode && millis() - lastDisplayUpdate > 5000) {
        display.showStatus("WiFi", "Connecting...");
        lastDisplayUpdate = millis();
      }
    }
    lastConnected = currentConnected;
  }

  moisture.loop();
  battery.loop();
  if (!isNightMode) {
    face.loop(moisture, battery);
  }

  // Webhook events on state transitions
  FaceRenderer::Mood m = face.mood();
  bool dead = face.isDeadMode();

  if (dead && !lastDead) {
    webhook.send(EVT_DEAD, moisture, dead, bootMs);
  } else if (!dead && lastDead) {
    webhook.send(EVT_OK, moisture, dead, bootMs);
  } else if (!dead && m != lastMood) {
    webhook.send(moodToEvent(m), moisture, dead, bootMs);
  }

  lastMood = m;
  lastDead = dead;
}