#include <Arduino.h>
#include <ArduinoJson.h>
#include <esp_sleep.h>      // For deep sleep functions
#include <TimeLib.h>        // For time functions
#include <Wire.h>           // For I2C
#include <SparkFun_VEML7700_Arduino_Library.h> // VEML7700
#include "WiFi.h"           // Needed for disabling
#include "BluetoothSerial.h" // Needed for disabling
#include <LoRa.h>           // LoRa library
#include <SPI.h>            // SPI for LoRa
#include <vector>           // For receivedMessageIds
#include <algorithm>        // For std::find_if

// --- Pin Definitions ---
// LoRa Configuration
#define LORA_CS 5
#define LORA_RST 14
#define LORA_IRQ 26 // DIO0 - RTC_GPIO17

// Relay Configuration
const int relayPin = 12;

// PIR sensor - RTC_GPIO14
const int PIR_PIN = 13;

// Voltage Sensor Configuration
const int voltageSensorPin = 34;
const float voltageDividerRatio = 5.0;
const float adcResolution = 3.3 / 4095.0; // Needs Calibration
const float calibrationFactor = 1.071; // Adjust as needed

// --- Sensor Objects ---
VEML7700 veml = VEML7700();

// --- Device Configuration ---
const char* myDeviceName = "driveway_light"; // *** RENAMED VARIABLE ***
const char* allLightsTarget = "all_lights";
const char* allDevicesTarget = "all_devices";

// --- Configuration Constants ---
const unsigned long AWAKE_INACTIVITY_TIMEOUT = 30000;
const float MIN_LUX_THRESHOLD = 5.0;
const float MAX_LUX_THRESHOLD = 500.0;

// --- RTC Memory Variables (Persistent State) ---
//RTC_DATA_ATTR bool settingsRequestMade = false;
RTC_DATA_ATTR time_t currentTime = 0;
RTC_DATA_ATTR time_t sunriseTime = 0;
RTC_DATA_ATTR time_t sunsetTime = 0;
RTC_DATA_ATTR float minimumPower = 11.0;
RTC_DATA_ATTR float maximumLight = 50.0;
RTC_DATA_ATTR unsigned long lightOnDuration = 30000;
RTC_DATA_ATTR String lightMode = "monitor";
RTC_DATA_ATTR unsigned long sleepTime = 15 * 60 * 1000;
RTC_DATA_ATTR String lightStatus = "off";
RTC_DATA_ATTR unsigned long motionDetectedTime = 0;
RTC_DATA_ATTR std::vector<String> receivedMessageIds;

// --- Volatile Variables (Reset on Wake) ---
bool isDaylight = true;
float lightReading = -1.0;
float powerReading = -1.0;
bool isSleeping = false;
unsigned long lastMessageReceivedTime = 0;

// --- Function Declarations ---

void initializeLoRa();
void handleReceivedLoRaMessage(String receivedMessage);
void handlePirWakeup();
void reportSensorsAndSleep();
void sleepCycle(unsigned long durationMs);
void sendLoRaMessage(String jsonPayload);
void sendAcknowledgment(String message_id);
void sendStatusUpdate(String event_type);
void turnLightOn(bool triggeredByPir = false);
void turnLightOff();
void updateDaylightStatus();
float readVoltage();
float readLightLevel();
String createMessageId();
void requestSettings();
// --- End Function Declarations ---

// --- Setup Function ---
// --- Setup Function ---
// --- Setup Function ---
void setup() {
  Serial.begin(115200);
  while (!Serial);
  Serial.println("\n\n--- Driveway Light Controller (Pin Re-init Fix) ---");

  // Disable GPIO hold FIRST
  gpio_hold_dis(GPIO_NUM_5);
  gpio_deep_sleep_hold_dis();

  // --- Initialize Core Peripherals and Pins on EVERY Wake-up ---
  Wire.begin(); // Initialize I2C (Using default pins 21, 22)
  initializeLoRa(); // Initialize LoRa module (includes SPI.begin)
  pinMode(relayPin, OUTPUT); // *** MOVED HERE: Re-init Relay Pin ***
  pinMode(PIR_PIN, INPUT);   // *** MOVED HERE: Re-init PIR Pin ***
  // --- End Core Init ---

  esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();

  // *** FIX: Synchronize TimeLib from RTC Memory ***
  if (currentTime != 0) {
    // If currentTime (from RTC memory) has a valid value (not the initial 0)
    setTime(currentTime); // Set the TimeLib internal clock
    Serial.print("TimeLib synchronized from RTC currentTime: ");
    Serial.println(currentTime);
  } else {
    // currentTime is still 0, meaning we haven't received a time update via LoRa yet.
    Serial.println("RTC currentTime is 0. Waiting for LoRa time update.");
  }
  // *** END FIX ***

  // Now update daylight status using the potentially synchronized time
  updateDaylightStatus();

  // Restore relay state based on RTC variable AFTER pinMode is set
  digitalWrite(relayPin, (lightStatus == "on") ? HIGH : LOW);
  Serial.print("Restored relay state based on lightStatus ('");
  Serial.print(lightStatus); Serial.println("')");

  bool enterLoopAwake = false;

  // --- SINGLE Switch Statement ---
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT1: {
      uint64_t wakeup_pin_mask = esp_sleep_get_ext1_wakeup_status();
      if (wakeup_pin_mask & (1ULL << LORA_IRQ)) {
          Serial.println("Wakeup caused by EXT1 (LoRa IRQ)");
          enterLoopAwake = true;
      } else if (wakeup_pin_mask & (1ULL << PIR_PIN)) {
          Serial.println("Wakeup caused by EXT1 (PIR)");
          handlePirWakeup(); // Reads PIR state using digitalRead AFTER pinMode
          // Stay awake if PIR turned light on in monitor mode
          if (lightStatus == "on" && lightMode == "monitor") {
              enterLoopAwake = true;
          }
          // If handlePirWakeup didn't turn light on, setup will decide sleep later
      } else {
          Serial.println("Wakeup caused by EXT1 (Unknown Pin)");
          // Go to sleep if unknown EXT1 source and light isn't meant to be on
          if (lightStatus != "on") {
             sleepCycle(sleepTime);
          } else {
             // If light is supposed to be on (e.g., mode=on), stay awake
             enterLoopAwake = true;
          }
      }
      break; // End of EXT1 case
    } // End of EXT1 block

    case ESP_SLEEP_WAKEUP_TIMER: {
      Serial.println("Wakeup caused by Timer");
      reportSensorsAndSleep(); // Reads sensors AFTER pinMode/Wire.begin
      // reportSensorsAndSleep calls sleepCycle, so code execution stops here for this path
      break; // End of TIMER case (technically unreachable due to sleep)
    } // End of TIMER block

    default: { // Initial Boot or other reasons
      Serial.printf("Initial Boot or other wake-up reason: %d\n", wakeup_reason);
      // I2C, LoRa, pinMode already done above
      if (veml.begin()) { Serial.println("VEML7700 connected"); }
      else { Serial.println("VEML7700 not found"); }
      WiFi.disconnect(true); WiFi.mode(WIFI_OFF); btStop();
      Serial.println("Initial boot setup complete.");

      // Check if essential time is missing
      if (currentTime == 0 || sunriseTime == 0 || sunsetTime == 0) {
          Serial.println("Essential time data missing on initial boot. Requesting settings.");
          requestSettings(); // Call the function to send the request
          Serial.println("Proceeding to loop to listen for settings response.");
          enterLoopAwake = true; // Ensure we enter the loop
      } else {
          // Time data IS present from a previous run
          Serial.println("Time data found in RTC. Reporting sensors and sleeping.");
          reportSensorsAndSleep(); // Proceed with normal timer-like behavior
          // reportSensorsAndSleep calls sleepCycle, so code execution stops here
      }
      break; // End of default case (may be unreachable if sleeping)
    } // End of default block

  } // *** Closing brace for the SINGLE switch statement ***

  // --- Enter Loop Awake State ---
  // This logic now runs *after* the switch statement is complete
  if (enterLoopAwake || (lightStatus == "on")) {
      Serial.println("Proceeding to loop in AWAKE state.");
      isSleeping = false;
      lastMessageReceivedTime = millis(); // Reset inactivity timer
      LoRa.receive(); // Ensure LoRa is listening
  } else if (!isSleeping) { // Add check to prevent redundant sleep call
      Serial.println("Setup complete, conditions not met to stay awake. Entering sleep cycle.");
      LoRa.receive();
      delay(10);
      sleepCycle(sleepTime);
  }
  // If sleepCycle was called inside the switch, execution might not reach here.

} // End of setup()




void requestSettings() {
  Serial.println("Requesting settings from base station...");
  JsonDocument doc;
  doc["device"] = myDeviceName;
  doc["action"] = "request_settings"; // Use a specific action keyword
  doc["message_id"] = createMessageId(); // Include a message ID

  String jsonData;
  serializeJson(doc, jsonData);
  sendLoRaMessage(jsonData);
  Serial.println("Settings request sent.");

  // No need to manage flags here.
  // The setup() function logic determines if we stay awake.
}

// --- Main Loop ---
// --- Main Loop ---
void loop() {
  bool processedLoRa = false;

  // 1. Check for LoRa messages FIRST
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
      String msg = "";
      while (LoRa.available()) { msg += (char)LoRa.read(); }
      handleReceivedLoRaMessage(msg);
      lastMessageReceivedTime = millis();
      processedLoRa = true;
      if (!isSleeping) { LoRa.receive(); }
      else { return; }
  }

  // 2. Check PIR Light Timeout (Only in monitor mode)
  if (lightStatus == "on" && lightMode == "monitor" && motionDetectedTime > 0) {
      if (millis() - motionDetectedTime > lightOnDuration) {
          Serial.println("PIR light duration expired.");
          turnLightOff();
          return;
      }
  }

  // 3. Check Low Power Condition (Only when lightMode is 'on')
  if (lightStatus == "on" && lightMode == "on") {
      static unsigned long lastPowerCheck = 0;
      if (millis() - lastPowerCheck > 60000) { // Check every 60 seconds
          lastPowerCheck = millis();
          powerReading = readVoltage();
          Serial.print("Periodic power check while ON: "); Serial.println(powerReading);
          if (powerReading >= 0 && powerReading < minimumPower) {
              Serial.println("LOW POWER DETECTED while lightMode=on. Turning off light.");
              turnLightOff();
              return;
          }
      }
  }

  // *** 4. ADDED: Check PIR Sensor while lightMode is 'on' ***
  if (lightMode == "on") {
      static bool lastPirState = LOW; // Remember last state to detect changes
      static unsigned long lastPirReportTime = 0;
      int currentPirState = digitalRead(PIR_PIN);

      if (currentPirState == HIGH && lastPirState == LOW) {
          // Motion just started while lightMode is 'on'
          Serial.println("PIR Motion Detected while lightMode=on.");
          // Send a status update immediately
          sendStatusUpdate("pir_motion_while_on");
          lastPirReportTime = millis(); // Record time of this report
      }
      // Optional: Send periodic updates if motion continues?
      // else if (currentPirState == HIGH && lastPirState == HIGH) {
      //    // Motion continues
      //    if (millis() - lastPirReportTime > 60000) { // e.g., report every minute if motion persists
      //       sendStatusUpdate("pir_motion_continuing_while_on");
      //       lastPirReportTime = millis();
      //    }
      // }
      lastPirState = currentPirState; // Update last state
  }
  // *** END ADDED PIR CHECK ***


  // 5. Check for Inactivity Timeout (Only relevant if NOT in 'on' mode)
  // If mode is 'on', we stay awake indefinitely unless turned off by LoRa/Low Power
  if (!processedLoRa && lightMode != "on" && lightStatus != "on") {
      if (millis() - lastMessageReceivedTime > AWAKE_INACTIVITY_TIMEOUT) {
          Serial.println("Awake inactivity timeout reached (monitor mode, light off). Going to sleep.");
          sleepCycle(sleepTime);
          return;
      }
  }

  delay(10); // Prevent tight loop
}


// --- Core Logic Functions ---

void handlePirWakeup() {
  Serial.println("Handling PIR Wakeup...");
  lightReading = readLightLevel();
  powerReading = readVoltage();
  updateDaylightStatus();


  Serial.print("PIR Trig: Daylight="); Serial.print(isDaylight);

  Serial.print("currentTime="); Serial.print(currentTime);
  
  Serial.print("sunriseTime="); Serial.print(sunriseTime);
  Serial.print("sunsetTime="); Serial.print(sunsetTime);

  Serial.print(" | Light="); Serial.print(lightReading);

Serial.print(" is less than maximumLight="); Serial.print(maximumLight);

  Serial.print(" | Power="); Serial.print(powerReading);
  Serial.print(" | Mode="); Serial.println(lightMode);

  bool conditionsMet = (!isDaylight || (lightReading >= 0 && lightReading < maximumLight)) &&
                       (powerReading >= 0 && powerReading > minimumPower) &&
                       lightMode == "monitor";

  if (conditionsMet) {
      Serial.println("Conditions met for PIR light ON.");
      turnLightOn(true);
      sendStatusUpdate("pir_light_on");
      LoRa.receive();
      return; // Return to setup -> loop
  } else {
      Serial.println("Conditions NOT met for PIR light ON (or mode=on).");
      LoRa.receive(); // Ensure LoRa ready if setup enters loop
      return; // Return to setup -> sleep decision
  }
}

void reportSensorsAndSleep() {
  Serial.println("Timer wake-up: Reporting sensors...");
  lightReading = readLightLevel();
  powerReading = readVoltage();
  updateDaylightStatus();

  JsonDocument doc;
  doc["device"] = myDeviceName; // *** Use consistent "device" key ***
  if (powerReading >= 0) doc["voltage"] = powerReading;
  if (lightReading >= 0) doc["lux"] = lightReading;
  doc["timestamp"] = now();
  doc["lightStatus"] = lightStatus;
  doc["lightMode"] = lightMode;
  doc["isDaylight"] = isDaylight;
  doc["message_id"] = createMessageId();

  String jsonData;
  serializeJson(doc, jsonData);
  sendLoRaMessage(jsonData);
  sleepCycle(sleepTime);
}

void sleepCycle(unsigned long durationMs) {
  Serial.print("Entering sleep cycle for "); Serial.print(durationMs); Serial.println(" ms");
  isSleeping = true;
  LoRa.receive(); // Put LoRa in receive mode before sleep
  delay(10);
  esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL); // Disable all previous sources

  // --- Configure Wake-up Sources ---

  // 1. Timer Wake-up (Always Enabled)
  esp_sleep_enable_timer_wakeup((uint64_t)durationMs * 1000);
  Serial.print("Timer wake-up enabled for "); Serial.print(durationMs); Serial.println(" ms");

  // 2. EXT1 Wake-up (ALWAYS Enable LoRa IRQ and PIR)
  uint64_t ext1_wakeup_mask = (1ULL << LORA_IRQ) | (1ULL << PIR_PIN);
  esp_sleep_enable_ext1_wakeup(ext1_wakeup_mask, ESP_EXT1_WAKEUP_ANY_HIGH);
  Serial.println("EXT1 wake-up enabled for LoRa IRQ (26) and PIR (13) - ANY_HIGH");
  // --- End Configure Wake-up Sources ---

  // --- Hold CS pin HIGH during sleep ---
  gpio_hold_en(GPIO_NUM_5);
  gpio_deep_sleep_hold_en();

  Serial.println("Entering deep sleep NOW...");
  Serial.flush();
  esp_deep_sleep_start();
  Serial.println("!!! Woke up from Deep Sleep Unexpectedly !!!"); // Should not see this
}


// --- LoRa Communication ---

void initializeLoRa() {
  Serial.print(F("[LoRa] Initializing ... "));
  SPI.begin();
  LoRa.setPins(LORA_CS, LORA_RST, LORA_IRQ);
  if (!LoRa.begin(434E6)) {
      Serial.println("Starting LoRa failed!");
      delay(1000); ESP.restart();
  }
  LoRa.setSpreadingFactor(9);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setCodingRate4(5);
  LoRa.setPreambleLength(8);
  LoRa.setSyncWord(0x34);
  Serial.println(F("success!"));
}

void sendLoRaMessage(String jsonPayload) {
    Serial.print("Sending LoRa Message: "); Serial.println(jsonPayload);
    LoRa.beginPacket();
    LoRa.print(jsonPayload);
    int success = LoRa.endPacket();
    if (!success) {
        Serial.println("LoRa transmit failed!");
    }
}

void sendAcknowledgment(String message_id) {
  JsonDocument ackDoc;
  ackDoc["message_id"] = message_id;
  ackDoc["message"] = "acknowledged";
  ackDoc["device"] = myDeviceName; // *** Use consistent "device" key ***
  String ackMessage;
  serializeJson(ackDoc, ackMessage);
  Serial.print("Sending ACK for message ID: "); Serial.println(message_id);
  sendLoRaMessage(ackMessage);
}

void sendStatusUpdate(String event_type) {
    JsonDocument statusDoc;
    statusDoc["device"] = myDeviceName; // *** Use consistent "device" key ***
    statusDoc["event"] = event_type;
    statusDoc["lightStatus"] = lightStatus;
    statusDoc["lightMode"] = lightMode;
    statusDoc["message_id"] = createMessageId();
    if (powerReading >= 0) statusDoc["voltage"] = powerReading;
    if (lightReading >= 0) statusDoc["lux"] = lightReading;
    String statusMessage;
    serializeJson(statusDoc, statusMessage);
    sendLoRaMessage(statusMessage);
}

// --- UPDATED Message Handler ---
// Handles the content of a received LoRa message
// Handles the content of a received LoRa message
// Handles the content of a received LoRa message
void handleReceivedLoRaMessage(String receivedMessage) {
  Serial.print("handleReceivedLoRaMessage - Raw: "); Serial.println(receivedMessage);

  // Parse the incoming JSON FIRST
  JsonDocument doc; // Use JsonDocument for parsing
  DeserializationError error = deserializeJson(doc, receivedMessage);
  if (error) {
    Serial.print("Failed to parse JSON: "); Serial.println(error.c_str());
    return; // Exit if parsing fails
  }
  Serial.println("Parsed Received JSON");

  // --- Always attempt to Update Settings ---
  bool settingsUpdatedThisMessage = false; // Track if any setting was updated in THIS message
  bool timeSettingsReceived = false; // Track if essential time settings came in this message

  if (doc["currentTime"].is<time_t>()) {
      currentTime = doc["currentTime"].as<time_t>();
      setTime(currentTime); // Set TimeLib internal clock
      updateDaylightStatus(); // Update daylight based on new time
      settingsUpdatedThisMessage = true;
      timeSettingsReceived = true;
      Serial.println("Updated currentTime");
  }
  if (doc["sunriseTime"].is<time_t>()) {
      sunriseTime = doc["sunriseTime"].as<time_t>();
      settingsUpdatedThisMessage = true;
      timeSettingsReceived = true;
      Serial.println("Updated sunriseTime");
  }
  if (doc["sunsetTime"].is<time_t>()) {
      sunsetTime = doc["sunsetTime"].as<time_t>();
      settingsUpdatedThisMessage = true;
      timeSettingsReceived = true;
      Serial.println("Updated sunsetTime");
  }
  if (doc["minimumPower"].is<float>()) {
      minimumPower = doc["minimumPower"].as<float>();
      settingsUpdatedThisMessage = true;
      Serial.println("Updated minimumPower");
  }
  if (doc["maximumLightPercent"].is<int>()) {
      int percent = doc["maximumLightPercent"].as<int>();
      percent = constrain(percent, 1, 100);
      maximumLight = map(percent, 1, 100, (long)MIN_LUX_THRESHOLD, (long)MAX_LUX_THRESHOLD);
      settingsUpdatedThisMessage = true;
      Serial.print("Updated maximumLight from Percent("); Serial.print(percent); Serial.print("%) to Lux: "); Serial.println(maximumLight);
  }
  if (doc["lightOnDuration"].is<unsigned long>()) {
      unsigned long durationSeconds = doc["lightOnDuration"].as<unsigned long>();
      lightOnDuration = durationSeconds * 1000UL; // Convert seconds to milliseconds
      settingsUpdatedThisMessage = true;
      Serial.print("Updated lightOnDuration from Seconds("); Serial.print(durationSeconds); Serial.print("s) to ms: "); Serial.println(lightOnDuration);
  }
  if (doc["sleepTime"].is<unsigned long>()) {
      unsigned long sleepSeconds = doc["sleepTime"].as<unsigned long>();
      sleepTime = sleepSeconds * 1000UL; // Convert seconds to milliseconds
      settingsUpdatedThisMessage = true;
      Serial.print("Updated sleepTime from Seconds("); Serial.print(sleepSeconds); Serial.print("s) to ms: "); Serial.println(sleepTime);
  }
  // --- End Update Settings ---

  // Extract necessary fields FROM THE PARSED 'doc'
  String message_id = doc["message_id"] | "no_id";
  String receivedTargetDevice = doc["targetDevice"] | "no_target";
  String action = doc["action"] | "no_action";

  bool commandProcessed = false;
  bool goingToSleep = false;
  bool ackSent = false;

  // --- Target Check ---
  bool targeted = (receivedTargetDevice.equals(myDeviceName) ||
                   receivedTargetDevice.equals(allLightsTarget) ||
                   receivedTargetDevice.equals(allDevicesTarget));

  Serial.print("Message Target Check: Received='"); Serial.print(receivedTargetDevice);
  Serial.print("', MyName='"); Serial.print(myDeviceName);
  Serial.print("', Targeted="); Serial.println(targeted);

  if (!targeted) {
      Serial.println("Message not targeted for this device.");
      // Decide if we should sleep or keep listening if not targeted
      if (lightMode != "on" && lightStatus != "on") {
          // If light is off and mode isn't forced 'on', sleep
          sleepCycle(sleepTime);
          return; // Exit function after starting sleep
      } else {
          // Otherwise (light is on or mode is 'on'), stay awake and listen
          LoRa.receive();
          return; // Exit function, stay awake
      }
  }
  Serial.println("Message targeted for this device.");

  // --- Action Processing ---
  // Send ACK *early* if possible and command is valid & targeted
  // Acknowledge specific actions or any message that updated settings
  if (message_id != "no_id") {
      if (action == "turn_on" || action == "turn_off" || action == "apply_settings" || action == "request_settings" || settingsUpdatedThisMessage) {
         sendAcknowledgment(message_id);
         ackSent = true;
         delay(50); // Small delay after ACK before potential status update
      }
  }

  if (action == "turn_on") {
      Serial.println("Received action: turn_on");
      powerReading = readVoltage(); // Check power before turning on
      if (powerReading >= 0 && powerReading < minimumPower) {
          Serial.print("Cannot turn on - LOW POWER detected: "); Serial.println(powerReading);
          sendStatusUpdate("turn_on_failed_low_power"); // Send specific status
          commandProcessed = true;
          goingToSleep = (lightMode != "on"); // Go to sleep unless mode is forced 'on'
      } else {
          if (lightStatus != "on") {
              turnLightOn(); // Turn light on (sets mode to 'on' implicitly)
          } else {
              // If already on, ensure mode is 'on'
              lightMode = "on";
              Serial.println("Light already on, ensuring mode is 'on'.");
          }
          commandProcessed = true;
          // Stay awake because light is now on or mode is 'on'
      }
  } else if (action == "turn_off") {
      Serial.println("Received action: turn_off");
      turnLightOff(); // This function handles status update and sleep
      commandProcessed = true;
      goingToSleep = true; // turnLightOff initiates sleep
      // ACK was sent above
      return; // Exit function as turnLightOff handles sleep
  } else if (action == "apply_settings") {
      Serial.println("Received action: apply_settings");
      // Logic using settingsRequestMade was removed here.
      if (settingsUpdatedThisMessage) {
          Serial.println("Settings values were updated from this message.");
      } else {
          Serial.println("Action 'apply_settings' received, but no new settings values were applied.");
      }
      commandProcessed = true;
      // ACK was sent above
      // Decide sleep based on current state after applying settings
      goingToSleep = (lightMode != "on" && lightStatus != "on");
  } else if (action == "request_settings") {
      Serial.println("Received action: request_settings (Ignoring, I am receiver)");
      // This device doesn't act on receiving a request, it sends requests.
      commandProcessed = true;
      // ACK was sent above
      // Decide sleep based on current state
      goingToSleep = (lightMode != "on" && lightStatus != "on");
  } else if (action != "no_action") {
      Serial.println("Unknown action received: " + action);
      if (message_id != "no_id" && !ackSent) {
          // Send ACK for unknown action if not already sent
          sendAcknowledgment(message_id);
          ackSent = true;
      }
      commandProcessed = true;
      // Decide sleep based on current state
      goingToSleep = (lightMode != "on" && lightStatus != "on");
  } else {
      // No specific 'action' key found in message.
      Serial.println("No specific 'action' key found in message.");
      if (settingsUpdatedThisMessage) {
           Serial.println("Settings values were updated from message with no specific action.");
           // ACK should have been sent above if message_id exists and settings were updated
           commandProcessed = true; // Mark as processed if settings were updated
      }
      // Decide sleep based on current state
      goingToSleep = (lightMode != "on" && lightStatus != "on");
  }
  // --- End Action Processing ---


  // --- Send Status Update ---
  // Send status update only if a command was processed, we aren't going to sleep immediately,
  // and it wasn't the turn_off command (which sends its own status before sleeping).
  if (commandProcessed && !goingToSleep && action != "turn_off") {
      // ACK should have already been sent if applicable
      delay(1500); // Keep delay for status update separation from ACK
      sendStatusUpdate("lora_command_processed");
  } else if (message_id == "no_id" && commandProcessed) {
      Serial.println("Command processed but no message_id received, cannot ACK.");
  }

  // --- Final Sleep/Wake Decision ---
  if (goingToSleep) {
      Serial.println("Command processed, conditions indicate sleep is appropriate.");
      sleepCycle(sleepTime);
      // Execution stops here
  } else {
      // Stay awake if light is on, mode is 'on', or loop inactivity timer hasn't expired
      Serial.println("Command processed, staying awake in loop.");
      lastMessageReceivedTime = millis(); // Reset inactivity timer as we processed a message
      LoRa.receive(); // Ensure LoRa is ready for next message
  }
}



void updateDaylightStatus() {
  if (sunriseTime == 0 || sunsetTime == 0 || currentTime == 0) {
    Serial.println("updateDaylightStatus: Invalid time(s), defaulting to daylight=true");
    isDaylight = true; // Default to daylight if times are invalid to prevent unwanted ON state
    return;
  }

  // Handle the normal case where sunrise and sunset are on the same day
  if (sunriseTime < sunsetTime) {
    isDaylight = (currentTime > sunriseTime && currentTime < sunsetTime);
  }
  // Handle the case where times span midnight (sunrise is 'tomorrow' relative to sunset 'today')
  else if (sunriseTime > sunsetTime) {
    isDaylight = (currentTime > sunriseTime || currentTime < sunsetTime);
  }
  // If sunriseTime == sunsetTime (unlikely, but handle it)
  else {
    isDaylight = false; // Or true? Define behavior for this edge case. False = dark.
  }

  Serial.print("updateDaylightStatus: currentTime="); Serial.print(currentTime);
  Serial.print(", sunriseTime="); Serial.print(sunriseTime);
  Serial.print(", sunsetTime="); Serial.print(sunsetTime);
  Serial.print(" -> isDaylight="); Serial.println(isDaylight);
}



float readVoltage() {
  int adcValue = analogRead(voltageSensorPin);
  const int numReadings = 5;
  static float readings[numReadings];
  static int readIndex = 0;
  static float total = 0;
  static bool filled = false;
  total = total - readings[readIndex];
  float rawVoltage = (float)adcValue * (3.3 / 4095.0) * voltageDividerRatio;
  float calibratedVoltage = rawVoltage * calibrationFactor; // Apply calibration
  readings[readIndex] = calibratedVoltage;
  total = total + readings[readIndex];
  readIndex++;
  if(readIndex >= numReadings) { readIndex = 0; filled = true; }
  powerReading = filled ? total / (float)numReadings : total / (float)(readIndex == 0 ? 1 : readIndex);
  return powerReading;
}

float readLightLevel() {
  Wire.begin(); // Re-init I2C
  delay(20);
  if (veml.begin()) {
     lightReading = veml.getAmbientLight();
  } else {
     lightReading = -1.0;
     Serial.println("VEML7700 read failed (veml.begin() failed).");
  }
  return lightReading;
}

void turnLightOn(bool triggeredByPir /*= false*/) {
  if (lightStatus == "off") {
      digitalWrite(relayPin, HIGH);
      lightStatus = "on";
      Serial.println("Light turned ON");
      if (triggeredByPir) {
          motionDetectedTime = millis();
          Serial.print("PIR timer started for "); Serial.print(lightOnDuration); Serial.println(" ms");
      } else {
          motionDetectedTime = 0;
          lightMode = "on";
          Serial.println("Light mode set to: on");
      }
  } else {
      if (!triggeredByPir && lightMode != "on") {
          lightMode = "on";
          Serial.println("Light already on, mode set to: on");
      }
  }
}

void turnLightOff() {
  if (lightStatus == "on") {
      digitalWrite(relayPin, LOW);
      lightStatus = "off";
      motionDetectedTime = 0;
      Serial.println("Light turned OFF");
      lightMode = "monitor";
      Serial.println("Light mode set to: monitor");
      sendStatusUpdate("light_turned_off");
      sleepCycle(sleepTime);
  } else {
      Serial.println("Light already OFF.");
      if (lightMode != "monitor") {
          lightMode = "monitor";
          Serial.println("Light mode set to: monitor");
          sendStatusUpdate("mode_set_monitor");
      }
      sleepCycle(sleepTime);
  }
}

String createMessageId() {
    return String(random(10000, 99999));
}