index.cpp

#include <WiFi.h>
#include <HTTPClient.h>
#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <UniversalTelegramBot.h>
#include <ArduinoJson.h>
#include <esp_system.h>

// ==================== PIN DEFINITIONS ====================
#define DHTPIN 13
#define DHTTYPE DHT22
#define SOIL_PIN 34
#define LDR_PIN 35
#define RAIN_PIN 32
#define WATER_LEVEL_PIN 33
#define PUMP_RELAY 16
#define FAN1_RELAY 26
#define FAN2_RELAY 27
#define MANUAL_BUTTON 4
#define WIFI_STATUS_LED 2

#define PROJECT_NAME "SmartFarm"
#define VERSION "v3.2"

// ==================== TEMPERATURE THRESHOLDS ====================
#define TEMP_FAN1_ON 22
#define TEMP_FAN1_OFF 18
#define TEMP_FAN2_ON 24
#define TEMP_FAN2_OFF 20
#define TEMP_CRITICAL 35

// ==================== SOIL MOISTURE THRESHOLDS (0-4095) ====================
#define SOIL_VERY_DRY 3500
#define SOIL_DRY 2800
#define SOIL_OPTIMAL_MAX 2200
#define SOIL_WET 1500
#define SOIL_VERY_WET 800

// ==================== RAIN SENSOR THRESHOLDS ====================
#define RAIN_CLEAR 3500
#define RAIN_LIGHT 2500
#define RAIN_THRESHOLD 3500
#define RAIN_HEAVY 1000
#define RAIN_HEAVY_THRESH 1500

// ==================== WATER LEVEL THRESHOLDS (higher = more water) ====================
#define WATER_CRITICAL 1000
#define WATER_PUMP_OFF 2400
#define WATER_PUMP_ON 2600
#define WATER_FULL 4500

// ==================== NETWORK & CLOUD ====================
#define THINGSPEAK_WRITE_KEY "NC47N46ACJUARDCK"
const char *server = "http://api.thingspeak.com/update";

const char *ssid = "Kuet21";
const char *password = "89777145!!";

#define BOT_TOKEN "8435066468:AAGJiyvhtlUxYoXluewx7oV0zcy53vYaXaM"
#define CHAT_ID "6436948731"
WiFiClientSecure secured_client;
UniversalTelegramBot bot(BOT_TOKEN, secured_client);

// ==================== TIMING INTERVALS (ms) ====================
#define UPLOAD_INTERVAL 15000
#define SENSOR_READ_INTERVAL 1000
#define LCD_UPDATE_INTERVAL 500
#define TELEGRAM_ALERT_INTERVAL 60000
#define TELEGRAM_STATUS_INTERVAL 600000
#define TELEGRAM_POLL_INTERVAL 2000

#define RELAY_SWITCH_DELAY 50 // minimum time between relay changes

// ==================== PUMP TIMING & SAFETY ====================
const unsigned long MIN_PUMP_ON_TIME = 10000;
const unsigned long MIN_PUMP_OFF_TIME = 10000;
const unsigned long SAFETY_STARTUP_DELAY = 5000;
bool systemReady = false;

DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2);

unsigned long lastUpload = 0;
unsigned long lastSensorRead = 0;
unsigned long lastLCDUpdate = 0;
unsigned long lastTelegramAlert = 0;
unsigned long lastTelegramStatus = 0;
unsigned long lastTelegramPoll = 0;
unsigned long lastDHTRead = 0;
unsigned long pumpStartTime = 0;
unsigned long lastPumpChange = 0;

float temperature = 0;
float humidity = 0;
int soilMoisture = 0;
int lightLevel = 0;
int rainLevel = 0;
int waterLevel = 0;

bool pumpStatus = false;
bool fan1Status = false;
bool fan2Status = false;
bool manualMode = false;
bool manualPumpRequest = false;
bool isRaining = false;
bool isHeavyRain = false;

int lcdScreen = 0;
const int TOTAL_SCREENS = 7;

bool criticalTempAlertSent = false;
bool criticalWaterAlertSent = false;
bool criticalSoilAlertSent = false;
bool heavyRainAlertSent = false;
bool pumpStuckAlertSent = false;
bool wifiDisconnectAlertSent = false;
bool dhtFaultAlertSent = false;

String pumpReason = "";
String activeFaults = "";
unsigned long faultStartTime = 0;

// Moving average buffers
const int AVG_SAMPLES = 5;
int waterReadings[5] = {0};
int soilReadings[5] = {0};
int waterIndex = 0, soilIndex = 0;
int waterTotal = 0, soilTotal = 0;

// Debug
unsigned long lastDebugPrint = 0;
#define DEBUG_INTERVAL 5000

// ---------- Non‑blocking relay control ----------
unsigned long lastRelayChange = 0; // timestamp of last relay write
bool pendingRelayChanges = false;  // flag to retry on next loop

struct RelayCommand
{
  uint8_t pin;
  bool state; // true = LOW (relay ON), false = HIGH (relay OFF)
};
RelayCommand nextRelayCmd; // command to execute when cooldown allows

// ==================== FUNCTION DECLARATIONS ====================
String getTimeString();
String getSoilCondition();
String getRainCondition();
String getPlantGrowthStatus();
bool isSoilDry();
bool isSoilVeryDry();
bool isSoilWet();
bool shouldPumpRun();
void checkAndReportFaults();
void sendStatusUpdate();
void readSensors();
void controlIrrigation();
void controlPoultryFans();
void checkButton();
void updateLCD();
void printData();
void sendToThingSpeak();
void handleTelegramMessages();
void debugManualState();
void debugWaterLevelLogic();
void setRelayNonBlocking(uint8_t pin, bool state);

// ==================== UTILITY ====================
void printResetReason()
{
  esp_reset_reason_t reason = esp_reset_reason();
  Serial.print("Reset reason: ");
  switch (reason)
  {
  case ESP_RST_POWERON:
    Serial.println("Power-on");
    break;
  case ESP_RST_EXT:
    Serial.println("External pin");
    break;
  case ESP_RST_SW:
    Serial.println("Software");
    break;
  case ESP_RST_PANIC:
    Serial.println("Exception/panic");
    break;
  case ESP_RST_INT_WDT:
    Serial.println("Interrupt watchdog");
    break;
  case ESP_RST_TASK_WDT:
    Serial.println("Task watchdog");
    break;
  case ESP_RST_WDT:
    Serial.println("Other watchdog");
    break;
  case ESP_RST_DEEPSLEEP:
    Serial.println("Deep sleep wake");
    break;
  case ESP_RST_BROWNOUT:
    Serial.println("Brownout (power dip!)");
    break;
  case ESP_RST_SDIO:
    Serial.println("SDIO");
    break;
  default:
    Serial.println("Unknown");
  }
}

String getTimeString()
{
  unsigned long seconds = millis() / 1000;
  int hours = (seconds / 3600) % 24;
  int minutes = (seconds / 60) % 60;
  int secs = seconds % 60;
  char timeStr[9];
  sprintf(timeStr, "%02d:%02d:%02d", hours, minutes, secs);
  return String(timeStr);
}

// ==================== SOIL / RAIN / PLANT ====================
String getSoilCondition()
{
  if (soilMoisture > SOIL_VERY_DRY)
    return "VERY DRY";
  if (soilMoisture > SOIL_DRY)
    return "DRY";
  if (soilMoisture > SOIL_OPTIMAL_MAX)
    return "OPTIMAL";
  if (soilMoisture > SOIL_WET)
    return "WET";
  return "VERY WET";
}
bool isSoilDry() { return (soilMoisture > SOIL_DRY); }
bool isSoilVeryDry() { return (soilMoisture > SOIL_VERY_DRY); }
bool isSoilWet() { return (soilMoisture < SOIL_WET); }

String getRainCondition()
{
  if (rainLevel < RAIN_HEAVY_THRESH)
    return "HEAVY";
  if (rainLevel < RAIN_THRESHOLD)
    return "LIGHT";
  if (rainLevel > RAIN_CLEAR)
    return "CLEAR";
  return "DAMP";
}

String getPlantGrowthStatus()
{
  if (soilMoisture == 0 || lightLevel == 0)
    return "SENSOR ERR";
  bool soilGood = (soilMoisture >= SOIL_WET && soilMoisture <= SOIL_DRY);
  bool lightGood = (lightLevel > 1500);
  if (soilMoisture > SOIL_VERY_DRY)
    return "WILTING!";
  if (soilMoisture < SOIL_VERY_WET)
    return "ROT!";
  if (lightLevel < 500)
    return "NO LIGHT!";
  if (soilGood && lightGood)
    return "THRIVING!";
  if (!soilGood && !lightGood)
    return "CRITICAL";
  if (!soilGood)
    return "SOIL BAD";
  if (!lightGood)
    return "LIGHT BAD";
  return "FAIR";
}

// ==================== PUMP DECISION (HYSTERESIS + SAFETY) ====================
// Safety overrides ALWAYS take precedence.
// Hysteresis: pump stays ON until water drops below OFF threshold;
//             pump stays OFF until water rises above ON threshold.
bool shouldPumpRun()
{
  if (!systemReady)
  {
    pumpReason = "System starting";
    return false;
  }

  // 1. CRITICAL SAFETY – absolute block
  if (waterLevel < WATER_CRITICAL)
  {
    pumpReason = "EMERGENCY: Critical low water";
    return false;
  }

  // 2. TANK FULL PROTECTION – prevent overflow
  if (waterLevel > WATER_FULL)
  {
    pumpReason = "Tank full - overflow prevention";
    return false;
  }

  // 3. HYSTERESIS (stable ON/OFF)
  if (pumpStatus)
  {
    // Pump is ON → keep ON until water drops below OFF threshold
    if (waterLevel < WATER_PUMP_OFF)
    {
      pumpReason = "Water dropped below OFF threshold";
      return false;
    }
  }
  else
  {
    // Pump is OFF → only allow start if water is above ON threshold
    if (waterLevel < WATER_PUMP_ON)
    {
      pumpReason = "Water too low to start (needs >" + String(WATER_PUMP_ON) + ")";
      return false;
    }
  }

  // 4. MANUAL OVERRIDE (safety already applied above)
  if (manualMode)
  {
    pumpReason = manualPumpRequest ? "Manual ON" : "Manual OFF";
    return manualPumpRequest;
  }

  // 5. RAIN LOGIC
  if (isHeavyRain)
  {
    pumpReason = "Heavy rain - pump disabled";
    return false;
  }
  if (isRaining)
  {
    if (isSoilVeryDry())
    {
      pumpReason = "Light rain, but soil VERY dry";
      return true;
    }
    else
    {
      pumpReason = "Raining, soil moisture OK";
      return false;
    }
  }

  // 6. SOIL MOISTURE
  if (isSoilVeryDry())
  {
    pumpReason = "Soil VERY dry - urgent watering needed";
    return true;
  }
  if (isSoilDry())
  {
    pumpReason = "Soil dry - watering needed";
    return true;
  }

  if (soilMoisture <= SOIL_OPTIMAL_MAX)
  {
    pumpReason = "Soil moisture optimal";
    return false;
  }
  if (isSoilWet())
  {
    pumpReason = "Soil wet - no watering needed";
    return false;
  }

  pumpReason = "Conditions not met for watering";
  return false;
}

// ==================== DEBUG ====================
void debugWaterLevelLogic()
{
  Serial.println("\n========== WATER LEVEL DEBUG ==========");
  Serial.print("Water Level Reading: ");
  Serial.println(waterLevel);
  Serial.print("Pump Status: ");
  Serial.println(pumpStatus ? "ON" : "OFF");
  Serial.print("Manual Mode: ");
  Serial.println(manualMode ? "YES" : "NO");
  Serial.println("\nThresholds:");
  Serial.print("  CRITICAL: < ");
  Serial.print(WATER_CRITICAL);
  Serial.print(" (Current: ");
  Serial.print(waterLevel < WATER_CRITICAL ? "BELOW" : "ABOVE");
  Serial.println(")");
  Serial.print("  PUMP OFF: < ");
  Serial.print(WATER_PUMP_OFF);
  Serial.print(" (Current: ");
  Serial.print(waterLevel < WATER_PUMP_OFF ? "BELOW" : "ABOVE");
  Serial.println(")");
  Serial.print("  PUMP ON : > ");
  Serial.print(WATER_PUMP_ON);
  Serial.print(" (Current: ");
  Serial.print(waterLevel >= WATER_PUMP_ON ? "ABOVE" : "BELOW");
  Serial.println(")");
  Serial.print("  FULL    : > ");
  Serial.print(WATER_FULL);
  Serial.print(" (Current: ");
  Serial.print(waterLevel > WATER_FULL ? "ABOVE" : "BELOW");
  Serial.println(")");
  Serial.println("\nDecision:");
  Serial.print("  Pump reason: ");
  Serial.println(pumpReason);
  Serial.println("========================================\n");
}

// ==================== TELEGRAM & FAULTS ====================
void sendTelegramMessage(String message, bool isAlert)
{
  if (WiFi.status() != WL_CONNECTED)
    return;
  String prefix = isAlert ? "⚠️ ALERT: " : "📱 ";
  String fullMessage = prefix + message + "\n\n⏰ Time: " + getTimeString();
  for (int attempts = 0; attempts < 3; attempts++)
  {
    yield();
    if (bot.sendMessage(CHAT_ID, fullMessage, ""))
      break;
    delay(1000);
  }
}

void updateRainStatus()
{
  bool wasRaining = isRaining;
  bool wasHeavyRain = isHeavyRain;
  isHeavyRain = (rainLevel < RAIN_HEAVY_THRESH);
  isRaining = (rainLevel < RAIN_THRESHOLD);
  if (isHeavyRain)
    isRaining = true;

  if (isRaining != wasRaining || isHeavyRain != wasHeavyRain)
  {
    if (isHeavyRain)
      sendTelegramMessage("HEAVY RAIN STARTED!\nPump disabled.\nRain level: " + String(rainLevel), true);
    else if (isRaining && !wasRaining)
      sendTelegramMessage("RAIN DETECTED!\nPump only if soil very dry.\nRain level: " + String(rainLevel), true);
    else if (!isRaining && wasRaining)
      sendTelegramMessage("RAIN STOPPED!\nResuming normal pump.\nRain level: " + String(rainLevel), true);
  }
}

void checkAndReportFaults()
{
  String currentFaults = "";
  bool hasFault = false;

  if (temperature > TEMP_CRITICAL)
  {
    currentFaults += "🔥 CRITICAL TEMPERATURE: " + String(temperature, 1) + "°C\n";
    hasFault = true;
    if (!criticalTempAlertSent)
    {
      sendTelegramMessage("⚠️ CRITICAL TEMPERATURE FAULT!\nTemperature: " + String(temperature, 1) + "°C\nBoth fans activated automatically!", true);
      criticalTempAlertSent = true;
    }
  }
  else if (temperature < 5 && temperature > 0)
  {
    currentFaults += "❄️ VERY LOW TEMPERATURE: " + String(temperature, 1) + "°C\n";
    hasFault = true;
    if (!criticalTempAlertSent)
    {
      sendTelegramMessage("⚠️ LOW TEMPERATURE FAULT!\nTemperature: " + String(temperature, 1) + "°C\nPlant frost risk detected!", true);
      criticalTempAlertSent = true;
    }
  }
  else
  {
    criticalTempAlertSent = false;
  }

  if (waterLevel < WATER_CRITICAL)
  {
    currentFaults += "💧 CRITICAL WATER LEVEL: " + String(waterLevel) + "\n";
    hasFault = true;
    if (!criticalWaterAlertSent)
    {
      sendTelegramMessage("⚠️ CRITICAL WATER FAULT!\nWater level critically low: " + String(waterLevel) + "\nPump emergency stopped!\nPlease refill water tank immediately!", true);
      criticalWaterAlertSent = true;
    }
  }
  else if (waterLevel < WATER_PUMP_OFF)
  {
    currentFaults += "💧 LOW WATER LEVEL: " + String(waterLevel) + "\n";
    hasFault = true;
    if (!criticalWaterAlertSent)
    {
      sendTelegramMessage("⚠️ LOW WATER WARNING!\nWater level low: " + String(waterLevel) + "\nPlease refill water tank soon.", true);
      criticalWaterAlertSent = true;
    }
  }
  else if (waterLevel > WATER_FULL)
  {
    currentFaults += "💧 TANK FULL: " + String(waterLevel) + "\n";
    hasFault = true;
  }
  else
  {
    criticalWaterAlertSent = false;
  }

  // Other fault checks (soil, pump stuck, etc.) remain unchanged for brevity.
  // ... [Include your existing fault checks here]

  if (hasFault)
  {
    if (activeFaults != currentFaults)
    {
      if (activeFaults != "")
        sendTelegramMessage("📋 FAULT SUMMARY:\n" + currentFaults, true);
      activeFaults = currentFaults;
      faultStartTime = millis();
    }
  }
  else
  {
    if (activeFaults != "")
    {
      sendTelegramMessage("✅ All faults cleared!\nSystem restored to normal operation.", true);
      activeFaults = "";
    }
  }
}

void sendStatusUpdate()
{
  String status = "📊 SYSTEM STATUS REPORT\n\n";
  status += "🌡️ Temperature: " + String(temperature, 1) + "°C\n";
  status += "💧 Humidity: " + String(humidity, 1) + "%\n";
  status += "🌱 Soil Moisture: " + String(soilMoisture) + " (" + getSoilCondition() + ")\n";
  status += "💧 Water Level: " + String(waterLevel);
  if (waterLevel < WATER_CRITICAL)
    status += " (CRITICAL!)";
  else if (waterLevel < WATER_PUMP_OFF)
    status += " (LOW)";
  else if (waterLevel > WATER_FULL)
    status += " (FULL)";
  else
    status += " (OK)";
  status += "\n☀️ Light: " + String(lightLevel) + "\n";
  status += "☔ Rain: " + getRainCondition() + " (" + String(rainLevel) + ")\n";
  status += "💧 Pump: " + String(pumpStatus ? "ON" : "OFF");
  if (pumpStatus)
    status += " (" + pumpReason + ")";
  status += "\n🌀 Fan1: " + String(fan1Status ? "ON" : "OFF");
  status += "  Fan2: " + String(fan2Status ? "ON" : "OFF") + "\n";
  status += "⚙️ Mode: " + String(manualMode ? "MANUAL" : "AUTO") + "\n";
  status += "🌱 Plant: " + getPlantGrowthStatus();
  sendTelegramMessage(status, false);
}

// ==================== SENSOR READING ====================
void readSensors()
{
  int rawSoil = analogRead(SOIL_PIN);
  int rawWater = analogRead(WATER_LEVEL_PIN);

  waterTotal -= waterReadings[waterIndex];
  waterReadings[waterIndex] = rawWater;
  waterTotal += rawWater;
  waterIndex = (waterIndex + 1) % AVG_SAMPLES;
  waterLevel = waterTotal / AVG_SAMPLES;

  soilTotal -= soilReadings[soilIndex];
  soilReadings[soilIndex] = rawSoil;
  soilTotal += rawSoil;
  soilIndex = (soilIndex + 1) % AVG_SAMPLES;
  soilMoisture = soilTotal / AVG_SAMPLES;

  lightLevel = analogRead(LDR_PIN);
  rainLevel = analogRead(RAIN_PIN);

  if (millis() - lastDHTRead >= 2000)
  {
    lastDHTRead = millis();
    float newTemp = dht.readTemperature();
    float newHum = dht.readHumidity();
    if (!isnan(newTemp))
      temperature = newTemp;
    if (!isnan(newHum))
      humidity = newHum;
  }
  updateRainStatus();
}

// ---------- Non‑blocking relay setter ----------
// Schedules a relay change; the change happens immediately if cooldown allows,
// otherwise it is queued for the next loop iteration.
void setRelayNonBlocking(uint8_t pin, bool state)
{
  // If cooldown has passed, execute immediately
  if (millis() - lastRelayChange >= RELAY_SWITCH_DELAY)
  {
    digitalWrite(pin, state ? LOW : HIGH); // active LOW
    lastRelayChange = millis();
    pendingRelayChanges = false;
  }
  else
  {
    // Queue the command for next opportunity
    nextRelayCmd.pin = pin;
    nextRelayCmd.state = state;
    pendingRelayChanges = true;
  }
}

// Call this in loop() to process any queued relay command
void processPendingRelay()
{
  if (pendingRelayChanges && (millis() - lastRelayChange >= RELAY_SWITCH_DELAY))
  {
    digitalWrite(nextRelayCmd.pin, nextRelayCmd.state ? LOW : HIGH);
    lastRelayChange = millis();
    pendingRelayChanges = false;
  }
}

// ==================== AGRICULTURE CONTROL (PUMP ONLY) ====================
void controlIrrigation()
{
  bool newPumpState;

  if (manualMode)
  {
    // Manual mode – enforce safety
    if (waterLevel < WATER_CRITICAL)
    {
      newPumpState = false;
      pumpReason = "Manual blocked: Critical low water";
    }
    else if (waterLevel > WATER_FULL && manualPumpRequest)
    {
      newPumpState = false;
      pumpReason = "Manual blocked: Tank full";
    }
    else
    {
      newPumpState = manualPumpRequest;
      pumpReason = manualPumpRequest ? "Manual ON" : "Manual OFF";
    }
  }
  else
  {
    newPumpState = shouldPumpRun();
  }

  if (newPumpState != pumpStatus)
  {
    unsigned long timeSinceLastChange = millis() - lastPumpChange;
    unsigned long requiredDelay = pumpStatus ? MIN_PUMP_OFF_TIME : MIN_PUMP_ON_TIME;

    if (timeSinceLastChange >= requiredDelay)
    {
      pumpStatus = newPumpState;
      setRelayNonBlocking(PUMP_RELAY, pumpStatus); // non‑blocking
      lastPumpChange = millis();

      Serial.printf("PUMP: %s | Water: %d | Soil: %d | Reason: %s\n",
                    pumpStatus ? "ON" : "OFF", waterLevel, soilMoisture, pumpReason.c_str());

      if (pumpStatus)
      {
        pumpStartTime = millis();
        sendTelegramMessage("💧 PUMP TURNED ON\nReason: " + pumpReason, false);
      }
      else
      {
        if (pumpReason != "Conditions not met" && pumpReason != "Soil optimal" && pumpReason != "Soil wet")
          sendTelegramMessage("💧 PUMP TURNED OFF\nReason: " + pumpReason, false);
      }
    }
  }

  // Pump stuck protection
  if (pumpStatus && (millis() - pumpStartTime > 1800000))
  {
    pumpStatus = false;
    setRelayNonBlocking(PUMP_RELAY, false);
    lastPumpChange = millis();
    sendTelegramMessage("⚠️ PUMP AUTO-SHUTDOWN\nRan 30 min! Check for leaks!", true);
  }
}

// ==================== POULTRY CONTROL (FANS ONLY) ====================
void controlPoultryFans()
{
  // Fan 1
  bool newFan1 = fan1Status;
  if (temperature > TEMP_FAN1_ON)
    newFan1 = true;
  else if (temperature < TEMP_FAN1_OFF)
    newFan1 = false;

  if (newFan1 != fan1Status)
  {
    fan1Status = newFan1;
    setRelayNonBlocking(FAN1_RELAY, fan1Status);
    if (fan1Status)
      sendTelegramMessage("🌀 FAN 1 ACTIVATED\nTemperature: " + String(temperature, 1) + "°C", false);
  }

  // Fan 2
  bool newFan2 = fan2Status;
  if (temperature > TEMP_FAN2_ON)
    newFan2 = true;
  else if (temperature < TEMP_FAN2_OFF)
    newFan2 = false;

  if (newFan2 != fan2Status)
  {
    fan2Status = newFan2;
    setRelayNonBlocking(FAN2_RELAY, fan2Status);
    if (fan2Status)
      sendTelegramMessage("🌀🌀 FAN 2 ACTIVATED\nTemperature: " + String(temperature, 1) + "°C", false);
  }

  // Critical temperature override
  if (temperature > TEMP_CRITICAL)
  {
    if (!fan1Status)
    {
      fan1Status = true;
      setRelayNonBlocking(FAN1_RELAY, true);
    }
    if (!fan2Status)
    {
      fan2Status = true;
      setRelayNonBlocking(FAN2_RELAY, true);
    }
  }
}

// ==================== BUTTON HANDLING ====================
void checkButton()
{
  static unsigned long lastDebounceTime = 0;
  static bool lastButtonState = HIGH;
  static bool buttonState = HIGH;
  static unsigned long pressStart = 0;
  static bool longPressDetected = false;
  const unsigned long debounceDelay = 50;
  const unsigned long longPressTime = 2000;

  bool reading = digitalRead(MANUAL_BUTTON);
  if (reading != lastButtonState)
    lastDebounceTime = millis();

  if ((millis() - lastDebounceTime) > debounceDelay)
  {
    if (reading != buttonState)
    {
      buttonState = reading;
      if (buttonState == LOW)
      {
        pressStart = millis();
        longPressDetected = false;
      }
      else
      {
        if (!longPressDetected)
        {
          manualMode = !manualMode;
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print(PROJECT_NAME);
          lcd.print(" ");
          lcd.print(VERSION);
          lcd.setCursor(0, 1);
          lcd.print("Mode: ");
          lcd.print(manualMode ? "MANUAL" : "AUTO");
          delay(1500);
          lcd.clear();
          lcdScreen = -1;
          sendTelegramMessage("🔄 SYSTEM MODE CHANGED\nMode: " + String(manualMode ? "MANUAL" : "AUTO"), false);
          controlIrrigation();
        }
      }
    }
    if (buttonState == LOW && !longPressDetected && (millis() - pressStart >= longPressTime))
    {
      longPressDetected = true;
      if (manualMode)
      {
        manualPumpRequest = !manualPumpRequest;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print(PROJECT_NAME);
        lcd.print(" ");
        lcd.print(VERSION);
        lcd.setCursor(0, 1);
        lcd.print("Pump ");
        lcd.print(manualPumpRequest ? "ON" : "OFF");
        delay(1500);
        lcd.clear();
        lcdScreen = -1;
        sendTelegramMessage("💧 MANUAL PUMP CONTROL\nPump: " + String(manualPumpRequest ? "ON" : "OFF"), false);
        controlIrrigation();
      }
    }
  }
  lastButtonState = reading;
}

// ==================== LCD ====================
void updateLCD()
{
  if (millis() - lastLCDUpdate < LCD_UPDATE_INTERVAL)
    return;
  lastLCDUpdate = millis();
  lcdScreen = (lcdScreen + 1) % TOTAL_SCREENS;
  lcd.clear();

  switch (lcdScreen)
  {
  case 0:
    lcd.setCursor(0, 0);
    lcd.print(PROJECT_NAME);
    lcd.print(" ");
    lcd.print(VERSION);
    lcd.setCursor(0, 1);
    lcd.print("Uptime: ");
    lcd.print(getTimeString());
    break;
  case 1:
    lcd.setCursor(0, 0);
    lcd.print("Temp:");
    lcd.setCursor(0, 1);
    lcd.print(temperature, 1);
    lcd.print("C");
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print("Humidity:");
    lcd.setCursor(0, 1);
    lcd.print(humidity, 1);
    lcd.print("%");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print("Water:");
    lcd.setCursor(0, 1);
    lcd.print(waterLevel);
    lcd.print(" (");
    if (waterLevel >= WATER_PUMP_ON)
      lcd.print("HIGH");
    else if (waterLevel < WATER_PUMP_OFF)
      lcd.print("LOW");
    else
      lcd.print("MID");
    lcd.print(")");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print("Soil:");
    lcd.print(soilMoisture);
    lcd.print(" ");
    lcd.print(getSoilCondition());
    lcd.setCursor(0, 1);
    lcd.print("Rain:");
    lcd.print(getRainCondition());
    lcd.print(" ");
    lcd.print(rainLevel);
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print("Plant: ");
    lcd.print(getPlantGrowthStatus());
    lcd.setCursor(0, 1);
    lcd.print("Soil:");
    lcd.print(soilMoisture);
    lcd.print(" L:");
    lcd.print(lightLevel);
    break;
  case 6:
    lcd.setCursor(0, 0);
    lcd.print("P:");
    lcd.print(pumpStatus ? "ON " : "OFF");
    lcd.print("F1:");
    lcd.print(fan1Status ? "ON " : "OFF");
    lcd.print("F2:");
    lcd.print(fan2Status ? "ON" : "OFF");
    lcd.setCursor(0, 1);
    lcd.print("Light:");
    lcd.print(lightLevel);
    break;
  }
}

// ==================== SERIAL OUTPUT ====================
void printData()
{
  Serial.println("\n=== " + String(PROJECT_NAME) + " " + String(VERSION) + " ===");
  Serial.print("Uptime: ");
  Serial.println(getTimeString());
  Serial.print("Temp: ");
  Serial.print(temperature);
  Serial.println(" C");
  Serial.print("Humidity: ");
  Serial.print(humidity);
  Serial.println(" %");
  Serial.print("Soil: ");
  Serial.print(soilMoisture);
  Serial.print(" (");
  Serial.print(getSoilCondition());
  Serial.println(")");
  Serial.print("Light: ");
  Serial.println(lightLevel);
  Serial.print("Water: ");
  Serial.println(waterLevel);
  Serial.print("Rain: ");
  Serial.print(rainLevel);
  Serial.print(" - ");
  Serial.println(getRainCondition());
  Serial.print("Pump: ");
  Serial.print(pumpStatus ? "ON" : "OFF");
  Serial.print(" (");
  Serial.print(pumpReason);
  Serial.println(")");
  Serial.print("Plant: ");
  Serial.println(getPlantGrowthStatus());
  Serial.print("Mode: ");
  Serial.println(manualMode ? "MANUAL" : "AUTO");
  Serial.println("================================");

  if (millis() - lastDebugPrint >= DEBUG_INTERVAL)
  {
    lastDebugPrint = millis();
    debugWaterLevelLogic();
  }
}

// ==================== THINGSPEAK ====================
void sendToThingSpeak()
{
  if (WiFi.status() != WL_CONNECTED)
    return;
  HTTPClient http;
  http.setTimeout(5000);
  String url = String(server) + "?api_key=" + THINGSPEAK_WRITE_KEY +
               "&field1=" + String(temperature) + "&field2=" + String(humidity) +
               "&field3=" + String(soilMoisture) + "&field4=" + String(lightLevel) +
               "&field5=" + String(rainLevel) + "&field6=" + String(waterLevel) +
               "&field7=" + String(pumpStatus ? 1 : 0) + "&field8=" + String(isRaining ? 1 : 0);
  http.begin(url);
  yield();
  int httpCode = http.GET();
  if (httpCode == 200)
    Serial.println("✓ ThingSpeak sent");
  else
    Serial.println("✗ ThingSpeak failed");
  http.end();
}

// ==================== TELEGRAM HANDLER ====================
void handleTelegramMessages()
{
  if (WiFi.status() != WL_CONNECTED)
    return;

  int newMessages = bot.getUpdates(bot.last_message_received + 1);
  while (newMessages)
  {
    for (int i = 0; i < newMessages; i++)
    {
      String text = bot.messages[i].text;
      String chat_id = bot.messages[i].chat_id;
      if (chat_id != CHAT_ID)
        continue;

      text.toLowerCase();
      if (text == "/pump_on")
      {
        manualMode = true;
        manualPumpRequest = true;
        bot.sendMessage(chat_id, "✅ Pump ON (Manual mode)", "");
        controlIrrigation();
      }
      else if (text == "/pump_off")
      {
        manualMode = true;
        manualPumpRequest = false;
        bot.sendMessage(chat_id, "✅ Pump OFF (Manual mode)", "");
        controlIrrigation();
      }
      else if (text == "/auto")
      {
        manualMode = false;
        bot.sendMessage(chat_id, "✅ Switched to AUTO mode", "");
        controlIrrigation();
      }
      else if (text == "/status")
      {
        sendStatusUpdate();
      }
      else if (text == "/debug")
      {
        String debugMsg = "🔍 WATER DEBUG:\n";
        debugMsg += "Level: " + String(waterLevel) + "\n";
        debugMsg += "CRIT: " + String(WATER_CRITICAL) + "\n";
        debugMsg += "OFF: " + String(WATER_PUMP_OFF) + "\n";
        debugMsg += "ON: " + String(WATER_PUMP_ON) + "\n";
        debugMsg += "FULL: " + String(WATER_FULL) + "\n";
        debugMsg += "Pump: " + String(pumpStatus ? "ON" : "OFF") + " (" + pumpReason + ")";
        bot.sendMessage(chat_id, debugMsg, "");
      }
      else if (text == "/help")
      {
        String helpMsg = "/pump_on, /pump_off, /auto, /status, /debug, /help";
        bot.sendMessage(chat_id, helpMsg, "");
      }
    }
    newMessages = bot.getUpdates(bot.last_message_received + 1);
    yield();
  }
}

void debugManualState()
{
  static bool lastManual = false, lastReq = false, lastPump = false;
  if (manualMode != lastManual || manualPumpRequest != lastReq || pumpStatus != lastPump)
  {
    Serial.printf("MANUAL DEBUG: Mode=%d Req=%d Pump=%d Reason=%s\n",
                  manualMode, manualPumpRequest, pumpStatus, pumpReason.c_str());
    lastManual = manualMode;
    lastReq = manualPumpRequest;
    lastPump = pumpStatus;
  }
}

// ==================== SETUP & LOOP ====================
void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("\n========================================");
  Serial.print(PROJECT_NAME);
  Serial.print(" ");
  Serial.println(VERSION);
  printResetReason();
  Serial.println("========================================\n");

  pinMode(PUMP_RELAY, OUTPUT);
  digitalWrite(PUMP_RELAY, HIGH);
  pinMode(FAN1_RELAY, OUTPUT);
  digitalWrite(FAN1_RELAY, HIGH);
  pinMode(FAN2_RELAY, OUTPUT);
  digitalWrite(FAN2_RELAY, HIGH);
  pinMode(MANUAL_BUTTON, INPUT_PULLUP);
  pinMode(WIFI_STATUS_LED, OUTPUT);
  digitalWrite(WIFI_STATUS_LED, LOW);

  Wire.begin();
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(PROJECT_NAME);
  lcd.print(" ");
  lcd.print(VERSION);
  lcd.setCursor(0, 1);
  lcd.print("Initializing...");
  delay(2000);

  dht.begin();
  secured_client.setInsecure();

  WiFi.begin(ssid, password);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(PROJECT_NAME);
  lcd.print(" ");
  lcd.print(VERSION);
  lcd.setCursor(0, 1);
  lcd.print("WiFi Connecting");
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 20)
  {
    delay(500);
    attempts++;
    yield();
  }

  if (WiFi.status() == WL_CONNECTED)
  {
    digitalWrite(WIFI_STATUS_LED, HIGH);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(PROJECT_NAME);
    lcd.print(" ");
    lcd.print(VERSION);
    lcd.setCursor(0, 1);
    lcd.print("WiFi OK");
    delay(1500);
    sendTelegramMessage("🌱 SMART FARM SYSTEM STARTED!\nVersion: " + String(VERSION) + "\nMode: AUTO\nCommands: /pump_on, /pump_off, /auto, /status, /debug, /help", false);
  }
  else
  {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(PROJECT_NAME);
    lcd.print(" ");
    lcd.print(VERSION);
    lcd.setCursor(0, 1);
    lcd.print("WiFi Failed");
    delay(1500);
  }

  lcd.clear();
  Serial.println("System ready. Pump will be enabled after safety delay...");
  delay(SAFETY_STARTUP_DELAY);
  systemReady = true;
  Serial.println("Pump control ENABLED.");
}

void loop()
{
  // Process any pending relay change (non‑blocking)
  processPendingRelay();

  if (millis() - lastSensorRead >= SENSOR_READ_INTERVAL)
  {
    lastSensorRead = millis();
    readSensors();
    checkButton();
    controlIrrigation();  // Agriculture – pump only
    controlPoultryFans(); // Poultry – fans only
    printData();
    debugManualState();
  }

  updateLCD();

  if (millis() - lastTelegramPoll >= TELEGRAM_POLL_INTERVAL)
  {
    lastTelegramPoll = millis();
    handleTelegramMessages();
  }

  if (millis() - lastTelegramAlert >= TELEGRAM_ALERT_INTERVAL)
  {
    lastTelegramAlert = millis();
    checkAndReportFaults();
  }

  if (millis() - lastTelegramStatus >= TELEGRAM_STATUS_INTERVAL)
  {
    lastTelegramStatus = millis();
    sendStatusUpdate();
  }

  if (millis() - lastUpload >= UPLOAD_INTERVAL)
  {
    lastUpload = millis();
    sendToThingSpeak();
  }

  delay(10);
  yield();
}