#include <PubSubClient.h>     //Library PubSubClient einbinden
#include <ESP8266WiFi.h>      //Library Wifi einbinden
#include <Wire.h>             //Library i2c-Bus einbinden
#include <OneWire.h>
#include <BME280I2C.h>
#include <DallasTemperature.h>

// Change this before you flash
#define ssid "SSID"                      //SSID Wifi
#define pass "PASSWORD"                   //Passwort Wifi
#define MQTTServer "test.mosquitto.org"             //MQTT-Server-Adresse
//#define MQTTUser "Benutzer-Login"                 //MQTT-User
//#define MQTTPW "Benutzer-Passwort"                //MQTT-Passwort
#define MQTTPort 1883                             //MQTT-Port des Servers

//Funktionen vordefinieren
void mqttconnect();

//Clients definieren
WiFiClient client;              //Wifi-Client
PubSubClient mclient(client);   //MQTT-Client

//Sensoren definieren
#define ONE_WIRE_BUS D1
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
float WTemp = 0;
/* DS18B20 ENDE */
/* Temperaturalarm */
#define ledRd D7
#define ledYe D8
const float alarmtempHigh = 28;
const float alarmtempLow = 6;
boolean error = false;
/* Temperaturalarm ENDE */
/* BME280 */
BME280I2C bme;
float temp(NAN), hum(NAN), pres(NAN);
BME280::TempUnit tempUnit(BME280::TempUnit_Celsius);
BME280::PresUnit presUnit(BME280::PresUnit_hPa);
/* BME280 ENDE */

//Variablen definieren
boolean wifiConnected = false;    //Wifi verbunden (richtig/falsch)
char buffers[10];                 //Zwischenspeicher für Daten in Variable/Array "buffers" puffern
const long interval = 10000;      //Interval für das Senden der Daten in Millisekunden = 10 Sekunden
unsigned long previousMillis = 0; //vorherige Millisekunden (für Timerfunktion)

void setup() {
  // hier steht der Setup-Code drin
  Wire.begin(D5, D6);           //i2c-Bus starten (Pin D5 = SDA, Pin D6 = SCL)
  Serial.begin(115200);         //Serielle Schnittstelle starten mit 115200 Baud
  if (!bme.begin()) {           //BME280 starten, wenn nicht startet, dann Fehlermeldung
    Serial.println("Kann BME280 nicht initialisieren!");
  }

  wifiConnected = connectWifi();              //W-Lan verbinden
  Serial.println();                           //Leerzeile im seriellen Monitor ausgeben
  Serial.print("Verbunden? ");                //"Verbunden?" im seriellen Monitor ausgeben
  Serial.println(wifiConnected);              //true oder false aus der Variable wifiConnected ausgeben und nächste Zeile
  mclient.setServer(MQTTServer, MQTTPort);    //MQTT-Server und -Port setzen
  mclient.setCallback(m_callback);            //Antwort-Funktion definieren, welche die Antworten des MQTT-Servers auswertet
  mqttconnect();                              //mit MQTT-Server verbinden
}

void loop() {
  // hier steht der Code, der ständig durchlaufen werden soll drin
  unsigned long currentMillis = millis();                                         //Variable currentMillis speichert die aktuellen Millisekunden seit dem Start des ESP
  if (currentMillis - previousMillis >= interval || currentMillis < 8000) {       //wenn Millisekunden seit dem Start - vorherige Millisekunden größer/gleich der Intervallzeit sind oder Millisekunden seit dem Start kleiner als 8000 sind, dann Code ausführen (Timer)
    previousMillis = currentMillis;                                               //vorherige Millisekunden = Millisekunden seit Start, um den Timer auf Null zu setzen
    Serial.println();                                                             //Leerzeile im seriellen Monitor ausgeben

    sensors.requestTemperatures();
    WTemp = 1 + sensors.getTempCByIndex(0);
    if (WTemp == 85 || WTemp == -126) { //85°C = max. Temperatur oder Fehler / Lesefehler
      Serial.println("DS18B20 nicht gefunden");
    }
    bme.read(pres, temp, hum, tempUnit, presUnit);
    Serial.println(pres);
    if (pres != pres || pres == NAN) {
      Serial.println("BME nicht gefunden!");
    }

    //MQTT übertragen
    dtostrf(temp, 5, 1, buffers);                         //Variable "temp" in Char-Array umwandeln und im Puffer speichern (5 Stellen vor dem Komma, eine Stelle nach dem Komma)
    mclient.publish("teich/sensoren/temp", buffers, true);   //Puffer-Inhalt (Temperatur) an den MQTT-Broker senden, Kanal = "haus/sensor/temp", true bedeutet, dass die Daten vom Broker gespeichert werden, bis neue Daten kommen
    dtostrf(pres, 5, 0, buffers);                         //Variable "pres" in Char-Array umwandeln und im Puffer speichern (5 Stellen vor dem Komma, keine Stelle nach dem Komma)
    mclient.publish("teich/sensoren/pres", buffers, true);   //Pufferinhalt senden
    dtostrf(hum, 5, 1, buffers);                          //...
    mclient.publish("teich/sensoren/hum", buffers, true);    //...
    dtostrf(WTemp, 5, 1, buffers);                          //...
    mclient.publish("teich/sensoren/WTemp", buffers, true);    //...
  }

  //wenn Verbindung zum MQTT-Broker verloren, dann neu verbinden ansonsten Verbindung halten
  if (!mclient.connected()) {
    mqttconnect();
  } else {
    mclient.loop();
  }
}

//Funktion W-Lan verbinden
boolean connectWifi() {
  boolean state = true;         //Variable status definieren
  int i = 0;                    //Zähler-Variable für Timeout definieren
  WiFi.disconnect();            //falls noch mit W-Lan verbunden, dann trennen (Vermeidung von Fhelermeldungen)
  WiFi.mode(WIFI_STA);          //Wifi-Modus festlegen
  WiFi.begin(ssid, pass);       //W-Lan verbinden
  Serial.println();             //Leerzeile einfügen und Infotext ausgeben
  Serial.println("Connecting to WiFi");
  Serial.print("Connecting ...");
  //auf Verbindung warten
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);                 //500 Millisekunden warten
    Serial.print(".");
    if (i > 10) {               //nach 10 Versuchen Verbindungsversuch abbrechen und While-Schleife verlassen, status = falsch bedeuten hier keine Verbindung
      state = false;
      break;
    }
    i++;                        //Timeoutzähler nach jedem durchlauf um 1 höher zählen
  }

  if (state) {                  //wenn status == true (hier abgekürzt), Verbindungsdaten im Seriellen Monitor ausgeben
    Serial.println("");
    Serial.print("Connected to ");
    Serial.println(ssid);
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  } else {                      //andernfalls Verbindung fehlgeschlagen auf dem seriellen Monitor ausgeben
    Serial.println("");
    Serial.println("Connection failed.");
  }

  return state;                 //übergebe status-Variable an die aufrufende Instanz (z.B. Zeile 39)
}

//Funktion zum Verbinden des MQTT-Servers
void mqttconnect() {
  Serial.println("Verbinde mit dem MQTT-Service!");     //Ausgabe serieller Monitor
  int i = 0;                                            //Zähler-Variable für Timeout
  mclient.setServer(MQTTServer, MQTTPort);              //Serverdaten setzen
  char clientID[9];                                     //Client-Variable definieren als char-Arry mit 9 Zeichen

  static const char alphanum[] = "0123456789"
                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                 "abcdefghijklmnopqrstuvwxyz";  // Variable Zum Generieren einer zufälligen Zeichernfolge (alphanumerisch)
  for (int i = 0; i < 8; i++) {                                 // Schleife 8x durchlaufen und bei jedem Durchlauf eines der 51 Zeichen zufällig in das Array ablegen
    clientID[i] = alphanum[random(51)];
  }
  clientID[8] = '\0';                                           // an letzetr Stelle des Arrays einen Abschluss setzen
  if (!mclient.connect(clientID)) {           //Verbindung herstellen und Verbindungsdaten ausgeben
    Serial.print("Connected with Client ID:  ");
    Serial.print(String(clientID));
    /*Serial.print(", Username: ");
    Serial.print(MQTTUser);
    Serial.print(" , Password: ");
    Serial.println("********"); */
  }
  Serial.println("Mit dem MQTT-Service Verbunden");
  mclient.subscribe("haus/aktoren/#");                          //den Kanal "haus/aktoren/#" abonieren... # ist ein Platzhalter für alle untergeordnetetn Kanäle
}

//Funktion für MQTT-Broker-Antworten vom abonnierten Kanal
void m_callback(char* topic, byte* payload, unsigned int length) {  //Topic = Kanal / Payload = Nachricht, Length = Nachrichtenlänge

  std::string plr( reinterpret_cast<char const*>(payload), length ) ; //Nachricht in String (Text) konvertieren und im Seriellen Monitor Kanal und nachricht ausgeben
  int pl = atoi( plr.c_str() );
  String top = (String)topic;
  String pay = (String)pl;
  Serial.println("Topic: " + top);
  Serial.println("Payload: " + pl);

  if ( top == "haus/aktoren/relais1" ) {    //wenn der Kanal "haus/aktoren/relais1" ist, dann eine näher zu definierende Aktion durchführen, z.B. Relais1 schalten
    if (pl > 0) {
      //Code für Relais1 auschalten
    } else {
      //Code für Relais1 einschalten
    }
  }
}