#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>
#include <ArduinoJson.h>

// WiFi credentials
const char* ssid = "Wokwi-GUEST";
const char* password = "";

// MQTT Broker settings
const char* mqtt_server = "broker.hivemq.com";
const int mqtt_port = 1883;
const char* mqtt_user = "";
const char* mqtt_password = "";
const char* client_id = "ESP32_Industrial_IoT_Fixed";

// Device ID for MQTT topics
const char* device_id = "industrial_iot_system";

// Pin definitions
#define DHT_PIN 4
#define DHT_TYPE DHT22
#define DS18B20_PIN 5
#define PRESSURE_PIN A0        // GPIO36 - Potentiometer 1
#define FLOW_RATE_PIN A3       // GPIO39 - Potentiometer 2  
#define VIBRATION_PIN A6       // GPIO34 - Potentiometer 3
#define LIGHT_PIN A7           // GPIO35 - LDR sensor
#define MOTION_PIN 13
#define BUZZER_PIN 19
#define EMERGENCY_BTN_PIN 15
#define START_BTN_PIN 32

// Relay pins - These control the visual relays in Wokwi
#define MOTOR_RELAY_PIN 25
#define PUMP_RELAY_PIN 26
#define VALVE_RELAY_PIN 27
#define COOLING_RELAY_PIN 14

// LED pins
#define SYSTEM_LED_PIN 2
#define ALERT_LED_PIN 16
#define PROCESS_LED_PIN 17
#define POWER_LED_PIN 18

// Sensor objects
DHT dht(DHT_PIN, DHT_TYPE);
OneWire oneWire(DS18B20_PIN);
DallasTemperature ds18b20(&oneWire);

// Initialize LCD with I2C address
LiquidCrystal_I2C lcd(0x27, 16, 2);

WiFiClient espClient;
PubSubClient client(espClient);

// System state variables
struct SystemState {
  bool systemOnline = false;
  bool emergencyStop = false;
  bool motorRunning = false;
  bool pumpRunning = false;
  bool valveOpen = false;
  bool coolingActive = false;
  bool alertActive = false;
  unsigned long lastSensorUpdate = 0;
  unsigned long lastStatusUpdate = 0;
  unsigned long lastDisplayUpdate = 0;
  unsigned long lastPageChange = 0;
  int displayPage = 0;
} systemState;

// Sensor data structure
struct SensorData {
  float envTemperature = 24.5;
  float envHumidity = 65.0;
  float processTemperature = 28.3;
  float systemPressure = 45.2;
  float flowRate = 12.8;
  float vibrationLevel = 15.4;
  int lightLevel = 78;
  bool motionDetected = false;
} sensorData;

// MQTT Topics for Node-RED integration
const char* TOPIC_MOTOR_CONTROL = "industrial/control/motor";
const char* TOPIC_PUMP_CONTROL = "industrial/control/pump";
const char* TOPIC_VALVE_CONTROL = "industrial/control/valve";
const char* TOPIC_COOLING_CONTROL = "industrial/control/cooling";
const char* TOPIC_SYSTEM_CONTROL = "industrial/control/system";

const char* TOPIC_SENSOR_DATA = "industrial/sensors/data";
const char* TOPIC_SYSTEM_STATUS = "industrial/status/system";
const char* TOPIC_RELAY_STATUS = "industrial/status/relays";
const char* TOPIC_ALERTS = "industrial/status/alerts";

// LCD Display status
bool lcdInitialized = false;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println("=== Industrial IoT System Starting ===");
  Serial.println("Version: Fixed for Wokwi with MQTT");
  
  // Initialize pins
  initializePins();
  
  // Initialize LCD
  initializeLCD();
  
  // Show startup message on LCD
  if (lcdInitialized) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Industrial IoT");
    lcd.setCursor(0, 1);
    lcd.print("Booting...");
    delay(2000);
  }
  
  // Initialize sensors
  dht.begin();
  ds18b20.begin();
  
  // Connect to WiFi
  connectToWiFi();
  
  // Setup MQTT
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(mqttCallback);
  
  // Connect to MQTT
  connectToMQTT();
  
  // Subscribe to control topics
  subscribeToControlTopics();
  
  // Initialize system
  systemState.systemOnline = true;
  digitalWrite(SYSTEM_LED_PIN, HIGH);
  digitalWrite(POWER_LED_PIN, HIGH);
  
  // Test relays on startup to show they work
  testRelays();
  
  if (lcdInitialized) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("System Online");
    lcd.setCursor(0, 1);
    lcd.print("MQTT Ready");
    delay(2000);
  }
  
  Serial.println("=== Industrial IoT System Ready ===");
  Serial.println("Send MQTT commands to control relays:");
  Serial.println("Topic: industrial/control/motor - Payload: {\"state\":true}");
  Serial.println("Topic: industrial/control/pump - Payload: {\"state\":true}");
  Serial.println("Topic: industrial/control/valve - Payload: {\"state\":true}");
  Serial.println("Topic: industrial/control/cooling - Payload: {\"state\":true}");
}

void loop() {
  // Maintain MQTT connection
  if (!client.connected()) {
    connectToMQTT();
  }
  client.loop();
  
  // Check buttons
  checkEmergencyButton();
  checkStartButton();
  
  // Read sensors (every 3 seconds)
  if (millis() - systemState.lastSensorUpdate > 3000) {
    readAllSensors();
    publishSensorData();
    systemState.lastSensorUpdate = millis();
  }
  
  // Update system status (every 5 seconds)
  if (millis() - systemState.lastStatusUpdate > 5000) {
    publishSystemStatus();
    systemState.lastStatusUpdate = millis();
  }
  
  // Update LCD display (every 2 seconds)
  if (millis() - systemState.lastDisplayUpdate > 2000) {
    updateDisplay();
    systemState.lastDisplayUpdate = millis();
  }
  
  // Process system logic
  processSystemLogic();
  
  delay(100);
}

void initializePins() {
  Serial.println("Initializing pins...");
  
  // Input pins
  pinMode(EMERGENCY_BTN_PIN, INPUT_PULLUP);
  pinMode(START_BTN_PIN, INPUT_PULLUP);
  pinMode(MOTION_PIN, INPUT);
  
  // Output pins - Relays
  pinMode(MOTOR_RELAY_PIN, OUTPUT);
  pinMode(PUMP_RELAY_PIN, OUTPUT);
  pinMode(VALVE_RELAY_PIN, OUTPUT);
  pinMode(COOLING_RELAY_PIN, OUTPUT);
  
  // Output pins - LEDs
  pinMode(SYSTEM_LED_PIN, OUTPUT);
  pinMode(ALERT_LED_PIN, OUTPUT);
  pinMode(PROCESS_LED_PIN, OUTPUT);
  pinMode(POWER_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  
  // Initialize all outputs to OFF
  digitalWrite(MOTOR_RELAY_PIN, LOW);
  digitalWrite(PUMP_RELAY_PIN, LOW);
  digitalWrite(VALVE_RELAY_PIN, LOW);
  digitalWrite(COOLING_RELAY_PIN, LOW);
  digitalWrite(SYSTEM_LED_PIN, LOW);
  digitalWrite(ALERT_LED_PIN, LOW);
  digitalWrite(PROCESS_LED_PIN, LOW);
  digitalWrite(POWER_LED_PIN, LOW);
  digitalWrite(BUZZER_PIN, LOW);
  
  Serial.println("Pins initialized successfully");
}

void initializeLCD() {
  Serial.println("Initializing LCD...");
  
  // Standard I2C LCD initialization for Wokwi
  lcd.init();
  lcd.backlight();
  
  // Test display
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("LCD Test...");
  delay(1000);
  
  lcdInitialized = true;
  Serial.println("LCD initialized successfully");
}

void connectToWiFi() {
  if (lcdInitialized) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Connecting WiFi");
  }
  
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println();
  Serial.print("Connected to WiFi. IP address: ");
  Serial.println(WiFi.localIP());
  
  if (lcdInitialized) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("WiFi Connected");
    lcd.setCursor(0, 1);
    lcd.print(WiFi.localIP());
    delay(2000);
  }
}

void connectToMQTT() {
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    
    if (client.connect(client_id, mqtt_user, mqtt_password)) {
      Serial.println("connected to MQTT broker");
      
      // Publish connection status
      String statusMsg = "{\"status\":\"connected\",\"device\":\"" + String(client_id) + "\",\"timestamp\":" + String(millis()) + "}";
      client.publish(TOPIC_SYSTEM_STATUS, statusMsg.c_str());
      
      if (lcdInitialized) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MQTT Connected");
        delay(1000);
      }
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void subscribeToControlTopics() {
  client.subscribe(TOPIC_MOTOR_CONTROL);
  client.subscribe(TOPIC_PUMP_CONTROL);
  client.subscribe(TOPIC_VALVE_CONTROL);
  client.subscribe(TOPIC_COOLING_CONTROL);
  client.subscribe(TOPIC_SYSTEM_CONTROL);
  
  Serial.println("Subscribed to MQTT control topics:");
  Serial.println("- " + String(TOPIC_MOTOR_CONTROL));
  Serial.println("- " + String(TOPIC_PUMP_CONTROL));
  Serial.println("- " + String(TOPIC_VALVE_CONTROL));
  Serial.println("- " + String(TOPIC_COOLING_CONTROL));
  Serial.println("- " + String(TOPIC_SYSTEM_CONTROL));
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  Serial.println("=== MQTT MESSAGE RECEIVED ===");
  Serial.println("Topic: " + String(topic));
  Serial.println("Payload: " + message);
  Serial.println("=============================");
  
  // Parse JSON command
  DynamicJsonDocument doc(256);
  DeserializationError error = deserializeJson(doc, message);
  
  if (error) {
    Serial.println("Failed to parse JSON: " + String(error.c_str()));
    return;
  }
  
  // Extract command and state
  bool state = doc["state"] | false;
  String command = doc["command"] | "";
  
  Serial.println("Parsed - State: " + String(state) + ", Command: " + command);
  
  // Process control commands
  if (String(topic) == TOPIC_MOTOR_CONTROL) {
    Serial.println("Processing MOTOR command: " + String(state ? "ON" : "OFF"));
    controlMotor(state);
  } 
  else if (String(topic) == TOPIC_PUMP_CONTROL) {
    Serial.println("Processing PUMP command: " + String(state ? "ON" : "OFF"));
    controlPump(state);
  } 
  else if (String(topic) == TOPIC_VALVE_CONTROL) {
    Serial.println("Processing VALVE command: " + String(state ? "OPEN" : "CLOSED"));
    controlValve(state);
  } 
  else if (String(topic) == TOPIC_COOLING_CONTROL) {
    Serial.println("Processing COOLING command: " + String(state ? "ON" : "OFF"));
    controlCooling(state);
  } 
  else if (String(topic) == TOPIC_SYSTEM_CONTROL) {
    Serial.println("Processing SYSTEM command: " + command);
    if (command == "start") {
      startSystem();
    } else if (command == "stop") {
      stopSystem();
    } else if (command == "emergency_stop") {
      emergencyStop();
    }
  }
}

void testRelays() {
  Serial.println("Testing all relays...");
  
  if (lcdInitialized) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Testing Relays");
  }
  
  // Test each relay for 1 second
  Serial.println("Testing Motor Relay (Pin " + String(MOTOR_RELAY_PIN) + ")");
  digitalWrite(MOTOR_RELAY_PIN, HIGH);
  if (lcdInitialized) {
    lcd.setCursor(0, 1);
    lcd.print("Motor: ON");
  }
  delay(1000);
  digitalWrite(MOTOR_RELAY_PIN, LOW);
  
  Serial.println("Testing Pump Relay (Pin " + String(PUMP_RELAY_PIN) + ")");
  digitalWrite(PUMP_RELAY_PIN, HIGH);
  if (lcdInitialized) {
    lcd.setCursor(0, 1);
    lcd.print("Pump: ON");
  }
  delay(1000);
  digitalWrite(PUMP_RELAY_PIN, LOW);
  
  Serial.println("Testing Valve Relay (Pin " + String(VALVE_RELAY_PIN) + ")");
  digitalWrite(VALVE_RELAY_PIN, HIGH);
  if (lcdInitialized) {
    lcd.setCursor(0, 1);
    lcd.print("Valve: OPEN");
  }
  delay(1000);
  digitalWrite(VALVE_RELAY_PIN, LOW);
  
  Serial.println("Testing Cooling Relay (Pin " + String(COOLING_RELAY_PIN) + ")");
  digitalWrite(COOLING_RELAY_PIN, HIGH);
  if (lcdInitialized) {
    lcd.setCursor(0, 1);
    lcd.print("Cooling: ON");
  }
  delay(1000);
  digitalWrite(COOLING_RELAY_PIN, LOW);
  
  Serial.println("Relay test completed - All relays should have visibly activated");
}

void readAllSensors() {
  // Read DHT22 (Environment)
  float tempReading = dht.readTemperature();
  float humReading = dht.readHumidity();
  
  if (!isnan(tempReading)) sensorData.envTemperature = tempReading;
  if (!isnan(humReading)) sensorData.envHumidity = humReading;
  
  // Read DS18B20 (Process Temperature)
  ds18b20.requestTemperatures();
  float processTemp = ds18b20.getTempCByIndex(0);
  if (processTemp != DEVICE_DISCONNECTED_C && processTemp != -127.0) {
    sensorData.processTemperature = processTemp;
  }
  
  // Read analog sensors (mapped to appropriate ranges)
  sensorData.systemPressure = map(analogRead(PRESSURE_PIN), 0, 4095, 0, 1000) / 10.0; // 0-100 bar
  sensorData.flowRate = map(analogRead(FLOW_RATE_PIN), 0, 4095, 0, 500) / 10.0; // 0-50 L/min
  sensorData.vibrationLevel = map(analogRead(VIBRATION_PIN), 0, 4095, 0, 1000) / 10.0; // 0-100 Hz
  sensorData.lightLevel = map(analogRead(LIGHT_PIN), 0, 4095, 0, 100); // 0-100%
  
  // Read digital sensors
  sensorData.motionDetected = digitalRead(MOTION_PIN);
}

void publishSensorData() {
  // Create comprehensive sensor data JSON
  DynamicJsonDocument doc(512);
  
  doc["environment"]["temperature"] = round(sensorData.envTemperature * 10) / 10.0;
  doc["environment"]["humidity"] = round(sensorData.envHumidity * 10) / 10.0;
  doc["process"]["temperature"] = round(sensorData.processTemperature * 10) / 10.0;
  doc["system"]["pressure"] = round(sensorData.systemPressure * 10) / 10.0;
  doc["system"]["flow_rate"] = round(sensorData.flowRate * 10) / 10.0;
  doc["system"]["vibration"] = round(sensorData.vibrationLevel * 10) / 10.0;
  doc["environment"]["light_level"] = sensorData.lightLevel;
  doc["security"]["motion_detected"] = sensorData.motionDetected;
  doc["timestamp"] = millis();
  
  String output;
  serializeJson(doc, output);
  client.publish(TOPIC_SENSOR_DATA, output.c_str());
}

void publishSystemStatus() {
  DynamicJsonDocument doc(256);
  
  doc["system_online"] = systemState.systemOnline;
  doc["emergency_stop"] = systemState.emergencyStop;
  doc["alert_active"] = systemState.alertActive;
  doc["timestamp"] = millis();
  
  String output;
  serializeJson(doc, output);
  client.publish(TOPIC_SYSTEM_STATUS, output.c_str());
  
  // Also publish relay status
  publishRelayStatus();
}

void publishRelayStatus() {
  DynamicJsonDocument doc(256);
  
  doc["motor"] = systemState.motorRunning;
  doc["pump"] = systemState.pumpRunning;
  doc["valve"] = systemState.valveOpen;
  doc["cooling"] = systemState.coolingActive;
  doc["timestamp"] = millis();
  
  String output;
  serializeJson(doc, output);
  client.publish(TOPIC_RELAY_STATUS, output.c_str());
}

void controlMotor(bool state) {
  if (!systemState.emergencyStop) {
    systemState.motorRunning = state;
    digitalWrite(MOTOR_RELAY_PIN, state ? HIGH : LOW);
    digitalWrite(PROCESS_LED_PIN, state ? HIGH : LOW);
    
    Serial.println("MOTOR RELAY: " + String(state ? "ACTIVATED (HIGH)" : "DEACTIVATED (LOW)"));
    Serial.println("Pin " + String(MOTOR_RELAY_PIN) + " set to: " + String(state ? "HIGH" : "LOW"));
    
    publishRelayStatus();
  } else {
    Serial.println("Motor control blocked - Emergency stop active");
  }
}

void controlPump(bool state) {
  if (!systemState.emergencyStop) {
    systemState.pumpRunning = state;
    digitalWrite(PUMP_RELAY_PIN, state ? HIGH : LOW);
    
    Serial.println("PUMP RELAY: " + String(state ? "ACTIVATED (HIGH)" : "DEACTIVATED (LOW)"));
    Serial.println("Pin " + String(PUMP_RELAY_PIN) + " set to: " + String(state ? "HIGH" : "LOW"));
    
    publishRelayStatus();
  } else {
    Serial.println("Pump control blocked - Emergency stop active");
  }
}

void controlValve(bool state) {
  if (!systemState.emergencyStop) {
    systemState.valveOpen = state;
    digitalWrite(VALVE_RELAY_PIN, state ? HIGH : LOW);
    
    Serial.println("VALVE RELAY: " + String(state ? "ACTIVATED (HIGH)" : "DEACTIVATED (LOW)"));
    Serial.println("Pin " + String(VALVE_RELAY_PIN) + " set to: " + String(state ? "HIGH" : "LOW"));
    
    publishRelayStatus();
  } else {
    Serial.println("Valve control blocked - Emergency stop active");
  }
}

void controlCooling(bool state) {
  if (!systemState.emergencyStop) {
    systemState.coolingActive = state;
    digitalWrite(COOLING_RELAY_PIN, state ? HIGH : LOW);
    
    Serial.println("COOLING RELAY: " + String(state ? "ACTIVATED (HIGH)" : "DEACTIVATED (LOW)"));
    Serial.println("Pin " + String(COOLING_RELAY_PIN) + " set to: " + String(state ? "HIGH" : "LOW"));
    
    publishRelayStatus();
  } else {
    Serial.println("Cooling control blocked - Emergency stop active");
  }
}

void checkEmergencyButton() {
  static bool lastEmergencyState = HIGH;
  bool currentState = digitalRead(EMERGENCY_BTN_PIN);
  
  if (lastEmergencyState == HIGH && currentState == LOW) {
    emergencyStop();
  }
  
  lastEmergencyState = currentState;
}

void checkStartButton() {
  static bool lastStartState = HIGH;
  bool currentState = digitalRead(START_BTN_PIN);
  
  if (lastStartState == HIGH && currentState == LOW) {
    if (systemState.emergencyStop) {
      resetEmergencyStop();
    } else {
      startSystem();
    }
  }
  
  lastStartState = currentState;
}

void emergencyStop() {
  systemState.emergencyStop = true;
  systemState.systemOnline = false;
  
  // Turn off all relays immediately
  digitalWrite(MOTOR_RELAY_PIN, LOW);
  digitalWrite(PUMP_RELAY_PIN, LOW);
  digitalWrite(VALVE_RELAY_PIN, LOW);
  digitalWrite(COOLING_RELAY_PIN, LOW);
  
  // Update states
  systemState.motorRunning = false;
  systemState.pumpRunning = false;
  systemState.valveOpen = false;
  systemState.coolingActive = false;
  
  // Activate alert
  systemState.alertActive = true;
  digitalWrite(ALERT_LED_PIN, HIGH);
  digitalWrite(SYSTEM_LED_PIN, LOW);
  
  // Sound buzzer
  for (int i = 0; i < 3; i++) {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(300);
    digitalWrite(BUZZER_PIN, LOW);
    delay(300);
  }
  
  Serial.println("*** EMERGENCY STOP ACTIVATED ***");
  
  // Publish emergency status
  String alertMsg = "{\"type\":\"emergency_stop\",\"active\":true,\"timestamp\":" + String(millis()) + "}";
  client.publish(TOPIC_ALERTS, alertMsg.c_str());
  publishSystemStatus();
}

void resetEmergencyStop() {
  systemState.emergencyStop = false;
  systemState.alertActive = false;
  digitalWrite(ALERT_LED_PIN, LOW);
  
  Serial.println("Emergency stop reset - System ready");
  String alertMsg = "{\"type\":\"emergency_stop\",\"active\":false,\"timestamp\":" + String(millis()) + "}";
  client.publish(TOPIC_ALERTS, alertMsg.c_str());
}

void startSystem() {
  if (!systemState.emergencyStop) {
    systemState.systemOnline = true;
    digitalWrite(SYSTEM_LED_PIN, HIGH);
    
    Serial.println("System started and ready for operation");
    publishSystemStatus();
  }
}

void stopSystem() {
  systemState.systemOnline = false;
  
  // Turn off all relays
  controlMotor(false);
  controlPump(false);
  controlValve(false);
  controlCooling(false);
  
  digitalWrite(SYSTEM_LED_PIN, LOW);
  digitalWrite(PROCESS_LED_PIN, LOW);
  
  Serial.println("System stopped");
  publishSystemStatus();
}

void processSystemLogic() {
  // Auto-cooling based on process temperature
  if (sensorData.processTemperature > 50.0 && !systemState.coolingActive && systemState.systemOnline) {
    Serial.println("Auto-activating cooling - Process temp: " + String(sensorData.processTemperature));
    controlCooling(true);
  } else if (sensorData.processTemperature < 45.0 && systemState.coolingActive) {
    Serial.println("Auto-deactivating cooling - Process temp: " + String(sensorData.processTemperature));
    controlCooling(false);
  }
  
  // Alert conditions
  bool alertCondition = (sensorData.processTemperature > 60.0) || 
                       (sensorData.systemPressure > 80.0) ||
                       (sensorData.vibrationLevel > 80.0);
  
  if (alertCondition && !systemState.alertActive && !systemState.emergencyStop) {
    systemState.alertActive = true;
    digitalWrite(ALERT_LED_PIN, HIGH);
    
    String alertMsg = "{\"type\":\"system_alert\",\"active\":true,\"temperature\":" + 
                     String(sensorData.processTemperature) + ",\"pressure\":" + 
                     String(sensorData.systemPressure) + ",\"vibration\":" + 
                     String(sensorData.vibrationLevel) + ",\"timestamp\":" + String(millis()) + "}";
    client.publish(TOPIC_ALERTS, alertMsg.c_str());
  } else if (!alertCondition && systemState.alertActive && !systemState.emergencyStop) {
    systemState.alertActive = false;
    digitalWrite(ALERT_LED_PIN, LOW);
    
    String alertMsg = "{\"type\":\"system_alert\",\"active\":false,\"timestamp\":" + String(millis()) + "}";
    client.publish(TOPIC_ALERTS, alertMsg.c_str());
  }
}

void updateDisplay() {
  if (!lcdInitialized) return;
  
  // Change display page every 4 seconds
  if (millis() - systemState.lastPageChange > 4000) {
    systemState.displayPage = (systemState.displayPage + 1) % 4;
    systemState.lastPageChange = millis();
  }
  
  lcd.clear();
  
  switch (systemState.displayPage) {
    case 0: // Environmental Data
      lcd.setCursor(0, 0);
      lcd.print("Env:" + String(sensorData.envTemperature, 1) + "C " + String(sensorData.envHumidity, 0) + "%");
      lcd.setCursor(0, 1);
      lcd.print("Proc:" + String(sensorData.processTemperature, 1) + "C");
      break;
      
    case 1: // System Parameters
      lcd.setCursor(0, 0);
      lcd.print("Press:" + String(sensorData.systemPressure, 1) + "bar");
      lcd.setCursor(0, 1);
      lcd.print("Flow:" + String(sensorData.flowRate, 1) + "L/min");
      break;
      
    case 2: // Analysis Data
      lcd.setCursor(0, 0);
      lcd.print("Vib:" + String(sensorData.vibrationLevel, 1) + "Hz");
      lcd.setCursor(0, 1);
      lcd.print("Light:" + String(sensorData.lightLevel) + "%");
      break;
      
    case 3: // System Status
      lcd.setCursor(0, 0);
      if (systemState.emergencyStop) {
        lcd.print("EMERGENCY STOP!");
        lcd.setCursor(0, 1);
        lcd.print("Press GREEN btn");
      } else {
        lcd.print(systemState.systemOnline ? "System:ONLINE" : "System:OFFLINE");
        lcd.setCursor(0, 1);
        lcd.print("M:" + String(systemState.motorRunning ? "1" : "0") + 
                 " P:" + String(systemState.pumpRunning ? "1" : "0") +
                 " V:" + String(systemState.valveOpen ? "1" : "0") +
                 " C:" + String(systemState.coolingActive ? "1" : "0"));
      }
      break;
  }
}