/*
 * ESP32 Aquaponik Überwachungssystem mit E-Mail-Benachrichtigung
 * 
 * Hardware: ESP32-DevKitC V4 (ESP32-WROOM-32)
 * Compiler: Arduino IDE 2.3.0 oder höher mit esp32 Board Support 2.0.14+
 * 
 * Sensoren:
 * - DS18B20: Wassertemperatur (OneWire, GPIO 4)
 * - DHT22: Lufttemperatur/Feuchtigkeit (GPIO 15)
 * - JSN-SR04T: Wasserstand Ultraschall (Trigger GPIO 5, Echo GPIO 18)
 * - DFRobot SEN0161-V2: pH-Wert (Analog GPIO 34)
 * 
 * Aktoren:
 * - 4-Kanal Relais-Modul (GPIO 12, 13, 14, 27)
 * 
 * Erforderliche Bibliotheken (über Bibliotheksverwalter):
 * - OneWire 2.3.7+
 * - DallasTemperature 3.9.0+
 * - DHT sensor library 1.4.4+ (Adafruit)
 * - Adafruit Unified Sensor 1.1.9+
 * - ESP Mail Client 3.4.0+ (Mobizt)
 * 
 * Erforderliche Bibliotheken (manuelle Installation):
 * - AsyncTCP (https://github.com/me-no-dev/AsyncTCP)
 * - ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
 */

#include 
#include 
#include 
#include 
#include 

// ==================== KONFIGURATION START ====================
// Bitte alle Werte entsprechend anpassen!

// WiFi-Zugangsdaten
#define WIFI_SSID "IhrWLANName"                    // WLAN-SSID
#define WIFI_PASSWORD "IhrWLANPasswort"            // WLAN-Passwort

// SMTP-Server Konfiguration (Beispiel: Mailbox.org)
// Für andere Anbieter entsprechend anpassen
#define SMTP_HOST "smtp.mailbox.org"               // SMTP-Server Adresse
#define SMTP_PORT 465                              // Port (465 für SSL, 587 für STARTTLS)
#define AUTHOR_EMAIL "This email address is being protected from spambots. You need JavaScript enabled to view it."      // Absender E-Mail-Adresse
#define AUTHOR_PASSWORD "IhrPasswort"              // E-Mail Passwort
#define RECIPIENT_EMAIL "This email address is being protected from spambots. You need JavaScript enabled to view it."      // Empfänger E-Mail-Adresse
#define RECIPIENT_NAME "Aquaponik Admin"           // Empfängername

// Sensor Pin-Definitionen
#define ONE_WIRE_BUS 4        // DS18B20 Datenleitung (OneWire)
#define DHTPIN 15             // DHT22 Datenleitung
#define DHTTYPE DHT22         // DHT-Sensor Typ
#define TRIGGER_PIN 5         // Ultraschall Sensor Trigger
#define ECHO_PIN 18           // Ultraschall Sensor Echo
#define PH_PIN 34             // pH-Sensor Analogeingang (ADC1_CH6)

// Relais Pin-Definitionen (LOW-Level-Trigger)
#define RELAY_PUMP1 12        // Pumpe 1 (Hauptpumpe)
#define RELAY_PUMP2 13        // Pumpe 2 (Nährlösung)
#define RELAY_LIGHT 14        // Beleuchtung
#define RELAY_RESERVE 27      // Reserve (z.B. Heizung/Lüfter)

// Grenzwerte für Alarme - an eigene Anforderungen anpassen
#define PH_MIN 5.5            // Minimaler pH-Wert
#define PH_MAX 7.5            // Maximaler pH-Wert
#define WATER_TEMP_MIN 18.0   // Minimale Wassertemperatur (°C)
#define WATER_TEMP_MAX 26.0   // Maximale Wassertemperatur (°C)
#define WATER_LEVEL_MIN 10.0  // Minimaler Wasserstand (cm vom Sensor)
#define WATER_LEVEL_MAX 100.0 // Maximaler Wasserstand (cm vom Sensor)
#define AIR_TEMP_MAX 35.0     // Maximale Lufttemperatur (°C)
#define HUMIDITY_MIN 40.0     // Minimale Luftfeuchtigkeit (%)

// pH-Sensor Kalibrierung (muss für jeden Sensor individuell erfolgen)
// Diese Werte sind Beispiele und müssen angepasst werden!
#define PH_CALIBRATION_VOLTAGE_4 1.032  // Spannung bei pH 4 (Volt)
#define PH_CALIBRATION_VOLTAGE_7 1.500  // Spannung bei pH 7 (Volt)

// Zeitintervalle
#define SENSOR_READ_INTERVAL 30000      // Sensor-Abfrage alle 30 Sekunden
#define EMAIL_COOLDOWN 300000           // Min. 5 Minuten zwischen E-Mails

// ==================== KONFIGURATION ENDE ====================

// Globale Objekte initialisieren
OneWire oneWire(ONE_WIRE_BUS);               // OneWire-Bus für DS18B20
DallasTemperature sensors(&oneWire);         // Dallas Temperature Bibliothek
DHT dht(DHTPIN, DHTTYPE);                    // DHT22 Sensor
SMTPSession smtp;                             // SMTP Session für E-Mail

// Globale Variablen
unsigned long lastSensorRead = 0;             // Zeitstempel letzte Sensor-Abfrage
unsigned long lastEmailSent = 0;              // Zeitstempel letzte E-Mail
bool wifiConnected = false;                   // WiFi Verbindungsstatus

// Struktur für Sensordaten
struct SensorData {
    float waterTemp;        // Wassertemperatur in °C
    float airTemp;          // Lufttemperatur in °C
    float humidity;         // Luftfeuchtigkeit in %
    float waterLevel;       // Wasserstand in cm
    float pH;               // pH-Wert
    bool valid;             // Daten gültig?
};

SensorData currentData = {0, 0, 0, 0, 0, false};

// Struktur für Alarmzustände
struct AlarmState {
    bool phLow;             // pH zu niedrig
    bool phHigh;            // pH zu hoch
    bool waterTempLow;      // Wassertemperatur zu niedrig
    bool waterTempHigh;     // Wassertemperatur zu hoch
    bool waterLevelLow;     // Wasserstand zu niedrig
    bool waterLevelHigh;    // Wasserstand zu hoch
    bool airTempHigh;       // Lufttemperatur zu hoch
    bool humidityLow;       // Luftfeuchtigkeit zu niedrig
    bool anyAlarm;          // Irgendein Alarm aktiv
};

AlarmState alarmState = {false, false, false, false, false, false, false, false, false};

// ==================== SETUP ====================
void setup() {
    // Serielle Kommunikation starten (für Debugging)
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n\n=== ESP32 Aquaponik Überwachungssystem ===");
    Serial.println("Hardware: ESP32-DevKitC V4 (ESP32-WROOM-32)");
    Serial.println("========================================\n");
    
    // GPIO-Pins konfigurieren
    pinMode(TRIGGER_PIN, OUTPUT);          // Ultraschall Trigger als Ausgang
    pinMode(ECHO_PIN, INPUT);              // Ultraschall Echo als Eingang
    pinMode(RELAY_PUMP1, OUTPUT);          // Relais als Ausgang
    pinMode(RELAY_PUMP2, OUTPUT);
    pinMode(RELAY_LIGHT, OUTPUT);
    pinMode(RELAY_RESERVE, OUTPUT);
    
    // Relais initial ausschalten (HIGH bei Low-Level-Trigger Modulen)
    digitalWrite(RELAY_PUMP1, HIGH);
    digitalWrite(RELAY_PUMP2, HIGH);
    digitalWrite(RELAY_LIGHT, HIGH);
    digitalWrite(RELAY_RESERVE, HIGH);
    
    Serial.println("GPIO-Pins initialisiert");
    
    // Sensoren initialisieren
    sensors.begin();                        // DS18B20 starten
    dht.begin();                           // DHT22 starten
    
    // Anzahl der DS18B20 Sensoren prüfen
    int deviceCount = sensors.getDeviceCount();
    Serial.print("DS18B20 Sensoren gefunden: ");
    Serial.println(deviceCount);
    
    if (deviceCount == 0) {
        Serial.println("WARNUNG: Kein DS18B20 gefunden! Verkabelung prüfen.");
    }
    
    // WiFi verbinden
    connectToWiFi();
    
    Serial.println("\nSystem bereit. Starte Überwachung...\n");
}

// ==================== MAIN LOOP ====================
void loop() {
    // WiFi-Verbindung prüfen und ggf. wiederherstellen
    if (WiFi.status() != WL_CONNECTED && wifiConnected) {
        Serial.println("WiFi-Verbindung verloren. Versuche Wiederverbindung...");
        wifiConnected = false;
        connectToWiFi();
    }
    
    // Sensoren in definierten Intervallen auslesen
    if (millis() - lastSensorRead >= SENSOR_READ_INTERVAL) {
        lastSensorRead = millis();
        
        // Alle Sensoren auslesen
        readAllSensors();
        
        // Daten ausgeben
        printSensorData();
        
        // Alarmzustände prüfen
        checkAlarms();
        
        // Bei Alarm E-Mail senden (wenn Cooldown abgelaufen)
        if (alarmState.anyAlarm && wifiConnected) {
            if (millis() - lastEmailSent >= EMAIL_COOLDOWN) {
                sendAlarmEmail();
                lastEmailSent = millis();
            } else {
                Serial.println("Alarm aktiv, aber E-Mail Cooldown noch nicht abgelaufen");
            }
        }
    }
    
    // Kleine Pause um Watchdog zu bedienen
    delay(100);
}

// ==================== FUNKTIONEN ====================

/**
 * Verbindung zum WiFi herstellen
 */
void connectToWiFi() {
    Serial.print("Verbinde mit WiFi: ");
    Serial.println(WIFI_SSID);
    
    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
        delay(500);
        Serial.print(".");
        attempts++;
    }
    
    if (WiFi.status() == WL_CONNECTED) {
        wifiConnected = true;
        Serial.println("\nWiFi verbunden!");
        Serial.print("IP-Adresse: ");
        Serial.println(WiFi.localIP());
        Serial.print("Signalstärke: ");
        Serial.print(WiFi.RSSI());
        Serial.println(" dBm");
    } else {
        wifiConnected = false;
        Serial.println("\nWiFi-Verbindung fehlgeschlagen!");
        Serial.println("System arbeitet im Offline-Modus (keine E-Mails möglich)");
    }
}

/**
 * Alle Sensoren auslesen und Daten in currentData speichern
 */
void readAllSensors() {
    // DS18B20 Wassertemperatur auslesen
    sensors.requestTemperatures();
    currentData.waterTemp = sensors.getTempCByIndex(0);
    
    // DHT22 Lufttemperatur und Feuchtigkeit auslesen
    currentData.airTemp = dht.readTemperature();
    currentData.humidity = dht.readHumidity();
    
    // JSN-SR04T Wasserstand auslesen
    currentData.waterLevel = readUltrasonic();
    
    // pH-Wert auslesen
    currentData.pH = readPH();
    
    // Validität prüfen (NaN-Werte von DHT22 abfangen)
    currentData.valid = !isnan(currentData.airTemp) && 
                       !isnan(currentData.humidity) &&
                       currentData.waterTemp != -127.0;
}

/**
 * Wasserstand mit JSN-SR04T Ultraschallsensor messen
 * @return Distanz in cm
 */
float readUltrasonic() {
    // Trigger-Impuls senden (10µs HIGH)
    digitalWrite(TRIGGER_PIN, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIGGER_PIN, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIGGER_PIN, LOW);
    
    // Echo-Zeit messen (Timeout nach 30ms = ca. 5m)
    long duration = pulseIn(ECHO_PIN, HIGH, 30000);
    
    // Distanz berechnen: Schallgeschwindigkeit ca. 343 m/s
    // Distanz = (Zeit * Geschwindigkeit) / 2 (Hin- und Rückweg)
    // In cm: duration (µs) * 0.0343 / 2
    float distance = duration * 0.01715;
    
    // Plausibilität prüfen
    if (distance < 2.0 || distance > 450.0) {
        Serial.println("Ultraschall: Messung außerhalb des gültigen Bereichs");
        return -1.0;
    }
    
    return distance;
}

/**
 * pH-Wert mit DFRobot SEN0161-V2 messen
 * @return pH-Wert (0-14)
 */
float readPH() {
    // ADC-Wert auslesen (12-bit: 0-4095)
    // Mit Spannungsteiler (R1=R2=10k): Eingangsspannung wird halbiert
    int adcValue = analogRead(PH_PIN);
    
    // ADC-Wert in Spannung umrechnen
    // ESP32 ADC: 0-4095 entspricht 0-3.3V
    // Mit Spannungsteiler: tatsächliche Sensorspannung = gemessene Spannung * 2
    float voltage = (adcValue / 4095.0) * 3.3 * 2.0;
    
    // pH-Wert berechnen mittels 2-Punkt-Kalibrierung
    // Lineare Interpolation zwischen zwei Kalibrierpunkten
    float phSlope = (7.0 - 4.0) / (PH_CALIBRATION_VOLTAGE_7 - PH_CALIBRATION_VOLTAGE_4);
    float phValue = 7.0 + phSlope * (voltage - PH_CALIBRATION_VOLTAGE_7);
    
    // Plausibilität prüfen
    if (phValue < 0.0 || phValue > 14.0) {
        Serial.println("pH-Sensor: Messung außerhalb des gültigen Bereichs");
        Serial.print("Gemessene Spannung: ");
        Serial.print(voltage, 3);
        Serial.println(" V");
        return -1.0;
    }
    
    return phValue;
}

/**
 * Sensordaten auf Serial Monitor ausgeben
 */
void printSensorData() {
    Serial.println("=== Aktuelle Messwerte ===");
    
    if (currentData.valid) {
        Serial.print("Wassertemperatur: ");
        Serial.print(currentData.waterTemp, 1);
        Serial.println(" °C");
        
        Serial.print("Lufttemperatur: ");
        Serial.print(currentData.airTemp, 1);
        Serial.println(" °C");
        
        Serial.print("Luftfeuchtigkeit: ");
        Serial.print(currentData.humidity, 1);
        Serial.println(" %");
        
        if (currentData.waterLevel > 0) {
            Serial.print("Wasserstand: ");
            Serial.print(currentData.waterLevel, 1);
            Serial.println(" cm");
        } else {
            Serial.println("Wasserstand: Messfehler");
        }
        
        if (currentData.pH > 0) {
            Serial.print("pH-Wert: ");
            Serial.println(currentData.pH, 2);
        } else {
            Serial.println("pH-Wert: Messfehler");
        }
    } else {
        Serial.println("FEHLER: Sensordaten ungültig!");
    }
    
    Serial.println("==========================\n");
}

/**
 * Grenzwerte prüfen und Alarmzustände setzen
 */
void checkAlarms() {
    // Alle Alarmzustände zurücksetzen
    alarmState.phLow = false;
    alarmState.phHigh = false;
    alarmState.waterTempLow = false;
    alarmState.waterTempHigh = false;
    alarmState.waterLevelLow = false;
    alarmState.waterLevelHigh = false;
    alarmState.airTempHigh = false;
    alarmState.humidityLow = false;
    
    // Nur prüfen wenn Daten gültig
    if (!currentData.valid) {
        Serial.println("ALARM: Sensordaten ungültig - System-Check erforderlich!");
        alarmState.anyAlarm = true;
        return;
    }
    
    // pH-Wert prüfen
    if (currentData.pH > 0) {
        if (currentData.pH < PH_MIN) {
            alarmState.phLow = true;
            Serial.println("ALARM: pH-Wert zu niedrig!");
        }
        if (currentData.pH > PH_MAX) {
            alarmState.phHigh = true;
            Serial.println("ALARM: pH-Wert zu hoch!");
        }
    }
    
    // Wassertemperatur prüfen
    if (currentData.waterTemp < WATER_TEMP_MIN) {
        alarmState.waterTempLow = true;
        Serial.println("ALARM: Wassertemperatur zu niedrig!");
    }
    if (currentData.waterTemp > WATER_TEMP_MAX) {
        alarmState.waterTempHigh = true;
        Serial.println("ALARM: Wassertemperatur zu hoch!");
    }
    
    // Wasserstand prüfen
    if (currentData.waterLevel > 0) {
        if (currentData.waterLevel < WATER_LEVEL_MIN) {
            alarmState.waterLevelLow = true;
            Serial.println("ALARM: Wasserstand zu niedrig!");
        }
        if (currentData.waterLevel > WATER_LEVEL_MAX) {
            alarmState.waterLevelHigh = true;
            Serial.println("ALARM: Wasserstand zu hoch!");
        }
    }
    
    // Lufttemperatur prüfen
    if (currentData.airTemp > AIR_TEMP_MAX) {
        alarmState.airTempHigh = true;
        Serial.println("ALARM: Lufttemperatur zu hoch!");
    }
    
    // Luftfeuchtigkeit prüfen
    if (currentData.humidity < HUMIDITY_MIN) {
        alarmState.humidityLow = true;
        Serial.println("ALARM: Luftfeuchtigkeit zu niedrig!");
    }
    
    // Gesamtalarmstatus setzen
    alarmState.anyAlarm = alarmState.phLow || alarmState.phHigh ||
                         alarmState.waterTempLow || alarmState.waterTempHigh ||
                         alarmState.waterLevelLow || alarmState.waterLevelHigh ||
                         alarmState.airTempHigh || alarmState.humidityLow;
}

/**
 * Alarm-E-Mail versenden
 */
void sendAlarmEmail() {
    Serial.println("\n=== Sende Alarm-E-Mail ===");
    
    // SMTP-Session konfigurieren
    Session_Config config;
    config.server.host_name = SMTP_HOST;
    config.server.port = SMTP_PORT;
    config.login.email = AUTHOR_EMAIL;
    config.login.password = AUTHOR_PASSWORD;
    config.login.user_domain = "";
    
    // Zeit-Synchronisation (für E-Mail-Header)
    config.time.ntp_server = "pool.ntp.org,time.nist.gov";
    config.time.gmt_offset = 1;  // MEZ: UTC+1
    config.time.day_light_offset = 0;
    
    // SMTP-Session initialisieren
    if (!smtp.connect(&config)) {
        Serial.println("FEHLER: SMTP-Verbindung fehlgeschlagen");
        Serial.println(smtp.errorReason());
        return;
    }
    
    // E-Mail-Nachricht erstellen
    SMTP_Message message;
    message.sender.name = "ESP32 Aquaponik System";
    message.sender.email = AUTHOR_EMAIL;
    message.subject = "ALARM: Aquaponik System - Kritischer Zustand";
    message.addRecipient(RECIPIENT_NAME, RECIPIENT_EMAIL);
    
    // E-Mail-Body erstellen
    String emailBody = "ALARM - Kritischer Zustand im Aquaponik-System!\n\n";
    emailBody += "Zeitpunkt: " + String(millis() / 1000) + " Sekunden seit System-Start\n\n";
    emailBody += "=== AKTUELLE MESSWERTE ===\n";
    emailBody += "Wassertemperatur: " + String(currentData.waterTemp, 1) + " °C\n";
    emailBody += "Lufttemperatur: " + String(currentData.airTemp, 1) + " °C\n";
    emailBody += "Luftfeuchtigkeit: " + String(currentData.humidity, 1) + " %\n";
    emailBody += "Wasserstand: " + String(currentData.waterLevel, 1) + " cm\n";
    emailBody += "pH-Wert: " + String(currentData.pH, 2) + "\n\n";
    emailBody += "=== AKTIVE ALARME ===\n";
    
    if (alarmState.phLow) emailBody += "- pH-Wert zu niedrig (< " + String(PH_MIN, 1) + ")\n";
    if (alarmState.phHigh) emailBody += "- pH-Wert zu hoch (> " + String(PH_MAX, 1) + ")\n";
    if (alarmState.waterTempLow) emailBody += "- Wassertemperatur zu niedrig (< " + String(WATER_TEMP_MIN, 1) + " °C)\n";
    if (alarmState.waterTempHigh) emailBody += "- Wassertemperatur zu hoch (> " + String(WATER_TEMP_MAX, 1) + " °C)\n";
    if (alarmState.waterLevelLow) emailBody += "- Wasserstand zu niedrig (< " + String(WATER_LEVEL_MIN, 1) + " cm)\n";
    if (alarmState.waterLevelHigh) emailBody += "- Wasserstand zu hoch (> " + String(WATER_LEVEL_MAX, 1) + " cm)\n";
    if (alarmState.airTempHigh) emailBody += "- Lufttemperatur zu hoch (> " + String(AIR_TEMP_MAX, 1) + " °C)\n";
    if (alarmState.humidityLow) emailBody += "- Luftfeuchtigkeit zu niedrig (< " + String(HUMIDITY_MIN, 1) + " %)\n";
    
    emailBody += "\nBitte System überprüfen!\n\n";
    emailBody += "Diese Nachricht wurde automatisch vom ESP32 Aquaponik-Überwachungssystem generiert.";
    
    message.text.content = emailBody.c_str();
    message.text.charSet = "utf-8";
    message.text.transfer_encoding = Content_Transfer_Encoding::enc_7bit;
    message.priority = esp_mail_smtp_priority::esp_mail_smtp_priority_high;
    
    // E-Mail senden
    if (!MailClient.sendMail(&smtp, &message)) {
        Serial.println("FEHLER beim E-Mail-Versand");
        Serial.println(smtp.errorReason());
    } else {
        Serial.println("E-Mail erfolgreich versendet!");
    }
    
    // SMTP-Session schließen
    smtp.closeSession();
    Serial.println("==========================\n");
}