#include <FS.h>
#include <TimeLib.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
//Wlan settings
const char *ssid = "WLAN NAME";
const char *pass = "WLAN PASSWORD";

const int sleepSeconds = 30;
const int timeZone = 1;     // Central European Time

int trigger = 12;   // D6
int echo = 13;      // D7
long dauer = 0;
long entfernung = 0;

//FTP buffers
char outBuf[128];
char outCount;

//WiFi Clients
WiFiUDP Udp;
unsigned int localPort = 8888;  // local port to listen for UDP packets

static const char ntpServerName[] = "us.pool.ntp.org";
const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets

//FTP settings
char* FTPfilename = "data.txt";
char* FTPhost = "192.168.178.1"; //Fritz Box
char* FTPusername = "FTP USER NAME";
char* FTPpassword = "FTP PASSWORD";
char* FTPfolder = "/";
short FTPresult; //outcome of FTP upload

time_t getNtpTime();
void digitalClockDisplay();
void printDigits(int digits);
void sendNTPpacket(IPAddress &address);
short doFTP(char* , char* , char* , char* , char* = "");

void setup() {
  Serial.begin(115200);
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, pass);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  //SPIFF setup
  SPIFFS.begin();
  Serial.print("IP number assigned by DHCP is ");
  Serial.println(WiFi.localIP());
  Serial.println("Starting UDP");
  Udp.begin(localPort);
  Serial.print("Local port: ");
  Serial.println(Udp.localPort());
  Serial.println("waiting for sync");
  setSyncProvider(getNtpTime);
  setSyncInterval(300);
}

time_t prevDisplay = 0; // when the digital clock was displayed

void loop()
{
  digitalWrite(trigger, LOW);
  delayMicroseconds(2);
  digitalWrite(trigger, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigger, LOW);
  dauer = pulseIn(echo, HIGH);
  entfernung = (dauer / 2) / 29.1;
  entfernung = 199 - entfernung;
  entfernung = entfernung * 84.7457;

  //Get the time from the NTP server
  setSyncProvider(getNtpTime);
  Serial.println("1) NTP GOTTEN");

    File f = SPIFFS.open(FTPfilename, "w");    // Öffnet die Datei, w überscheibt alles, a fügt Datensätze hinzu
    if (!f) {
      Serial.println("file open failed");
    }
    else {
      Serial.println("2) FILE OPENED");
      f.print("Messwert - ");
      f.print(entfernung);
      f.print(" Liter   -   ");            

      //This section puts the date and time into the data file
      if (hour() < 10) { 
        f.print("0");
        f.print(hour());
      }
      else {
        f.print(hour());
      }
      printDigits(minute(), f);
      printDigits(second(), f);
      f.print(" ");
      if (day() < 10) { 
        f.print("0");
        f.print(day());
      }
      else {
        f.print(day());
      }
      f.print("/");
      if (month() < 10) { 
        f.print("0");
        f.print(month());
      }
      else {
        f.print(month());
      }
      f.print("/");
      f.print(year());
      f.println();
      f.close();  
      Serial.println("3) FILE PRINTED AND CLOSED");
      //Attempt FTP upload
      FTPresult = doFTP(FTPhost, FTPusername, FTPpassword, FTPfilename, FTPfolder);
      //What is the outcome?
      Serial.println("A return code of 226 is success");
      Serial.print("Return code = ");
      Serial.println(FTPresult);
    }

  Serial.println("4) GOING TO SLEEP");
  delay(2000);
  ESP.deepSleep(sleepSeconds * 1000000, WAKE_RF_DEFAULT);
}

short doFTP(char* host, char* uname, char* pwd, char* fileName, char* folder)
{
  WiFiClient ftpclient;
  WiFiClient ftpdclient;

  const short FTPerrcode = 400; //error codes are > 400
  const byte Bufsize = 128;
  char outBuf[Bufsize];
  short FTPretcode = 0;
  const byte port = 21; //21 is the standard connection port

  File ftx = SPIFFS.open(fileName, "r"); //file to be transmitted
  if (!ftx) {
    Serial.println(F("file open failed"));
    return 900;
  }
  if (ftpclient.connect(host, port)) {
    Serial.println(F("Connected to FTP server"));
  }
  else {
    ftx.close();
    Serial.println(F("Failed to connect to FTP server"));
    return 910;
  }
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;

  /* User - Authentication username
     Send this command to begin the login process. username should be a
     valid username on the system, or "anonymous" to initiate an anonymous login.
  */
  ftpclient.print("USER ");
  ftpclient.println(uname);
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;

  /* PASS - Authentication password
     After sending the USER command, send this command to complete
     the login process. (Note, however, that an ACCT command may have to be
     used on some systems, not needed with synology diskstation)
  */
  ftpclient.print("PASS ");
  ftpclient.println(pwd);
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;

  //CWD - Change the working folder on the FTP server
  if (!(folder == "")) {
    ftpclient.print("CWD ");
    ftpclient.println(folder);
    FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
    if (FTPretcode >= 400) {
      return FTPretcode;
    }
  }

  /* SYST - Returns a word identifying the system, the word "Type:",
     and the default transfer type (as would be set by the
     TYPE command). For example: UNIX Type: L8 - this is what
     the diskstation returns
  */
  ftpclient.println("SYST");
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;

  /* TYPE - sets the transfer mode
     A - ASCII text
     E - EBCDIC text
     I - image (binary data)
     L - local format
     for A & E, second char is:
     N - Non-print (not destined for printing). This is the default if
     second-type-character is omitted
     Telnet format control (<CR>, <FF>, etc.)
     C - ASA Carriage Control
  */
  ftpclient.println("Type I");
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;

  /* PASV - Enter passive mode
     Tells the server to enter "passive mode". In passive mode, the server
     will wait for the client to establish a connection with it rather than
     attempting to connect to a client-specified port. The server will
     respond with the address of the port it is listening on, with a message like:
     227 Entering Passive Mode (a1,a2,a3,a4,p1,p2), e.g. from diskstation
     Entering Passive Mode (192,168,0,5,217,101)
  */
  ftpclient.println("PASV");
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) return FTPretcode;
  /* This is parsing the return from the server
     where a1.a2.a3.a4 is the IP address and p1*256+p2 is the port number.
  */
  char *tStr = strtok(outBuf, "(,"); //chop the output buffer into tokens based on the delimiters
  int array_pasv[6];
  for ( int i = 0; i < 6; i++) { //there are 6 elements in the address to decode
    tStr = strtok(NULL, "(,"); //1st time in loop 1st token, 2nd time 2nd token, etc.
    array_pasv[i] = atoi(tStr); //convert to int, why atoi - because it ignores any non-numeric chars
    //after the number
    if (tStr == NULL) {
      Serial.println(F("Bad PASV Answer"));
    }
  }
  //extract data port number
  unsigned int hiPort, loPort;
  hiPort = array_pasv[4] << 8; //bit shift left by 8
  loPort = array_pasv[5] & 255; //bitwise AND
  Serial.print(F("Data port: "));
  hiPort = hiPort | loPort; //bitwise OR
  Serial.println(hiPort);
  //first instance of dftp
  if (ftpdclient.connect(host, hiPort)) {
    Serial.println(F("Data port connected"));
  }
  else {
    Serial.println(F("Data connection failed"));
    ftpclient.stop();
    ftx.close();
  }

  /* STOR - Begin transmission of a file to the remote site. Must be preceded
     by either a PORT command or a PASV command so the server knows where
     to accept data from
  */
  ftpclient.print("STOR ");
  ftpclient.println(fileName);
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) {
    ftpdclient.stop();
    return FTPretcode;
  }
  Serial.println(F("Writing..."));

  byte clientBuf[64];
  int clientCount = 0;

  while (ftx.available()) {
    clientBuf[clientCount] = ftx.read();
    clientCount++;
    if (clientCount > 63) {
      ftpdclient.write((const uint8_t *)clientBuf, 64);
      clientCount = 0;
    }
  }
  if (clientCount > 0) ftpdclient.write((const uint8_t *)clientBuf, clientCount);
  ftpdclient.stop();
  Serial.println(F("Data disconnected"));
  FTPretcode = eRcv(ftpclient, outBuf, Bufsize);
  if (FTPretcode >= 400) {
    return FTPretcode;
  }

  //End the connection
  ftpclient.println("QUIT");
  ftpclient.stop();
  Serial.println(F("Disconnected from FTP server"));

  ftx.close();
  Serial.println(F("File closed"));
  return FTPretcode;
} // end function doFTP
/*------------------------------------------------------
   FUNCTION - eRcv
   Reads the response from an FTP server and stores the
   output in a buffer.Extracts the server return code from
   the buffer.

   Parameters passed:
     aclient - a wifi client connected to FTP server and
     delivering the server response
     outBuf - a buffer to store the server response on
     size - size of the buffer in bytes

   Return codes:
      These are the first three chars in the buffer and are
      defined in
      https://en.wikipedia.org/wiki/List_of_FTP_server_return_codes

   Dependencies:
     Libraries - <ESP8266WiFi.h> wifi library
     Functions - none
  --------------------------------------------------------*/
short eRcv(WiFiClient aclient, char outBuf[], int size)
{
  byte thisByte;
  char index;
  String respStr = "";
  while (!aclient.available()) delay(1);
  index = 0;
  while (aclient.available()) {
    thisByte = aclient.read();
    Serial.write(thisByte);
    if (index < (size - 2)) { //less 2 to leave room for null at end
      outBuf[index] = thisByte;
      index++;
    }
  } //note if return from server is > size it is truncated.
  outBuf[index] = 0; //putting a null because later strtok requires a null-delimited string
  //The first three bytes of outBuf contain the FTP server return code - convert to int.
  for (index = 0; index < 3; index++) {
    respStr += (char)outBuf[index];
  }
  return respStr.toInt();
} // end function eRcv

void digitalClockDisplay()
{
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(" ");
  Serial.print(day());
  Serial.print(".");
  Serial.print(month());
  Serial.print(".");
  Serial.print(year());
  Serial.println();
}

void printDigits(int digits, File f) {
  // utility for digital clock display: prints preceding colon and leading 0
  f.print(":");
  if (digits < 10)
    f.print('0');
  f.print(digits);
}

/*-------- NTP code ----------*/

time_t getNtpTime()
{
  IPAddress ntpServerIP; // NTP server's ip address

  while (Udp.parsePacket() > 0) ; // discard any previously received packets
  Serial.println("Transmit NTP Request");
  // get a random server from the pool
  WiFi.hostByName(ntpServerName, ntpServerIP);
  Serial.print(ntpServerName);
  Serial.print(": ");
  Serial.println(ntpServerIP);
  sendNTPpacket(ntpServerIP);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 1500) {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE) {
      Serial.println("Receive NTP Response");
      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
      unsigned long secsSince1900;
      // convert four bytes starting at location 40 to a long integer
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
    }
  }
  Serial.println("No NTP Response :-(");
  return 0; // return 0 if unable to get the time
}

// send an NTP request to the time server at the given address
void sendNTPpacket(IPAddress &address)
{
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12] = 49;
  packetBuffer[13] = 0x4E;
  packetBuffer[14] = 49;
  packetBuffer[15] = 52;
  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  Udp.beginPacket(address, 123); //NTP requests are to port 123
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Udp.endPacket();
}