/**
 * SALATMASCHINE
 *
 * Microcontroller

 * ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102 (Nachfolgermodell zum ESP8266)
 * ESP32 NODEMCU Module WiFi Development Board with CP2102 (successor model for the ESP8266) Compatible with Arduino
 * Zusätzliche Boardverwalter URL eintragen:
 * https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json <- klappt nicht!
 * https://dl.espressif.com/dl/package_esp32_index.json <- alte Version
 * Open Boards Manager from Tools > Board menu and install esp32 platform (and do not forget to select your ESP32 board from Tools > Board menu after installation).
 * ESP32 Dev Module
 * Das ist aber ein ESP32-WROOM-DA Module
 * Partition Scheme "No OTA(1MB APP/3MB SPIFFS")
 *
 * Es braucht scheinbar auch noch den CP201x Universal Driver (09.06.2023)
 * https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers?tab=downloads
 * Installieren über Gerätetreiber -> Treiber aktualisieren -> auf Computer suchen
 *
 * Relais
 * HW-383 2-Channel-Relais
 *
 * OLED
 * AZ-Delivery 1.3" I²C OLED Display
 *
 * Temperatur
 * Dallas DS18B20
 */
int version = 20240927;

#include <Arduino.h>
#include "arduino_secrets.h"
#include "pins.h"

  // ----------------------------------------------------------------------------------------------------------------
  // alle variablen hier als unsigned long
  // mit int gab es bei langen Perioden Überläufen
  unsigned long std_duration_interval = 1200000;  // in ms
unsigned long std_max_water = 6000;               // in ms

bool useTemperature = false;  // gibt es Sensoren bzw. sollen die ausgelesen werden?
bool useHumidity = false;     // gibt es Sensoren bzw. sollen die ausgelesen werden?
bool useButtons = true;      // gibt es Sensoren bzw. sollen die ausgelesen werden?
bool useSalatserver = true;  // gibt es Sensoren bzw. sollen die ausgelesen werden?
bool useSalatdisplay = true;      // gibt es Sensoren bzw. sollen die ausgelesen werden?

bool useDryWetTrigger = false;
// int
int minMoisture = 25;  // bei weniger Feuchtigkeit wird gewässert

// der häufigere Intervall für die vom MoistureSensor gesteuerte (Wert ist unter minMoisture) dry-Phase
// wird aus std_duration_interval errechnet
unsigned long moisture_interval_divider = 3;  // Zeit seit der letzten Wässerung in ms

unsigned long dry_since = 0;      // Zeit seit der letzten Wässerung in ms
unsigned long first_water = 0;    // Zeitpunkt Start Waesserung in ms
unsigned long last_water = 0;     // Zeitpunkt letzte Waesserung in ms
unsigned long max_water;          // Dauer Wasser in ms
unsigned long duration_interval;  // Interval in ms
bool pump_on = false;             // Pumpe an


unsigned long dry_time_left;  // vebleibende Zeit bis Start Waesserung in ms
unsigned long wet_time_left;  // Vebleibende Zeit bis Ende Waesserung in ms
// ----------------------------------------------------------------------------------------------------------------
float uptime;

// Messzyklus für alle Sensoren
unsigned long duration_interval_measure = 5000;  // Interval in ms
unsigned long last_measure = 0;                  // Zeitpunkt letzte Messung in ms

// Zyklus Display
unsigned long duration_interval_display = 1000;  // Interval in ms
unsigned long last_display = 0;                  // Zeitpunkt letzte Messung in ms

const char* message = "";  // Meldungen für DB und Webseite
// ----------------------------------------------------------------------------------------------------------------
bool firstStep = true;
String trigger = "wet";
// ---------------------------------------------------------------------------------------------------------------
#include "temperature.h"
#include "humidity.h"
#include "buttons.h"
#include "salatserver.h"
#include "display.h"
#include "salatclient.h"
// ----------------------------------------------------------------------------------------------------------------

void pumpOn() {
  // pumpe anschalten
  digitalWrite(relais, LOW);
  pump_on = true;

  first_water = millis();
  last_water = 0;
  dry_since = 0;
  Serial.println("pumpON-Pumpe via Relais 1 an");
  // Pumpe an - LED aus
  digitalWrite(LED, LOW);

  // Daten an serverExt senden via salatclient
  sendDataToExtern();
}
void pumpOff() {

  digitalWrite(relais, HIGH);
  pump_on = false;

  first_water = 0;
  last_water = millis();
  Serial.println("pumpOFF-Pumpe via Relais aus");
  // Pumpe aus - LED an
  digitalWrite(LED, HIGH);
}
void setup() {
  Serial.begin(9600);
  Serial.println("Salatmaschine startet");

  // LED
  // LED geht nach dem ERSTEN MAL pumpen an ... vorher ist pump_on NULL
  pinMode(LED, OUTPUT);

  // Relais
  pinMode(relais, OUTPUT);
  digitalWrite(relais, HIGH);
  // pinMode(relais_2, OUTPUT);
  // digitalWrite(relais_2, HIGH);
  pump_on = false;

  // Initialwerte setzen
  max_water = std_max_water;                  // millis
  duration_interval = std_duration_interval;  // millis
  last_water = millis();                      // millis
  if (useButtons) {
    setupButtons();
  }
  if (useTemperature) {
    setupTemperature();
  }
  if (useHumidity) {
    setupHumidity();
  }
  if (useSalatdisplay) {
    setupDisplay();
  }
  if (useSalatserver) {
    setupSalatserver();
  }
}
void loop() {
  
  
  if (useButtons) {
    loopButtons();
  }



  // Time is up - dies ist der große Intervall - Pumpe wird angeschaltet
  // Wässern auf jeden Fall, wenn der Intervall abgelaufen ist
  if ((millis() > (last_water + duration_interval)) && pump_on == false) {
    // pumpe anschalten
    pumpOn();
  }


  // Pumpe läuft ....
  if (pump_on == true) {
    wet_time_left = max_water - (millis() - first_water);
    // Pumpe abschalten, wenn genug gewässert
    if (millis() > (first_water + max_water)) {
      wet_time_left = 0;
      // Pumpe aus
      pumpOff();
    }
  } else {
    dry_time_left = (duration_interval - (millis() - last_water));
    dry_since = millis() - last_water;
  }


  /**
   * Sensoren auslesen
   */
  if (millis() > (last_measure + duration_interval_measure)) {
    uptime = millis() / 1000;
    if (useTemperature) {
      getTemperature();
    }
    if (useHumidity) {
      getHumidity();
    }
    Serial.println("xxxxx");

    Serial.print("uptime ");
    Serial.println(uptime / 1000);
    Serial.print("last_water ");
    Serial.println(last_water / 1000);
    Serial.print("duration_interval ");
    Serial.println(duration_interval / 1000);
    Serial.print("max_water ");
    Serial.println(max_water / 1000);
    Serial.print("dry_since ");
    Serial.println(dry_since / 1000);
    Serial.print("message ");
    Serial.println(message);

    // je nach Feuchtigkeit - im kleinen Intervall (immer 1/3 vom großen Intervall)
    if ((moistureValuePercent < minMoisture) && useDryWetTrigger) {
      trigger = "dry";
      // duration_interval = std_duration_interval / moisture_interval_divider;

      Serial.println("triggerDRY");
    } else {

      Serial.println("triggerWET");
      trigger = "wet";
      // duration_interval = std_duration_interval;
    }

    last_measure = millis();
  }




  if (millis() > (last_display + duration_interval_display)) {
    if (useSalatdisplay) {
      loopSalatdisplay();
    }
  }
}