/**
 * Power Regler DTZ
 * Version 0.20
 * 19.10.2022 P. Rebesky
 * author Creator P.Rebesky
 * Copyright (©): 2020-2022 by Peter Rebesky
 * This code can use in private cases only. Every business or companies using of this codes or codes parts is required an approval of us (me)
 * Every private using can exchange some parts of code or modify some code-lines. This code is allowed change for private use only.
 * This software is basicly owned by Peter Rebesky and any comercial using is forbidden without approval of us (me).
 **/
//#define DEBUG
//#define DEBUG_PAYLOAD
//#define DEBUG_VALUE
//#define DEBUG_CONNECT
#define OTA_on
#define ESPRAM "R1M"  // for 1 MB memory
//#define ESPRAM "R2M" // for 2 MB memory

#include <ESP8266WiFi.h>          //ESP8266 Core WiFi Library
#include <ESP8266WiFiMulti.h>     //ESP8266 Core WiFi Library
#include <DNSServer.h>
#include <ESP8266WebServer.h>     //Local WebServer
#include "configPWR.h"
#include "strings.h"
#include <LittleFS.h> // LittleFS is declared
#include <NTPClient.h>
#include <base64.h>
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <pgmspace.h>
#ifdef OTA_on
  #include <WiFiUdp.h>
  #include <ESP8266httpUpdate.h>
#endif

//ADC_MODE(ADC_VCC);
#ifdef DEBUG
#define BoardTaster 2
#else
#define BoardTaster 1
#endif
#define LEDred 13
#define LEDboard 2
#define RELAIS 14
#define RFinput 12
#define OFF 0
#define ON 1
#define ESPstart 2
#define LOST 3
#define WIFIerror  4
#define RESTART 5
#define UPDATE 6
#define NEWSSID 7
#define SHUTDOWN 8
#define NEWTIME 9
#define FLASHTIME 300
#define MESZ 0  // summer-time = 1 else winter-time = 0
#define TimeOf2021 1640998800
#define bufferLength 150
#define YEAR 0
#define MONTH 1
#define DAY 2
#define HOUR 3
#define MINUTE 4
#define SECOND 5

const long _utcOffsetInSeconds = 3600;
int _year = 0; int _month = 0; int _day = 0;
int _hour  = 0; int _minute =0; int _second =0;
int _date_time[6]; //[YEAR][MONTH][DAY][HOUR][MINUTE][SECOND]
uint32_t _timestamp = 0;
unsigned int _waitTimeCount =0;
uint32_t _previousMillis = 0;
uint32_t _secondMillis  =0;
int _errorCount=0;
int _flashCounter = 0;
unsigned int _onTime = 0;
bool _receivedOK = false;
String _TransmitResult;
int _historyPointer=0;
int _valueMem =0;
int _errorWait =0;
int _actualConsumption=0;
uint32_t _history[bufferLength][2];

WiFiManager wm; // global wm instance
//WiFiManagerParameter custom_field; // global param ( for non blocking w params )
WiFiServer server(80);
ESP8266WiFiMulti WiFiMulti;
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", _utcOffsetInSeconds);
configPWR cPWR;

//*********************** use WIFI manager by Tzapu https://github.com/tzapu/WiFiManager ************************************
bool setupWIFI() {
  WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
  pinMode(LEDred, OUTPUT);  // set as output
  digitalWrite(LEDred,ON); // show setup-mode on LED
  delay(1000);
//  Serial.println("\n Starting");
  std::vector<const char *> menu = {"wifi","info","sep","restart","exit"};
  wm.setMenu(menu);

  // set dark theme
  wm.setClass("invert");
//set static ip
//  wm.setSTAStaticIPConfig(IPAddress(192,168,0,10),IPAddress(192,168,0,1),IPAddress(255,255,255,0),IPAddress(8,8,8,8)); // set static ip,gw,sn,dns
//  wm.setShowStaticFields(true); // force show static ip fields
//  wm.setShowDnsFields(true);    // force show dns field always
  
  wm.setConfigPortalTimeout(500); // auto close configportal after n seconds
//  checkButton();                  // if pressed then reset WIFI config to start new change ssid
  bool res;
  res =   wm.autoConnect("PWR_Setup"); // anonymous ap, first parameter is name of access point
  if(!res) {
    return false;
  } 
  else {
    return true;
  }
}
//************************* press button for set a new SSID **********************************
void checkButton(){
  // check for button press
  if ( digitalRead(BoardTaster) == LOW ) {
    // poor mans debounce/press-hold
    delay(50);
    if( digitalRead(BoardTaster) == LOW ){
      digitalWrite(LEDred,OFF);           // LED OFF
      delay(5000); // reset delay hold
      if( digitalRead(BoardTaster) == LOW ){
        digitalWrite(LEDred,ON);           // show button pressed on LED
        wm.resetSettings();
        delay(100);
        wm.resetSettings();
        for(int i=0;i<50;i++){
          if(i%2)digitalWrite(LEDred,ON); 
          else digitalWrite(LEDred,OFF);
          delay(50);
        }
        saveHistoryStatus(NEWSSID);
        cPWR.saveHistory(getRawHistory());
        delay(100);
        ESP.restart();
      }
    }
  }
}
//*************************** function by WIFI manager ********************************
String getParam(String name){
  //read parameter from server, for customhmtl input
  String value;
  if(wm.server->hasArg(name)) {
    value = wm.server->arg(name);
  }
  return value;
}
//*************************** function by WIFI manager ********************************
void saveParamCallback(){
#ifdef DEBUG_VALUE
  Serial.println("[CALLBACK] saveParamCallback fired");
  Serial.println("PARAM customfieldid = " + getParam("customfieldid"));
#endif
}
//*************************** function for get time & date as timestamp ********************************
bool syncron_NTP_Time() {
    timeClient.begin();
    if(timeClient.update()) {
      uint32_t timeNTP = timeClient.getEpochTime();
      if(timeNTP !=0){
        _timestamp = timeNTP + (MESZ * 3600); // 3600 means add 1 hour
        return true;
      }
    }
    return false;
}
//*************************** create a string from values for data and time ********************************
//*** time ***
String getTime2String(int hour,int minute,int second){    
    String acttime;
    if(hour < 10) acttime += "0"; // if value < 10 then show a zero before
    acttime += String(hour); //combine string for time
    acttime += ":";
    if(minute < 10) acttime += "0";
    acttime += String(minute);
    acttime += ":";
    if(second < 10) acttime += "0";
    acttime += String(second);
return acttime;
} 
//*** date ***   
String getDate2String(int year,int month,int day){    
    String actdate;
    if (day < 10) actdate += "0"; // if value < 10 then show a zero before
    actdate += String(day); //combine string for time
    actdate += ".";
    if(month < 10) actdate += "0";
    actdate += String(month);
    actdate += ".";
    if(year < 10) actdate += "0";
    actdate += String(year);
return actdate;
}
//**************************** intern clock *******************************
bool internClock(uint32_t currentMillis) {
  if (currentMillis < _secondMillis) _secondMillis = 0; // handle if currentMillis are overflows, max 32 bits
  if (currentMillis - _secondMillis >=1000){
      _secondMillis = currentMillis;
      _second++;
      _timestamp++;
      if (_second >=60){ _second=0, _minute++;}
      if (_minute >=60){ _minute=0, _hour++;}
      if (_hour >=24){ _hour=0; _day++;}
      return true;
   }
   else return false;
}
//***************************** show Data on WEB-Browser ******************************
void check4Client() {
 // Check if a client has connected
  String argument;
  String PostValues;
  if (WiFi.status() == WL_CONNECTED) {
        WiFiClient client = server.available();
        if (!client) {
          return;
        }
        // Wait until the client sends some data
        unsigned long timeout = millis() + 3000;
        while (!client.available() && millis() < timeout) {
          delay(1);
        }
        if (millis() > timeout) {
//          Serial.println("timeout");
          client.flush();
          client.stop();
          return;
        }
 // Read the first line of the reply from server and copy it into variable "argument"
        if(client.available()){
          String methode;
          String line;
          methode = client.readStringUntil(' ');
          if (methode == "GET")  line = client.readStringUntil('\n');
          else {
            line = client.readString();
            int postBegin = line.indexOf("\r\n\r\n");
            PostValues = line.substring(postBegin+4, line.length());
          }
          int argEnd = line.indexOf("HTTP");
          argument = line.substring(0, argEnd-1);
          argEnd = line.indexOf("?");
          if(argEnd>0 && methode == "GET"){
            argument = line.substring(0, argEnd); // cut the values after ?
          }
//          Serial.println(argument); // debug
//          Serial.println(PostValues); // debug
        
 // Match the request
          client.flush();
          String s;
          if (argument == "/status"){ //depricated
            s = HTTP_ANSWERJSON;
            s += getStatus();
          }
          else if (argument == "/ontime"){ //depricated
            s = HTTP_ANSWERJSON;
            s += getOnTime();
          }
          else if(argument == "/xmlHttp"){
            s = HTTP_ANSWERJSON;
            s += getData();
          }
          else if(argument == "/reOn"){
            digitalWrite(RELAIS, ON);  // set relais on
            s = HTTP_ANSWERJSON;
            s += getData();
            saveHistoryRelais();
          }
          else if(argument == "/reOff"){
            digitalWrite(RELAIS, OFF);  // set relais off
            s = HTTP_ANSWERJSON;
            s += getData();
            saveHistoryRelais();
          }
          else if (argument == "/save") {
            cPWR.savePostValues(PostValues);
            s = HTTP_ANSWER;
            s += HTTP_HEAD_PWR;
            s += "<title>"; s += cPWR.getPName(); s += "</title>";
            s += HTTP_BODYSTYLE_PWR; s += "<body>";   
            s += HTTP_DIV_FIELD;
            s += "<p><b>Ihre Eingaben wurden gespeichert.</b></p>";
            s += "<hr><p><form action=\"back\" method=\"get\"><button type=\"submit\">OK</button></form></p>";
            s += HTTP_TEXT_END;
          }
          else if (argument == "/setup") {
            s = HTTP_ANSWER;
            s += HTTP_HEAD_PWR;
            s += "<title>"; s += cPWR.getPName(); s += "</title>";
            s += HTTP_BODYSTYLE_PWR; s += "<body>";   
            s += HTTP_DIV_FIELD;
            s += "<p><b>Einstellungen</b></p>";
            s += "<form action=\"save\" method=\"post\">";
//            s += "<p><label>Zähler-ID:</label><br><input type=\"text\" value=\""; s += "empty"; s += "\" disabled></p>";
            s += "<p><label>Reglername:</label><br><input type=\"text\" name=\"rname\" maxlength=\"32\" value=\""; s += cPWR.getPName(); s += "\" required></p>";
            s += "<p><label>Wert in W Aktion an:</label><br><input type=\"number\" name=\"von\" value=\""; s += cPWR.getValueON(); s += "\" required></p>";
            s += "<p><label>Wert in W Aktion aus:</label><br><input type=\"number\" name=\"voff\" value=\""; s += cPWR.getValueOFF(); s += "\" required></p>";
            s += "<p><label>Aktion Wartezeit in s:</label><br><input type=\"number\" name=\"wait\" min=\"2\"  max=\"3600\" value=\""; s += cPWR.getWaitAction(); s += "\" required></p>";
            s += "<p><label>Scaninterval Zähler in s:</label><br><input type=\"number\" name=\"scan\" min=\"2\"  max=\"3600\" value=\""; s += cPWR.getScanTime(); s += "\" required></p>";
            s += "<p><label>Ausschalten nach Errors:</label><br><input type=\"number\" name=\"error\" min=\"1\"  max=\"10\" value=\""; s += cPWR.getErrorWait(); s += "\" required></p>";
            s += "<p><label>Zähler-IP:</label><br><input type=\"text\" name=\"turl\" maxlength=\"64\" value=\""; s += cPWR.getTargetMeter(); s += "\" required></p>";

            s += "<p>Automatik: <label>AN</label><input style=\"width:10%\" type=\"radio\" name=\"ract\" value=\"1\"";if(cPWR.getActionOn())s+="checked"; s+=">";
            s += "<label>AUS</label><input style=\"width:10%\" type=\"radio\" name=\"ract\" value=\"0\"";if(!cPWR.getActionOn())s+="checked"; s+="></p>";
            
//            s += "<p>Master / Slave:<input style=\"width:10%\" type=\"radio\" name=\"masla\" value=\"1\"";if(cPWR.getIfMaster())s+="checked"; s+="><label>Master</label>";
//            s += "<input style=\"width:10%\" type=\"radio\" name=\"masla\" value=\"0\"";if(!cPWR.getIfMaster())s+="checked"; s+="><label>Slave</label></p>";
            
            s += "<p><label>Update Server:</label><br><input type=\"text\" name=\"upser\" maxlength=\"64\" value=\""; s += cPWR.getUpdateServer(); s += "\" required></p>";
            s += "<hr><p><button type=\"submit\">Speichern</button>";
            s += "<button type=\"submit\" formaction=\"back\">Abruch</button></p></form>";
            s += "<hr>Regler-Version: "; s += PWRVersion;
            s += "<br><a href=\"firmware\">Check for update firmware</a>";
            s += "<br><hr><p><a href=\"https://infozaehler.de/help.html\"/help.html\">Hilfe & Impressum</a></p>";
            s += HTTP_TEXT_END;
          }
           else if (argument == "/favicon.ico") {
            s = HTTP_ANSWER;
            s += "none";
          }
          else if (argument == "/searchLogger") {
            s = HTTP_ANSWER;
            int argBegin = line.indexOf("?");
            s += "{\"DTZLOGGER\":\"" + PWRVersion + "\"}";
          }
          else if (argument == "/" || argument == "/back") {
            // Prepare the response
            s = HTTP_ANSWER;
            s += HTTP_HEAD_PWR;
            s += "<title>"; s += cPWR.getPName(); s += "</title>";
            s += HTTP_BODYSTYLE_PWR;       s += "<body>";   
            s += HTTP_DIV_FIELD;
            s += "<p><b>PW-Switch-Status</b></p>";
            s += "<p>Zeit: <a style=\"text-decoration:none\" href=\"setTime\">&#x1F504;</a><br>";
            s += "<input value=\""; s+=getTime2String(_hour,_minute,_second); s += "\" readonly><br>";
            s += "Datum:<br><input value=\""; s+=getDate2String(_year,_month,_day); s += "\" readonly><br>";
            s += "PW-Switch-IP:<br><input value=\"";  s += WiFi.localIP().toString(); s += "\" readonly><br>";
            s += "</p>";
            s += _TransmitResult;
            s += "<hr>";
            s += "<p><b>"; s += cPWR.getPName(); s += "</b> aktiv: ";
            if(cPWR.getActionOn()) s+="&#9989;"; else s += "&#128542;";
            s +="</p>";
            s += "Verbunden mit Zähler: <span id=\"con\">";
            if(_receivedOK == true)s += "&#9989;";  // show a red bubble when StromLog not connect on server at the first time
            else s += "&#128542;";
            s += "</span><br>Status Relais: <span id=\"rel\">";
            if(digitalRead(RELAIS))s += "&#128077;";  // show status of relais
            else s += "&#128078;";
            s += "</span><br>";
            s += "Tages Einschaltzeit: <span id=\"ont\">"; s+=_onTime/60; s+="</span> Minuten<br>";
            
            s += "<p>Aktuelle Leistung: <b><span id=\"actc\">"; s+=_actualConsumption; s += "</span> W</b><br>";
            if(cPWR.getActionOn()){
              s += "Relais<br>AN  < "; s+=cPWR.getValueON(); s+=" W<br>AUS > "; s+=cPWR.getValueOFF(); s+="W";
            } else {
              s += "<button onclick=\"ron()\">Relais an</button><br>";
              s += "<button onclick=\"roff()\">Relais aus</button>";
            }
            s += "<br></p>";
            s += "Einschalt Wartezeit: <span id=\"wait\">"; s+= cPWR.getWaitAction()-_waitTimeCount; s+="</span> s<br><hr>";
            s += "Protokoll Errors: <span id=\"err\">"; s+= _errorCount; s+="</span><br>";
            s += HTTP_HISTORY_BUTTON;
            s += HTTP_SETUP_BUTTON;
//            s += "<span id=\"check\" onclick=\"set()\">Text</span>\n";
            s += "<hr><p><a href=\"https://infozaehler.de/help.html\">Hilfe & Impressum</a></p>";
            s += "</div>\n";
            s += "<script>setInterval('set()',"; s+=cPWR.getScanTime()*1000; s+=");</script>";
            s += HTTP_JS_SCRIPT;
          }
          else if (argument == "/memory") {
            s = HTTP_ANSWER;
            s += "Free space: "; s += cPWR.FREESPACE; s += "<br>";
            s += HTTP_TEXT_END;
          }
          else if (argument == "/history") {
            s = HTTP_ANSWER;
            s += HTTP_HEAD_PWR;
            s += HTTP_BODYSTYLE_PWR; s += "<body>";
            s += HTTP_DIV_FIELD;
            s += "<br><b>PWR-Schalter History:</b><br><hr><p style=\"text-align:left\">";
            s += getHistory();
            s += "</p><hr>History End<br><br>";
            s += "<form><button type=\"submit\" formaction=\"back\">Zurück</button></form><br>";
            s += HTTP_TEXT_END;
          }
          else if (argument == "/delHistory") {
            s = HTTP_ANSWER;
            s += "Saved history will delete now!";
            s += HTTP_TEXT_END;
            cPWR.delSavedHistory();
          }
          else if(argument == "/savedhistory"){
            s = HTTP_ANSWER;
            s += cPWR.readSavedHistory();
            s += HTTP_TEXT_END;
          }
          else if(argument == "/shutdown"){
            saveHistoryStatus(SHUTDOWN);
            cPWR.saveHistory(getRawHistory());
            s = HTTP_ANSWER;
            s += "Restart power-regler now!<br>";
            s += HTTP_TEXT_END;
            delay(500);
            ESP.restart();
          }
#ifdef OTA_on
          else if (argument == "/firmware"){
            s = HTTP_ANSWER;
            s += "Your PWRegler versions number: "+Version+"<br>";
            s += "Check for new firmware now.<br>";
            s += getFilesFromServer(WiFi.localIP());
            s += HTTP_TEXT_END;
          }
          else if (argument == "/upDate"){
            int valueBegin = line.indexOf("?");
            s = HTTP_ANSWER;
            if(valueBegin > 0){
              int valueEnd = line.indexOf("HTTP");
              String argumentValue = line.substring(valueBegin+1,valueEnd-1);
              if(argumentValue.indexOf(ESPRAM)>0){  // check if the right firmware and memory of esp (1M,2M,4M....)
                s += "Update will be start now.<br>";
                s += "Update-file: "+argumentValue+"<br>";
                s += "Don't turn off power during update!<br><br>";
                s += "After update, the reconnection only via IP, without arguments behind it!<br><br>";
                s += "<a href=\"http://"+WiFi.localIP().toString()+"\">Click here for reconnect after update</a><br>";
              } else{
                s += "Wrong firmware for this IoT.<br>Update canceled.<br>";
                argument ="";
              }
            } else {
              s += "Error: Missing name of update file!<br>";
              s += "Update canceled.<br>";
              argument ="";
            }
            s += HTTP_TEXT_END;
          }
#endif
          else if(argument == "/setTime"){
            s = HTTP_ANSWER;
            s += HTTP_BODYSTYLE_PWR;       s += "<body>";   
            s += HTTP_DIV_FIELD;
            s += "<p><b>Die Uhr wird jetzt neu synchronisiert.</b></p>";
            s += "<p>Zeit:<br><input value=\""; s+=getTime2String(_hour,_minute,_second); s += "\" readonly><br>";
            if (syncron_NTP_Time() == true){
              getTime2Value(_timestamp);
              s += "Neue Zeit:<br><input value=\""; s+=getTime2String(_hour,_minute,_second); s += "\" readonly><br>";
            } else {
              s += "Serverfehler! Aktuallisierung nicht erfolgt.<br>Bitte eine Wartezeit von 2 Minuten,<br>bis zur wiederholten, manuellen Aktuallisierung einhalten.<br>";        
            }
            s += "</p><hr><p><form action=\"back\" method=\"get\"><button type=\"submit\">OK</button></form></p>";
            s += HTTP_TEXT_END;
          }
          else s = "HTTP/1.1 403 OK\r\nContent-Type: text/html\r\n\r\n";
          // Send the response to the client
          client.print(s);
          delay(1);
#ifdef OTA_on
          if(argument == "/upDate"){
            turnAllOff();
            int valueBegin = line.indexOf("?");
            if(valueBegin > 0){
              int valueEnd = line.indexOf("HTTP");
              argument = line.substring(valueBegin+1,valueEnd-1);
              delay(1000); //wait one second
              updateStromLog(argument); // start update now
            }
          }
#endif
      }   
  }
}
//*********** update new software for StromLog ***************************/
//*********** get available files ****************************************/
#ifdef OTA_on
String getFilesFromServer(IPAddress ip){
String files = "";
  if (WiFiMulti.run() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;
    String target = "http://"; target+=cPWR.getUpdateServer(); target+="/fwpwr/getFiles.php";
    if (http.begin(client,target)){
      http.addHeader("Content-Type","application/json;charset=utf-8");
      int httpCode = http.POST("{\"userIP\":\""+ip.toString()+"\",\"build\":\""+Version+"\"}");
      if(httpCode >= 100){
        files = http.getString();
      }
      else files = "Error: no connection.";
    }
    http.end();
  }
return files;  
}
//********** update, input file-name ************************************/
String updateStromLog(String file){
  saveHistoryStatus(UPDATE);
  cPWR.saveHistory(getRawHistory());
  String result = "ERROR: Update failed!";
  ESPhttpUpdate.rebootOnUpdate(false); // remove automatic update
  digitalWrite(LEDred,ON);
  WiFiClient client;
  t_httpUpdate_return ret = ESPhttpUpdate.update(client, cPWR.getUpdateServer(), 80, "/fwpwr/"+file);
  switch (ret) {
    case HTTP_UPDATE_FAILED:
      break;
    case HTTP_UPDATE_NO_UPDATES:
      break;
    case HTTP_UPDATE_OK:
      String result = "Update successful.";
      delay(500); // Wait a second and restart
      ESP.restart();
      break;
  }
return result;  
}
#endif
//*********** update end *************************************************/
//*********** send status as JSON for controling *************************/
String getStatus(){
  String json = "{\"status\":{\"relais\":"; json+=digitalRead(RELAIS); json+=",\"power\":"; json+=_actualConsumption; json+="}}";
  return json;
}
String getOnTime(){
  String json = "{\"ontime\":{\"value\":"; json+=_onTime; json+=",\"unit\":\"sec\"},\"errors\":"; json+=_errorCount; json+="}";
  return json;
}
String getData(){
  String json = "{\"ac\":"; json+=_actualConsumption; 
         json+= ",\"re\":"; json+=digitalRead(RELAIS);
         json+= ",\"ot\":"; json+=_onTime/60;
         json+= ",\"wt\":"; json+=cPWR.getWaitAction()-_waitTimeCount;
         json+= ",\"er\":"; json+=_errorCount;
         json+= ",\"co\":"; json+=_receivedOK;
         json+= "}";
  return json;
}
//*********** get json data from meter *******************/
bool getConsumptionMeter(){
bool r=false;
  if (WiFiMulti.run() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;
    String target = "http://"; target += cPWR.getTargetMeter(); target+="/consumption";
    int httpCode = 0;
    if (http.begin(client,target)){
      httpCode = http.GET();
      if (httpCode == HTTP_CODE_OK){
        _TransmitResult = http.getString();
        r=true;
#ifdef DEBUG_PAYLOAD
        Serial.println(httpCode);
        Serial.println(_TransmitResult);
#endif
      } else {_TransmitResult ="Missing answer! "; _TransmitResult +=httpCode;}
    } else _TransmitResult ="Target not found!";
    http.end();
  }
  return r;
}
/***********************************************************
* convert a unix-timestamp into single bytes as value
* function works up to 1972 until 19.01.2038
***********************************************************/
void Timestamp2DateTime(uint32_t unixTime){
  int dummy = 0; int years=0;
  uint32_t SecOfYear; uint32_t timeDummy;
  bool leapYear = false; // default: don't be a leap-year
  timeDummy = unixTime - 31536000 *2; // sub two years (1970 and 1971) add the years later
  years= (timeDummy / 126230400) *4; // get the periodes of four years cycle; 3Y+leapY = 126230400 seconds
  timeDummy = timeDummy % 126230400; // get the rest of timestamp without the cycles like above this line
  if (timeDummy >= 31622400) {
    timeDummy -= 31622400; // sub the first leap-year if it's over
    years++;  // add the leapyear
    years += timeDummy / 31536000; // get the rest of years between 0 until 2 years 
  }
  years = years + 1972; // add start-year +2: now, we know the actual year and can figure out if is a leap-year
  _date_time[YEAR]=years;
//  if (year % 4 == 0) leapYear = true; // if year divison by four without some rest, then is a leap-year...yeeeh -> it works until 2036 only
  if ( bitRead(years,0)==0 && bitRead(years,1)==0) { // it's very faster than %-arithmetic
    leapYear = true;
    SecOfYear = 31622400;   // set the counts of seconds leap-year
//    Serial.print("LeapYear ");
  } else SecOfYear = 31536000; // or don't be a leap-year -> regulary seconds
  _date_time[DAY] = (timeDummy % SecOfYear) / 86400; // get the days of actual year
  _date_time[MONTH] = 0; // set zero
  for (int i=0; _date_time[DAY]>=0; i++ ) {  // do it until the day(s) are negativ, this loop has be exicute one time -> to set month at ones
    dummy = _date_time[DAY];  // store the value befor result is negativ for break, because the last one was the day of actual month
    _date_time[DAY] = _date_time[DAY] - DaysPerMonth[i]; // sub the days of month until it's negativ, according byte-array
    if (i == 1 && leapYear == true) {_date_time[DAY] -= 1;} // sub the 29. of february on leapyears ;-)
    _date_time[MONTH]++; // add one month on every loop 
    if (i > 11) return; // if this function wild ;-) then break (max. months are 0 - 11)
  }
  _date_time[DAY] = dummy+1; // add one, because the start was on 1. january (start of timstamp = 01.01.1970 and we have to add it)
/****** get time ******/
  _date_time[HOUR] = (timeDummy % 86400) / 3600;  // the value of _timeDummy contents the rest of hours, minutes and seconds only
  _date_time[MINUTE] = (timeDummy % 3600) / 60;   // it's shorter to take reduced _timeDummy than the whole timestamp
  _date_time[SECOND] = timeDummy % 60;
// return values are in array "unsigned int _date_time[6]; //[YEAR][MONTH][DAY][HOUR][MINUTE][SECOND]"  
}
void writeTime(){
  _year = _date_time[YEAR];
  _month = _date_time[MONTH];
  _day = _date_time[DAY];
  _hour  = _date_time[HOUR]; 
  _minute = _date_time[MINUTE];
  _second = _date_time[SECOND];
}
void getTime2Value(uint32_t unixTime){
  Timestamp2DateTime(unixTime);
  writeTime();
}
//****************************** show received a protocol on red LED ***************************
void showProtocolOnLED(){
}
//*********************** decode value from JSON *********************************
void decodeValue(){
  _receivedOK=true;
  int valueBegin = _TransmitResult.indexOf("value");
  if(valueBegin >= 0){
    int valueEnd = _TransmitResult.indexOf(",",valueBegin);
      if (valueEnd != -1){ 
        String value = _TransmitResult.substring(valueBegin+7, valueEnd);
#ifdef DEBUG_VALUE
        Serial.println(value);
#endif
        _actualConsumption=value.toInt();
      }
  } else _actualConsumption=0;
} 
//********************* error handling ***********************************
void errorConnect(){
  _errorCount++;
  saveHistoryStatus(LOST);
  if(_errorWait>=cPWR.getErrorWait()){
    turnAllOff();
  }
}
//******************** turn off relais and set variable on zero **********
void turnAllOff(){
  _receivedOK=false;
  _TransmitResult="";
  _actualConsumption=0;
  digitalWrite(RELAIS, OFF);
  _waitTimeCount=0;
  saveHistoryRelais();
}
//****************** time counter until switch on ************************
bool ifWaitTimeOver(){
  _waitTimeCount += cPWR.getScanTime();
  if(_waitTimeCount >= cPWR.getWaitAction()){
    _waitTimeCount = cPWR.getWaitAction();
    return true;
  }
  else return false;
}
//*********************** handle turn on or off relais *******************
void switchRelais(){
  if(cPWR.getActionOn()){
    if(_actualConsumption < cPWR.getValueON()){if(ifWaitTimeOver())digitalWrite(RELAIS, ON);saveHistoryRelais();}else _waitTimeCount=0;
    if(_actualConsumption > cPWR.getValueOFF()){digitalWrite(RELAIS, OFF); _waitTimeCount=0;saveHistoryRelais();}
  }else 
    turnAllOff();
}
//*********************** handle status for history **********************
//*** save history ***
void saveHistoryRelais(){
  int x=digitalRead(RELAIS);
  if(x != _valueMem){
    _history[_historyPointer][0]=_timestamp;
    _history[_historyPointer][1]=x;
    _valueMem=x;
    historyPointerPlus();
  }
}
void saveHistoryStatus(int stat){
    _history[_historyPointer][0]=_timestamp;
    _history[_historyPointer][1]=stat;
    historyPointerPlus();
}
void historyPointerPlus(){
    if(_historyPointer<bufferLength-1)_historyPointer++;
    else _historyPointer=0;
    
#ifdef DEBUG_VALUE
    Serial.print("Pointer: ");
    Serial.println(_historyPointer);
#endif

}
//*** read history ***
String getHistory(){
  String h;
  int y=_historyPointer;
  for(int i=0;i<bufferLength;i++){
    if(_history[y][0] !=0){
      Timestamp2DateTime(_history[y][0]);
      h += getDate2String(_date_time[YEAR],_date_time[MONTH],_date_time[DAY]);
      h += " - ";
      h += getTime2String(_date_time[HOUR],_date_time[MINUTE],_date_time[SECOND]);
      h+=" - ";
      switch (_history[y][1]){
        case OFF:       h+="<font color=darkred>aus</font>"; break;      // 0
        case ON:        h+="an"; break;       // 1
        case ESPstart:  h+="<font color=darkgreen>Start</font>"; break;    // 2
        case LOST:      h+="<b>lost</b>";break;      // 3
        case WIFIerror: h+="<font color=red>WIFIlost</font>";break;  // 4
        case RESTART:   h+="<font color=blue>Reset</font>"; break;    // 5
        case UPDATE:    h+="Update"; break;   // 6
        case NEWSSID:   h+="Set WLAN";        // 7
        case SHUTDOWN:  h+="<font color=red>RESTART</font>";  break; // 8 NEWTIME
        case NEWTIME:   h+="TimeSync";  break; // 9 
        default:        h+="?"; 
      }
      h += "<br>";
      h += "";
    }
    y++;
    if(y>=bufferLength)y=0;
#ifdef DEBUG_VALUE
    Serial.println(_historyPointer);
    Serial.println(_history[i][0]);
#endif
  }
  return h;
}
//**** get raw history ***************************************************
String getRawHistory(){
  String h = "Pointer:"; h+=_historyPointer; h+="&";
  for(int i=0;i<bufferLength;i++){
    h+= _history[i][0]; h+=":";
    h+= _history[i][1]; h+="&";
  }
  return h;
}
//**** load history into buffer array ************************************
int loadHistory(){
  int oldPointer=0; String value; int multi;
  String s=cPWR.readSavedHistory();
  if(s.substring(0,7)=="Pointer" && s.length()>0){
    int pointerEnd = s.indexOf("&",8);
    String pointer=s.substring(8,pointerEnd);
    oldPointer=pointer.toInt();
    for(int i=0;i<oldPointer;i++){
      multi=(i*13);
      value=s.substring(multi+pointerEnd+1,multi+pointerEnd+11);
      _history[i][0]=value.toInt();
      value=s.substring(multi+pointerEnd+12,multi+pointerEnd+13);
      _history[i][1]=value.toInt();
    }
  }
  return oldPointer;
}
//*********************** setup esp on start *****************************
void setup() {

  pinMode(LEDred, OUTPUT);  // set as output
  digitalWrite(LEDred,OFF);
  pinMode(RELAIS, OUTPUT);
  digitalWrite(RELAIS, OFF);  // set relais off
  _flashCounter = 30;     // time to show flash on LED for infos
#ifdef DEBUG
  Serial.begin(115200);
#else
  pinMode(BoardTaster, INPUT_PULLUP);  // set as input
//  pinMode(LEDboard, OUTPUT);  // set as output (blue LED)
#endif
  delay(200);

  wifi_station_set_hostname("PWR_StromLog"); // set hostname into WLAN network
  bool result = setupWIFI();
  if (result) {
    cPWR.begin();  // start filesystem and properties of user 
    server.begin();
    syncron_NTP_Time();
    getTime2Value(_timestamp);
    delay(200);
 }
  else {
    for (int i=0 ; i<20;i++){
      if (digitalRead(LEDred) == HIGH)digitalWrite(LEDred,OFF); else digitalWrite(LEDred,ON);
      delay(200);
    }
    ESP.restart();
  }
  _historyPointer=loadHistory();
  saveHistoryStatus(ESPstart);
}
//************************* esp loop function ***************************
void loop() {
  yield();
  checkButton();    // check if user pressed button for set new SSID
  uint32_t currentMillis = millis();
  if(internClock(currentMillis)== true) { // every second will run this component
    if (_flashCounter > 0){    // Flash LED when errors occurs or for information
      if (digitalRead(LEDred) == HIGH)digitalWrite(LEDred,OFF); else digitalWrite(LEDred,ON);
      _flashCounter --;
    } else digitalWrite(LEDred,OFF); // if flashtime over turn off LED
    if (_hour == 23 && _minute==1 && _second==3){ // update _timestamp
      if (syncron_NTP_Time() == true){
        getTime2Value(_timestamp);
        saveHistoryStatus(NEWTIME);
      }
      cPWR.saveHistory(getRawHistory());
      _onTime=0;
      _errorCount=0;
      
    }
    if (_timestamp < TimeOf2021 && _second == 50) {
       if (syncron_NTP_Time() == true) getTime2Value(_timestamp);  // get timestamp again if sync was failure, perhaps after power down
    }
    if(_second % cPWR.getScanTime() == 0){ // handle get data from meter and switch relais
      if(cPWR.getActionOn()){             // is automatic on
        if(getConsumptionMeter()){        // get value of consumption from meter
          decodeValue();                  // decode value of consumption
          _TransmitResult="Connect with Target (Meter or Master)";
          _errorWait=0;                   // set error wait of zero
          switchRelais();                 // handle turn on of relais
        } else {
          _errorWait++;                   // count error wait
          errorConnect();                 // if connection lost turn off relais after errorWait value
          _TransmitResult="Target not found! Timeout!";
          if(!WiFi.isConnected()){
            _flashCounter=20;
            saveHistoryStatus(WIFIerror);
            if(_errorWait > 20){
              saveHistoryStatus(RESTART);
              cPWR.saveHistory(getRawHistory());
              delay(500);
              ESP.restart();  // connect lost do restart
            }
          }
        }
#ifdef DEBUG_CONNECT
        Serial.print("Status: "); Serial.println(WiFi.status());
        Serial.print("RRSI: "); Serial.println(WiFi.RSSI());
        Serial.print("ErroWait: "); Serial.println(_errorWait);
#endif
      }// else turnAllOff();
    }
    if(digitalRead(RELAIS)==1)_onTime++;
  }
  check4Client(); // thats it's if with the browser show data on port 80 by html
 }