#include <WiFi.h>
#include <PubSubClient.h>

// --- 1. CONFIGURATION ---
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// Server Settings
// For Cloud: Use "mqtt.geia.ai"
// For Local MasterHub: Use the IP address of your Hub (e.g., "192.168.1.50")
const char* mqttServer = "mqtt.geia.ai"; 
const char* mqttUser = "YOUR_API_TOKEN"; 	// Token from App
const char* mqttPass = "YOUR_API_PASSWORD";   	// Password from App

// --- 2. TOPIC & ID SETUP ---
// IMPORTANT:
// If using Cloud: Set location_prefix to "YOUR_LOCATION_ID/" (e.g., "77/")
// If using Local MasterHub: Set location_prefix to "" (Empty String)
String location_prefix = "e/77"; // Use "" for Master Hub
const char* sensor_id = "12345";  //Get this ID from GEIA App (Sensor Settings)
const char* relay_id = "67890";   // Get this ID from GEIA App (Relay Settings)
const int relayPin = 2; // The GPIO pin your relay is connected to	on	Arduinoi/ESP

WiFiClient espClient;
PubSubClient client(espClient);

// Timers (Non-blocking delays)
// We use millis() instead of delay() so the MQTT connection doesn't drop
unsigned long lastMsg = 0;
const long interval = 30000; // Send sensor data every	30 Seconds interval
float lastTemp = 0.0;
float lastHum = 0.0;

// Logic State variables
bool automationOff = false; 
int forceStatus = -1; 

// --- SENSOR MOCKUP ---
// Replace these functions with your actual library calls (e.g., dht.readTemperature())
float readTemperature() { return 22.5; } 
float readHumidity() { return 55.1; }

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);	// Default to OFF
  Serial.begin(115200);
  
  setup_wifi();
  client.setServer(mqttServer, 1883);
  client.setCallback(mqttCallback);	// Register function to handle incoming msgs	
}

void setup_wifi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
  Serial.println("\nWiFi connected");
}

void loop() {
  // Ensure we stay connected to MQTT
  if (!client.connected()) reconnectMQTT();
  client.loop();

   // --- NON-BLOCKING TIMER ---
  // This allows the loop to keep running fast to listen for commands
  unsigned long now = millis();
  if (now - lastMsg > interval) {
    lastMsg = now;
    checkAndPublish();
  }
}

void checkAndPublish() {
  float temp = readTemperature();
  float hum = readHumidity();

  // CHANGE DETECTION: Only publish if values changed by > 0.1
  // This saves data and reduces clutter
  if (abs(temp - lastTemp) > 0.1 || abs(hum - lastHum) > 0.1) {
    
    // Payload Format: Space separated ("Value1 Value2")
    String payload = String(temp, 1) + " " + String(hum, 1);
    
    // Construct Topic: [Location_Prefix] + /e/s/ + [Sensor_ID]
    String topic = (location_prefix.length() > 0 ? location_prefix + "/" : "") + "e/s/" + sensor_id;
    
    client.publish(topic.c_str(), payload.c_str(), true);
    Serial.println("New Data Published: " + payload);
    
    lastTemp = temp;
    lastHum = hum;
  }
}


// --- INCOMING COMMAND HANDLER ---
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) message += (char)payload[i];

  // Construct topic strings to compare against
  String prefix = (location_prefix.length() > 0 ? location_prefix + "/" : "");
  String switchTopic = prefix + "e/r/" + relay_id + "/switch";
  String forceTopic  = prefix + "e/r/force/" + relay_id;

   // 1. HANDLE FORCE LOGIC (Manual Override)
  // This allows the User in the App to say "Force ON" or "Force OFF"even	if	automation	trying	to	change	the	state
  if (String(topic) == forceTopic) {
    if(message == "0" || message == "0 0") {
      automationOff = false; 
    } else if(message == "1 0") {
      automationOff = true;  
      digitalWrite(relayPin, LOW); 
    } else if(message == "1 1") {
      automationOff = true;  
      digitalWrite(relayPin, HIGH); 
    }
  }

   // 2. HANDLE NORMAL SWITCH (Automation Commands)
  // Only execute if automation is NOT overridden manually	(Force	Switch	Off)
  if (String(topic) == switchTopic && !automationOff) {
      if (message == "1") digitalWrite(relayPin, HIGH);
      else if (message == "0") digitalWrite(relayPin, LOW);
  }
  //Publish	the	state	of	relay	to	rstate	topic	to	confirm
  
  
}

void reconnectMQTT() {
  while (!client.connected()) {
    String clientId = "GEIA-Node-" + String(random(0xffff), HEX);
    if (client.connect(clientId.c_str(), mqttUser, mqttPass)) {
      String prefix = (location_prefix.length() > 0 ? location_prefix + "/" : "");
      client.subscribe((prefix + "e/r/" + relay_id + "/switch").c_str());
      client.subscribe((prefix + "e/r/force/" + relay_id).c_str());
    } else { delay(5000); }
  }
}

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_WIFI_PASS";

// State Tracking for Consumption Calculation
unsigned long onTimestamp = 0; // Stores when it turned ON (Epoch or millis)
bool isRelayOn = false;
float deviceWattage = 50.0; // Example: 50 Watt Grow Light

// (Include Part 2 Functions here)

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
}

void loop() {
  // EXAMPLE LOGIC: Detecting a switch change
  // In your real code, you call this when you switch your relay
  
  bool commandToTurnOn = true; // Replace with your actual switch logic

  if (commandToTurnOn && !isRelayOn) {
    // TURN ON EVENT
    isRelayOn = true;
    onTimestamp = millis(); // Or use time(NULL) if you have NTP synced
    Serial.println("Relay Turned ON. Timer Started.");
  } 
  else if (!commandToTurnOn && isRelayOn) {
    // TURN OFF EVENT
    isRelayOn = false;
    unsigned long offTimestamp = millis();
    
    // 1. Calculate Duration (in seconds)
    float durationSeconds = (offTimestamp - onTimestamp) / 1000.0;
    
    // 2. Calculate Watts Used (Watt-hours or total consumption based on duration)
    // Formula: (Watts * Seconds) / 3600 = Watt-hours
    float wattsUsed = (deviceWattage * durationSeconds) / 3600.0;
    
    // 3. Send to GEIA API
    logRelayData("RELAY_ID_123", onTimestamp, offTimestamp, wattsUsed);
  }
  
  delay(1000);
}

// --- GEIA API CONFIG ---
// Check API Docs: This URL may differ based on your cluster
String apiBase = "https://api.geia.ai"; 

// Initial Credentials (Get these from your App/Profile)
String jwtToken = "YOUR_INITIAL_JWT";
String refreshToken = "YOUR_REFRESH_TOKEN";

// Helper to refresh token if expired
bool refreshJWT();

// Function to log Sensor Data
void logSensorData(String sensor_id, float v1, float v2) {
  HTTPClient http;
  http.begin(apiBase + "/data/add/sensor"); 
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer " + jwtToken);

  // Create JSON Doc	using ArduinoJson
  // StaticJsonDocument<200> is sufficient for simple data
  StaticJsonDocument<200> doc;
  doc["sensor_id"] = sensor_id;
  doc["value_1"] = v1;
  doc["value_2"] = v2;
  // Note: We omit "sample_timestamp" to let the Server assign the time.
  // If you have an RTC, you can add it here in ISO 8601 format.

  String payload;
  serializeJson(doc, payload);

  // Send Request
  int code = http.POST(payload);
  
  // --- RETRY LOGIC ---
  // If the server says "401 Unauthorized", our token expired.
  if(code == 401) {
    Serial.println("Token expired. Refreshing...");
    http.end(); // Close old connection
    
    if(refreshJWT()) {
      // Retry sending data with new token
      HTTPClient httpRetry;
      httpRetry.begin(apiBase + "/data/add/sensor");
      httpRetry.addHeader("Content-Type", "application/json");
      httpRetry.addHeader("Authorization", "Bearer " + jwtToken);
      httpRetry.POST(payload);
      httpRetry.end();
      Serial.println("Data sent after refresh.");
    }
  } else {
    Serial.print("Data Sent. Code: ");
    Serial.println(code);
    http.end();
  }
}



// Function to log Relay Data
void logRelayData(String relay_id, unsigned long on_ts, unsigned long off_ts, float watts) {
  if(WiFi.status() != WL_CONNECTED) return;

  HTTPClient http;
  http.begin(apiBase + "/data/add/relay");
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer " + jwtToken);

  // Build JSON Payload
  StaticJsonDocument<200> doc;
  doc["relay_id"] = relay_id;
  doc["on_timestamp"] = on_ts;   // Start time
  doc["off_timestamp"] = off_ts; // End time
  doc["watts_used"] = watts;     // Calculated consumption
  
  String payload;
  serializeJson(doc, payload);

  // Send Request
  int code = http.POST(payload);
  
  // Retry Logic for Expired Token
  if(code == 401) {
    http.end();
    if(refreshJWT()) {
      // Re-initialize and retry
      HTTPClient httpRetry;
      httpRetry.begin(apiBase + "/data/add/relay");
      httpRetry.addHeader("Content-Type", "application/json");
      httpRetry.addHeader("Authorization", "Bearer " + jwtToken);
      httpRetry.POST(payload);
      httpRetry.end();
    }
  } else {
    http.end();
  }
}


// Function to get a new JWT using the Refresh Token
bool refreshJWT() {
  HTTPClient http;
  http.begin(apiBase + "/auth/refresh");
  http.addHeader("Content-Type", "application/json");
  
  StaticJsonDocument<200> doc;
  doc["refresh_token"] = refreshToken;
  
  String payload;
  serializeJson(doc, payload);
  
  int code = http.POST(payload);
  bool success = false;

  if(code == 200){
    StaticJsonDocument<512> resp;
    deserializeJson(resp, http.getString());
    jwtToken = resp["jwt"].as();
    success = true;
  }
  http.end();
  return success;
}

#include <WiFi.h>
#include <PubSubClient.h>

// --- SETUP ---
String location_id = "LOC123"+"/";  // Leave blank for offline =""; or replace only "LOC123" for Cloud  
String sensor_id   = "S1";         
String actuator_id = "R1";         

const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_WIFI_PASS";
const char* mqtt_server = "ASSIGNED_MQTT_HOSTNAME"; 

WiFiClient espClient;
PubSubClient client(espClient);

// Data Globals
float remoteSensorValue = -999; 
int remoteRelayState = -1; 
unsigned long lastRun = 0;

// Topics
String topic_sensor      = location_id + "e/s/" + sensor_id;
String topic_rstate      = location_id + "e/r/force/" + actuator_id + "/rstate";
String topic_relaySwitch = location_id + "e/r/" + actuator_id + "/switch";

void callback(char* topic, byte* message, unsigned int length) {
  String msg = "";
  for (int i = 0; i < length; i++) msg += (char)message[i];
  String t = String(topic);

  if (t == topic_sensor) remoteSensorValue = msg.toFloat();
  if (t == topic_rstate) remoteRelayState = msg.toInt();
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void reconnect() {
  while (!client.connected()) {
    String clientId = "AutoBot-" + String(random(0xffff), HEX);
    if (client.connect(clientId.c_str())) {
      client.subscribe(topic_sensor.c_str());
      client.subscribe(topic_rstate.c_str());
    } else { delay(2000); }
  }
}

void runAutomation() {
  if (remoteSensorValue == -999) return; 

  // Automation Logic
  bool shouldBeOn = (remoteSensorValue < 20.0); // Temp < 20, Heater ON
  
  // Command Execution
  if (shouldBeOn && remoteRelayState == 0) {
    client.publish(topic_relaySwitch.c_str(), "1");
    Serial.println("CMD: ON");
  } 
  else if (!shouldBeOn && remoteRelayState == 1) {
    client.publish(topic_relaySwitch.c_str(), "0");
    Serial.println("CMD: OFF");
  }

  // --- ERROR DETECTION ---
  // We check if the command failed. 
  // If we want it ON, but the remote state confirms it is still OFF (0)
  if (shouldBeOn && remoteRelayState == 0) {
     Serial.println("⚠ CRITICAL FAILURE: Relay is not responding to ON command!");
     
     // NOTE: GEIA has an API Route for Errors/Notifications. 
     // You can use the HTTP logic from Snippet 2 to send this error 
     // to /api/log/error so you get a push notification on your phone.
  }
}

void loop() {
  if (!client.connected()) reconnect();
  client.loop();

  if (millis() - lastRun > 2000) {
    lastRun = millis();
    runAutomation();
  }
}

#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// --- PIN DEFINITIONS ---
// Define which Arduino pin each relay is connected to
#define LIGHT_RELAY_PIN   4
#define PUMP_RELAY_PIN    5
#define FAN_RELAY_PIN     6

// Define sensor pins
#define DHT_PIN           7
#define ONEWIRE_BUS_PIN   8

// --- RELAY STATE (Important!) ---
// Some relay modules are "LOW" active (turn ON when pin is LOW)
// Change these if your relays work backwards
#define RELAY_ON  LOW
#define RELAY_OFF HIGH

// --- AUTOMATION TIMERS (in milliseconds) ---
// Light Cycle (18 hours ON, 6 hours OFF)
const unsigned long LIGHT_CYCLE_DURATION = 18UL * 60 * 60 * 1000; // 18 hours
const unsigned long DARK_CYCLE_DURATION  = 6UL * 60 * 60 * 1000;  // 6 hours

// Watering Cycle (Pump ON for 30s, every 15 min)
const unsigned long PUMP_ON_DURATION = 30000UL;      // 30 seconds
const unsigned long PUMP_CYCLE_INTERVAL = 15UL * 60 * 1000; // 15 minutes

// Fan Cycle (Fan ON for 2 min after pumping)
const unsigned long FAN_ON_DURATION = 120000UL;     // 2 minutes

// Sensor Reading (Read every 5 seconds)
const unsigned long SENSOR_READ_INTERVAL = 5000UL;

// --- SENSOR SETUP ---
#define DHT_TYPE DHT22   // Change to DHT11 if that's what you have
DHT dht(DHT_PIN, DHT_TYPE);
OneWire oneWire(ONEWIRE_BUS_PIN);
DallasTemperature sensors(&oneWire);

// --- GLOBAL TIMER VARIABLES ---
// These are used by the loop to track time
unsigned long lastSensorRead = 0;
unsigned long lastWateringCycleStart = 0;
unsigned long lastPumpOnTime = 0;
unsigned long lastFanOnTime = 0;

// --- STATE MANAGEMENT ---
// This tracks what the watering system is doing
// 0 = IDLE, 1 = PUMPING, 2 = FAN_ONLY
int wateringState = 0;

void setup() {
  Serial.begin(115200);
  Serial.println("Arduino Hydroponics Automation - OFFLINE SCRIPT");

  // Set relay pins to output and turn them all off
  pinMode(LIGHT_RELAY_PIN, OUTPUT);
  pinMode(PUMP_RELAY_PIN, OUTPUT);
  pinMode(FAN_RELAY_PIN, OUTPUT);
  
  digitalWrite(LIGHT_RELAY_PIN, RELAY_OFF);
  digitalWrite(PUMP_RELAY_PIN, RELAY_OFF);
  digitalWrite(FAN_RELAY_PIN, RELAY_OFF);

  // Start sensors
  dht.begin();
  sensors.begin();
}

void handleLights() {
  // Get the "time since boot" and find where we are in a 24-hour cycle
  unsigned long timeOfDay = millis() % (LIGHT_CYCLE_DURATION + DARK_CYCLE_DURATION);

  if (timeOfDay < LIGHT_CYCLE_DURATION) {
    // We are in the "Lights ON" part of the cycle
    digitalWrite(LIGHT_RELAY_PIN, RELAY_ON);
  } else {
    // We are in the "Lights OFF" part of the cycle
    digitalWrite(LIGHT_RELAY_PIN, RELAY_OFF);
  }
}

void handleWatering(unsigned long now) {
  
  // State 0: IDLE (Waiting for next cycle)
  if (wateringState == 0) {
    if (now - lastWateringCycleStart >= PUMP_CYCLE_INTERVAL) {
      // Time to start the pump
      Serial.println("Starting pump...");
      digitalWrite(PUMP_RELAY_PIN, RELAY_ON);
      
      lastPumpOnTime = now; // Record when the pump turned on
      wateringState = 1;      // Move to "PUMPING" state
    }
  }

  // State 1: PUMPING (Pump is running)
  else if (wateringState == 1) {
    if (now - lastPumpOnTime >= PUMP_ON_DURATION) {
      // Pump has run long enough, turn it off
      digitalWrite(PUMP_RELAY_PIN, RELAY_OFF);
      
      // Now, turn on the root fan
      Serial.println("Pump OFF. Starting root fan...");
      digitalWrite(FAN_RELAY_PIN, RELAY_ON);
      
      lastFanOnTime = now; // Record when the fan turned on
      wateringState = 2;   // Move to "FAN_ONLY" state
    }
  }

  // State 2: FAN_ONLY (Fan is running)
  else if (wateringState == 2) {
    if (now - lastFanOnTime >= FAN_ON_DURATION) {
      // Fan has run long enough, turn it off
      Serial.println("Fan OFF. Cycle complete.");
      digitalWrite(FAN_RELAY_PIN, RELAY_OFF);
      
      wateringState = 0; // Return to "IDLE" state
      lastWateringCycleStart = now; // Reset the main cycle timer
    }
  }
}

void readSensors(unsigned long now) {
  if (now - lastSensorRead >= SENSOR_READ_INTERVAL) {
    lastSensorRead = now; // Reset the sensor timer

    // Read Air Temp & Humidity
    float h = dht.readHumidity();
    float t = dht.readTemperature(); // Celsius

    // Read Water Temp
    sensors.requestTemperatures();
    float waterTempC = sensors.getTempCByIndex(0);

    // Print all data to the Serial Monitor
    Serial.println("--- SENSOR READ ---");
    Serial.print("Air Temp: "); Serial.print(t); Serial.println(" *C");
    Serial.print("Humidity: "); Serial.print(h); Serial.println(" %");
    Serial.print("Water Temp: "); Serial.print(waterTempC); Serial.println(" *C");
    Serial.println("---------------------");
  }
}

void loop() {
  // Get the current time once at the start of the loop
  unsigned long currentMillis = millis();

  // Call each automation function.
  // They will decide for themselves if it's time to act.
  handleLights();
  handleWatering(currentMillis);
  readSensors(currentMillis);
}

// LIBRARIES
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>


// --- 1. PIN DEFINITIONS ---
#define LIGHT_RELAY_PIN   4
#define PUMP_RELAY_PIN    5
#define FAN_RELAY_PIN     6
#define DHT_PIN           7
#define ONEWIRE_BUS_PIN   8

// --- 2. RELAY STATE ---
// Change to HIGH if your relays are "HIGH Active"
#define RELAY_ON  LOW
#define RELAY_OFF HIGH

// --- 3. AUTOMATION TIMERS (in milliseconds) ---
// Light Cycle (18 hours ON, 6 hours OFF)
const unsigned long LIGHT_CYCLE_DURATION = 18UL * 60 * 60 * 1000; // 18 hours
const unsigned long DARK_CYCLE_DURATION  = 6UL * 60 * 60 * 1000;  // 6 hours

// Watering Cycle (Pump ON for 30s, every 15 min)
const unsigned long PUMP_ON_DURATION = 30000UL;      // 30 seconds
const unsigned long PUMP_CYCLE_INTERVAL = 15UL * 60 * 1000; // 15 minutes

// Fan Cycle (Fan ON for 2 min after pumping)
const unsigned long FAN_ON_DURATION = 120000UL;     // 2 minutes

// Sensor Reading (Read every 5 seconds)
const unsigned long SENSOR_READ_INTERVAL = 5000UL;

// --- 4. SENSOR SETUP ---
#define DHT_TYPE DHT22   // Change to DHT11 if needed
DHT dht(DHT_PIN, DHT_TYPE);
OneWire oneWire(ONEWIRE_BUS_PIN);
DallasTemperature sensors(&oneWire);

// --- 5. GLOBAL TIMER & STATE VARIABLES ---
unsigned long lastSensorRead = 0;
unsigned long lastWateringCycleStart = 0;
unsigned long lastPumpOnTime = 0;
unsigned long lastFanOnTime = 0;
int wateringState = 0; // 0=IDLE, 1=PUMPING, 2=FAN_ONLY

// =======================================================
//   SETUP: Runs once at the beginning
// =======================================================
void setup() {
  Serial.begin(115200);
  Serial.println("Arduino Hydroponics Automation - OFFLINE SCRIPT");

  // Set relay pins to output and turn them all off
  pinMode(LIGHT_RELAY_PIN, OUTPUT);
  pinMode(PUMP_RELAY_PIN, OUTPUT);
  pinMode(FAN_RELAY_PIN, OUTPUT);
  
  digitalWrite(LIGHT_RELAY_PIN, RELAY_OFF);
  digitalWrite(PUMP_RELAY_PIN, RELAY_OFF);
  digitalWrite(FAN_RELAY_PIN, RELAY_OFF);

  // Start sensors
  dht.begin();
  sensors.begin();
}

// =======================================================
//   LOOP: Runs constantly
// =======================================================
void loop() {
  // Get the current time once at the start of the loop
  unsigned long currentMillis = millis();

  // Call each automation function.
  // They will decide for themselves if it's time to act.
  handleLights();
  handleWatering(currentMillis);
  readSensors(currentMillis);
}

// =======================================================
//   AUTOMATION FUNCTIONS
// =======================================================

/**
 * Handles the 24-hour light cycle.
 * WARNING: This is based on when the Arduino was plugged in.
 * If power is lost, the cycle resets.
 */
void handleLights() {
  unsigned long timeOfDay = millis() % (LIGHT_CYCLE_DURATION + DARK_CYCLE_DURATION);

  if (timeOfDay < LIGHT_CYCLE_DURATION) {
    digitalWrite(LIGHT_RELAY_PIN, RELAY_ON);
  } else {
    digitalWrite(LIGHT_RELAY_PIN, RELAY_OFF);
  }
}

/**
 * Handles the watering state machine.
 * 0=IDLE, 1=PUMPING, 2=FAN_ONLY
 */
void handleWatering(unsigned long now) {
  
  // State 0: IDLE (Waiting for next cycle)
  if (wateringState == 0) {
    if (now - lastWateringCycleStart >= PUMP_CYCLE_INTERVAL) {
      Serial.println("Starting pump...");
      digitalWrite(PUMP_RELAY_PIN, RELAY_ON);
      lastPumpOnTime = now; 
      wateringState = 1;      
    }
  }

  // State 1: PUMPING (Pump is running)
  else if (wateringState == 1) {
    if (now - lastPumpOnTime >= PUMP_ON_DURATION) {
      digitalWrite(PUMP_RELAY_PIN, RELAY_OFF);
      Serial.println("Pump OFF. Starting root fan...");
      digitalWrite(FAN_RELAY_PIN, RELAY_ON);
      lastFanOnTime = now; 
      wateringState = 2;   
    }
  }

  // State 2: FAN_ONLY (Fan is running)
  else if (wateringState == 2) {
    if (now - lastFanOnTime >= FAN_ON_DURATION) {
      Serial.println("Fan OFF. Cycle complete.");
      digitalWrite(FAN_RELAY_PIN, RELAY_OFF);
      wateringState = 0; 
      lastWateringCycleStart = now; 
    }
  }
}

/**
 * Reads all sensors and prints to Serial Monitor
 */
void readSensors(unsigned long now) {
  if (now - lastSensorRead >= SENSOR_READ_INTERVAL) {
    lastSensorRead = now; 

    float h = dht.readHumidity();
    float t = dht.readTemperature();
    sensors.requestTemperatures();
    float waterTempC = sensors.getTempCByIndex(0);

    Serial.println("--- SENSOR READ ---");
    Serial.print("Air Temp: "); Serial.print(t); Serial.println(" *C");
    Serial.print("Humidity: "); Serial.print(h); Serial.println(" %");
    Serial.print("Water Temp: "); Serial.print(waterTempC); Serial.println(" *C");
    Serial.println("---------------------");
  }
}

#include <LiquidCrystal_I2C.h>


// Initialize LCD (address 0x27 is common, 4 rows, 20 cols)
LiquidCrystal_I2C lcd(0x27, 20, 4); 

void setup() {
  // ... (inside your existing setup function)
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("GEIA Offline v1.0");
}

// Modify your readSensors() function:
void readSensors(unsigned long now) {
  if (now - lastSensorRead >= SENSOR_READ_INTERVAL) {
    // ... (all the sensor reading code is the same)
    
    // --- OLD SERIAL CODE ---
    // Serial.println("--- SENSOR READ ---");
    // ...

    // --- NEW LCD CODE ---
    // Row 0: Air Temp / Humidity
    lcd.setCursor(0, 0);
    lcd.print("Air: ");
    lcd.print(t);
    lcd.print("C  ");
    lcd.print(h);
    lcd.print("%   ");

    // Row 1: Water Temp
    lcd.setCursor(0, 1);
    lcd.print("Water Temp: ");
    lcd.print(waterTempC);
    lcd.print("C  ");

    // Row 2: Watering Status
    lcd.setCursor(0, 2);
    lcd.print("Water Status: ");
    if (wateringState == 0) lcd.print("IDLE    ");
    if (wateringState == 1) lcd.print("PUMPING ");
    if (wateringState == 2) lcd.print("FAN ON  ");
    
    // Row 3: Light Status
    lcd.setCursor(0, 3);
    lcd.print("Lights: ");
    if (digitalRead(LIGHT_RELAY_PIN) == RELAY_ON) lcd.print("ON      ");
    else lcd.print("OFF     ");
  }
}