void loop{
	//calculate readings and create CAP MSG
    if (WiFi.status() != WL_CONNECTED)
    {
        //if not connected, try to connect to WiFi in each loop iteration
        bool connected = connect_to_wifi();
        if (connected){
            //send MSG to server
        }
        else{
            //buffer MSG
        }
    }
    else{
        //send MSG to server
    }
}

bool connect_to_wifi(){
    WiFi.begin(SSID,PW) //begin the wifi connection
    if (WiFi.status() == WL_CONNECTED)
    {
        return truue;
    }
    else{
        return false;
    }
}

queue<String> buffer_identifier;
queue<String> buffer_datetime;
queue<int> buffer_msg_ids;

//mean buffers
queue<double> buffer_t;
queue<double> buffer_h;
queue<double> buffer_p;
queue<double> buffer_l;

//sd buffers
queue<double> buffer_t_;
queue<double> buffer_h_;
queue<double> buffer_p_;
queue<double> buffer_l_;

void loop{
  //BUFFER LOGIC

  //loop buffer if buffer is not empty
  //	if connected
  //		POST buffer data and pop from buffer
  //	else break
    while (!buffer_msg_ids.empty()){
        if (WiFi.status() == WL_CONNECTED){
            //create CAP MSG from raw data in buffers
            if (sendPostRequest(xmlchar_buf, msg_id_buf)){
                popBuffers();
            }
        }
    }
    
    //MAIN LOGIC
    
	//calculate readings and create CAP MSG
    if (WiFi.status() != WL_CONNECTED)
    {
        bool connected = connect_to_wifi();
        if (connected){
            //send MSG to server
            if (!sendPostRequest(xmlchar, msg)){
                //buffer MSG
                pushToBuffers();
            }
        }
        else{
            //buffer MSG
            pushToBuffers();
        }
    }
    else{
        //send MSG to server
        if (!sendPostRequest(xmlchar, msg)){
            //buffer MSG
            pushToBuffers();
        }
    }
}

void pushToBuffers(){
    //push all the raw data needed for MSG to queues
}

void popBuffers(){
    //pop the front element from the queues
}

void beginOLED(){
    //initial setup and starting of OLED Display
}
void displayText(){
    //display the content in the OLED display
    //in various places, this function is called to print sensor and other information
}
void getTimeStamp(){
    //get the current time
}
void popBuffers(){
    //pop the front element from the queues
}
void pushToBuffers(){
    //push all the raw data needed for MSG to queues
}

void setup(){
    beginOLED();
    wait_and_connect_to_wifi();
  	begin_sensors();
    configTime();
}

void loop(){
    
  //BUFFER LOGIC

  //loop buffer if buffer is not empty
  //	if connected
  //		POST buffer data and pop from buffer
  //	else break
    while (!buffer_msg_ids.empty()){
        if (WiFi.status() == WL_CONNECTED){
            //generate CAP XML message from the data in buffers
            generateXMLStr();
            if (sendPostRequest(xmlchar_buf, msg_id_buf)){
                popBuffers();
            }
        }
    }
    
    //MAIN LOGIC
    
	//calculate readings and create CAP MSG
    int x = 0;
    int rounds = 15;
  	int round_time = 2000;
    while (x < rounds){
        readTemperature();
        readHumidity();
        readPressure();
        readLightIntensity();
            
        delay(round_time);
        x++;
    }
    temperature = calculate_mean(t_, rounds);
  	humidity = calculate_mean(h_, rounds);
  	pressure = calculate_mean(p_, rounds);
  	light = calculate_mean(l_, rounds);
    
    temperature_sd = calculate_sd(t_, rounds, temperature);
  	humidity_sd = calculate_sd(h_, rounds, humidity);
  	pressure_sd = calculate_sd(p_, rounds, pressure);
  	light_sd = calculate_sd(l_, rounds, light);
    
    getTimeStamp(datetime_);
    
    //send WARNING e-mail
    if ((temperature > 40) && (WiFi.status() == WL_CONNECTED)){
        //if a warning e-mail has not sent in last 5minutes
        //	send mail
    }
    
    //generate CAP XML message from the calculated data
    generateXMLStr();
    
    if (WiFi.status() != WL_CONNECTED)
    {
        bool connected = connect_to_wifi();
        if (connected){
            //send MSG to server
            if (!sendPostRequest(xmlchar, msg)){
                //buffer MSG
                pushToBuffers();
            }
        }
        else{
            //buffer MSG
            pushToBuffers();
        }
    }
    else{
        //send MSG to server
        if (!sendPostRequest(xmlchar, msg)){
            //buffer MSG
            pushToBuffers();
        }
    }
}

#include <Arduino.h>
#include <WiFi.h>
#include <queue>
using namespace std;
#include "xml.h"
#include "http.h"
#include "time.h"

#include "readings.h"
#include "wifi_con.h"
#include "config.h"
#include "utils.h"

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#include "mail_client.h"

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void beginOLED()
{
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
  { // Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ;
  }
  delay(2000);
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(20, 25);
  display.println("EMonitor");
  display.setTextSize(1);
  display.println("");
  display.println("GITHUB/ANJUCHAMANTHA");
  display.display();
  delay(5000);
  display.setCursor(0, 0);
}

String t0 = "";
String t1 = "";
String t2 = "";
String t3 = "";
String t4 = "";
String t5 = "";
String t6 = "";
String t7 = "";

void displayText()
{
  display.setCursor(0, 0);
  display.clearDisplay();
  display.println(t0);
  display.println(t1);
  display.println(t2);
  display.println(t3);
  display.println(t4);
  display.println(t5);
  display.println(t6);
  display.println(t7);
  display.display();
}

const char *ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 19800;
const int daylightOffset_sec = 0;

queue<String> buffer_identifier;
queue<String> buffer_datetime;
queue<int> buffer_msg_ids;

//mean buffers
queue<double> buffer_t;
queue<double> buffer_h;
queue<double> buffer_p;
queue<double> buffer_l;

//sd buffers
queue<double> buffer_t_;
queue<double> buffer_h_;
queue<double> buffer_p_;
queue<double> buffer_l_;

int msg = 0;
double temperature = 0;
double humidity = 0;
double pressure = 0;
double light = 0;
double temperature_sd = 0;
double humidity_sd = 0;
double pressure_sd = 0;
double light_sd = 0;

char xmlchar[1700];
String identifier;
char datetime_[32] = {};
String datetime;

void getTimeStamp(char *datetime_)
{
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo))
  {
    Serial.println("Failed to obtain time");
  }
  Serial.print("[TIME] ");
  // sprintf(times, &timeinfo, "%Y-%m-%dT%H:%M:%S%z");
  // Serial.println(&timeinfo, "%Y-%m-%dT%H:%M:%S%z");

  char timeString[32];
  time_t timeT = time(NULL);
  strftime(timeString, sizeof(timeString), "%Y-%m-%dT%H:%M:%S%z", localtime(&timeT));
  printf("%s\n", timeString);
  sprintf(datetime_, timeString);
  // datetime_ = timeString;
}

void popBuffers()
{
  buffer_msg_ids.pop();
  buffer_identifier.pop();
  buffer_datetime.pop();

  buffer_t.pop();
  buffer_h.pop();
  buffer_p.pop();
  buffer_l.pop();

  buffer_t_.pop();
  buffer_h_.pop();
  buffer_p_.pop();
  buffer_l_.pop();
}

void pushToBuffers()
{
  buffer_msg_ids.push(msg);
  buffer_identifier.push(identifier);
  buffer_datetime.push(datetime);

  buffer_t.push(temperature);
  buffer_h.push(humidity);
  buffer_p.push(pressure);
  buffer_l.push(light);

  buffer_t_.push(temperature_sd);
  buffer_h_.push(humidity_sd);
  buffer_p_.push(pressure_sd);
  buffer_l_.push(light_sd);
}

void setup()
{
  Serial.begin(115200);
  beginOLED();
  t7 = String("WIFI   : 0");
  t6 = String("SERVER : 0");
  displayText();
  wait_and_connect_to_wifi();
  t7 = String("WIFI   : 1");
  displayText();
  begin_sensors();
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
}

bool mailSent = false;
int mailTime = 10;

void loop()
{
  //BUFFER LOGIC

  //if buffer is not empty
  //    loop buffer
  //      if connected
  //        POST buffer data
  //      else break
  while (!buffer_msg_ids.empty())
  {
    Serial.println("[BUFFER] Processing Buffer... ");
    if (WiFi.status() == WL_CONNECTED)
    {
      t7 = String("WIFI   : 1");
      displayText();
      char xmlchar_buf[1700];

      int msg_id_buf = buffer_msg_ids.front();
      String identifier_buf = (String)buffer_identifier.front();
      String datetime_buf = (String)buffer_datetime.front();

      double t_buf = buffer_t.front();
      double h_buf = buffer_h.front();
      double p_buf = buffer_p.front();
      double l_buf = buffer_l.front();

      double t_sd_buf = buffer_t_.front();
      double h_sd_buf = buffer_h_.front();
      double p_sd_buf = buffer_p_.front();
      double l_sd_buf = buffer_l_.front();

      generateXMLStr(xmlchar_buf,
                     t_buf, h_buf, p_buf, l_buf,
                     t_sd_buf, h_sd_buf, p_sd_buf, l_sd_buf,
                     identifier_buf, datetime_buf);
      if (sendPostRequest(xmlchar_buf, msg_id_buf))
      {

        Serial.printf("[BUFFER] POST successful for : MSG %i\n\n", msg_id_buf);
        popBuffers();
        t6 = String("SERVER : 1 M-" + String(msg_id_buf) + " <B>");
        displayText();
      }
      else
      {
        t6 = String("SERVER : 0");
        displayText();
        Serial.printf("[BUFFER] POST Failed for : MSG %i\n\n", msg_id_buf);
        break;
      }
    }
    else
    {
      Serial.println("[WIFi] Not Connected !");
      t7 = String("WIFI   : 0");
      t6 = String("SERVER : 0");
      displayText();
      Serial.println("[BUFFER] Buffer Processing Skipped !\n\n");
      break;
    }
  }

  // MAIN LOGIC

  int x = 0;
  //Get 10 sensor values in 0.5s intervals
  //Calculate median & s.d for values in 10s intervals (10 readings x 1s)
  int rounds = 15;
  int round_time = 2000;

  //get values and keep in the arrays
  double t_[rounds];
  double h_[rounds];
  double p_[rounds];
  double l_[rounds];

  Serial.print("[SENSORS] Reading sensors > ");
  String temp = String("M-" + String(msg) + " ");
  while (x < rounds)
  {
    t_[x] = round(readTemperature() * 100) / 100.00;
    h_[x] = round(readHumidity() * 100) / 100.00;
    p_[x] = round(readPressure() * 100) / 100.00;
    l_[x] = round(readLightIntensity() * 100) / 100.00;
    Serial.print(".");
    temp = temp + "-";
    t5 = temp;
    displayText();
    delay(round_time);
    x++;
  }
  Serial.print("\n");

  temperature = calculate_mean(t_, rounds);
  humidity = calculate_mean(h_, rounds);
  pressure = calculate_mean(p_, rounds);
  light = calculate_mean(l_, rounds);

  temperature_sd = calculate_sd(t_, rounds, temperature);
  humidity_sd = calculate_sd(h_, rounds, humidity);
  pressure_sd = calculate_sd(p_, rounds, pressure);
  light_sd = calculate_sd(l_, rounds, light);

  Serial.printf("Temperature : %.2f +- %.2f %s \n", temperature, temperature_sd, "°C");
  Serial.printf("Humidity    : %.2f +- %.2f %s \n", humidity, humidity_sd, "%");
  Serial.printf("Pressure    : %.2f +- %.2f %s \n", pressure, pressure_sd, "Pa");
  Serial.printf("Light       : %.2f +- %.2f %s \n", light, light_sd, "%");
  Serial.print("\n");

  t0 = String("Temp     " + String(temperature) + "     C");
  t1 = String("Humidity " + String(humidity) + "     %");
  t2 = String("Pressure " + String(pressure) + " Pa");
  t3 = String("Light    " + String(light) + "     %");
  displayText();

  identifier = String(msg);
  getTimeStamp(datetime_);
  datetime = String(datetime_);

  if ((temperature > 40) && (WiFi.status() == WL_CONNECTED))
  {
    if (!mailSent || (mailTime < 1))
    {
      sendMail(temperature);
      mailSent = true;
      mailTime = 10;
    }
    mailTime--;
  }

  // Get the xml as a string to xmlchar variable
  generateXMLStr(xmlchar,
                 temperature, humidity, pressure, light,
                 temperature_sd, humidity_sd, pressure_sd, light_sd,
                 identifier, datetime);
  if (WiFi.status() != WL_CONNECTED)
  {
    t7 = String("WIFI   : 0");
    t6 = String("SERVER : 0");
    displayText();
    bool connected = connect_to_wifi();
    if (connected)
    {
      t7 = String("WIFI   : 1");
      displayText();
      if (!sendPostRequest(xmlchar, msg))
      {
        pushToBuffers();
        Serial.printf("[BUFFER] MSG %i Queued !\n\n", msg);
        t6 = String("SERVER : 0 M-" + String(msg) + " *");
        displayText();
      }
      t6 = String("SERVER : 1 M-" + String(msg));
      displayText();
    }
    else
    {
      pushToBuffers();
      Serial.printf("[BUFFER] MSG %i Queued !\n\n", msg);
      t7 = String("WIFI   : 0");
      t6 = String("SERVER : 0 M-" + String(msg) + " *");
      displayText();
    }
  }
  else
  {
    t7 = String("WIFI   : 1");
    displayText();
    if (!sendPostRequest(xmlchar, msg))
    {
      pushToBuffers();
      Serial.printf("[BUFFER] MSG %i Queued !\n\n", msg);
      t6 = String("SERVER : 0 M-" + String(msg) + " *");
      displayText();
    }
    else
    {
      t6 = String("SERVER : 1 M-" + String(msg));
      displayText();
    }
  }
  msg++;
}

const char *SSID = "WIFI SSID";
const char *PW = "WIFI PASSWORD";
const char *serverBase = "http://e-monitor.herokuapp.com/";

#ifndef SENSITIVE_CONFIG_H
#define SENSITIVE_CONFIG_H

extern const char *SSID;
extern const char *PW;
extern const char *serverBase;

#define emailSenderAccount "SENDER EMAIL ADDRESS"
#define emailSenderPassword "SENDER EMAIL ADDRESS PASSWORD"
#define emailRecipient "RECEIVER EMAIL ADDRESS"
#define smtpServer "smtp.gmail.com"
#define smtpServerPort 465
#define emailSubject "EMonitor Device Alert!"

#endif

#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "config.h"

bool sendPostRequest(char *xmlstr, int msg)
{
    if (WiFi.status() != WL_CONNECTED)
    {
        Serial.println("[WIFI] Connection lost !");
        Serial.println();
        return false;
    }

    // Send POST request
    HTTPClient http;
    String url = (String)serverBase + "/data";
    http.begin((String)url);

    Serial.printf("[HTTP] POST Request : MSG %i\n", msg);
    int responseCode = http.POST(xmlstr);
    http.end();

    // Connection failed error codes
    if (responseCode < 0)
    {
        String errorMessage = http.errorToString(responseCode).c_str();
        Serial.printf("[HTTP] Request failed: %s\n", errorMessage.c_str());
        return false;
    }

    // Server returned error code
    if (responseCode != HTTP_CODE_OK)
    {
        Serial.printf("[HTTP] %d \n", responseCode);
        return false;
    }

    // Success
    Serial.printf("[HTTP] %d : %s\n\n", responseCode, "OK");
    return true;
}

#ifndef HTTP_H
#define HTTP_H

bool sendPostRequest(char *xmlstr, int msg);

#endif

#include "ESP32_MailClient.h"
#include "config.h"

SMTPData smtpData;

// Callback function to get the Email sending status
void sendCallback(SendStatus info);

void sendMail(double temperature)
{
    Serial.println("\n----------------");
    Serial.println("[MAIL] Preparing to send email...");
    Serial.println();

    smtpData.setLogin(smtpServer, smtpServerPort, emailSenderAccount, emailSenderPassword);
    smtpData.setSender("EMonitor Device", emailSenderAccount);
    smtpData.setPriority("High");
    smtpData.setSubject(emailSubject);
    smtpData.setMessage("<div><h1 style=\"color:#ff9966;\"> EMonitor Device Alert !</h1><p>Temperature threshold exceeded !</p><h2 style=\"color:#cc3300;\"> Temperature = " + String(temperature) + " °C</h2><p><a href=\"" + String(serverBase) + "\">Visit EMonitor website</a></p></div>",
                        true);
    smtpData.addRecipient(emailRecipient);
    //smtpData.addRecipient("YOUR_OTHER_RECIPIENT_EMAIL_ADDRESS@EXAMPLE.com");
    smtpData.setSendCallback(sendCallback);

    if (!MailClient.sendMail(smtpData))
        Serial.println("[MAIL] Error sending Email, " + MailClient.smtpErrorReason());

    smtpData.empty();
}

// Callback function to get the Email sending status
void sendCallback(SendStatus msg)
{
    Serial.println("[MAIL]" + msg.info());
    if (msg.success())
    {
        Serial.println("----------------");
    }
}

#ifndef ALERT_MAIL_H
#define ALERT_MAIL_H

void sendMail(double temperature);

#endif

#include <Arduino.h>
#include "DHT.h"
#include <Wire.h>
#include <Adafruit_BMP085.h>

#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

Adafruit_BMP085 bmp;

// Potentiometer is connected to GPIO 34 (Analog ADC1_CH6)
const int ldrPin = A0;

void begin_sensors()
{
    dht.begin();
    if (!bmp.begin())
    {
        Serial.println("Could not find a valid BMP085 sensor, check wiring!");
        while (1)
        {
        }
    }
}
float readTemperature()
{
    float t = dht.readTemperature();
    // Check if any reads failed and exit early (to try again).
    if (isnan(t))
    {
        Serial.println(F("[DHT] Failed to read Temperature from DHT sensor!\n"));
        return 0;
    }
    return t;
}

float readHumidity()
{
    float h = dht.readHumidity();
    if (isnan(h))
    {
        Serial.println(F("[DHT] Failed to read Humidity from DHT sensor!\n"));
        return 0;
    }
    return h;
}

float readPressure()
{
    float p = bmp.readPressure();
    if (isnan(p))
    {
        Serial.println(F("[BMP] Failed to read Pressure from BMP sensor!\n"));
        return 0;
    }
    return p;
}

float readLightIntensity()
{
    float ldrVal = analogRead(ldrPin) * 100 / 3000;
    if (ldrVal > 100)
    {
        return 100.00;
    }
    return ldrVal;
}

#ifndef READINGS_H
#define READINGS_H

void begin_sensors();
float readTemperature();
float readHumidity();
float readPressure();
float readLightIntensity();

#endif

#include <Arduino.h>

double calculate_mean(double arr[], int len)
{
    double tot = 0;
    for (int i = 0; i < len; i++)
    {
        tot += arr[i];
    }
    return round((tot / len) * 100) / 100.00;
}

double calculate_sd(double arr[], int len, double mean)
{
    double variance = 0;
    for (int i = 0; i < len; i++)
    {
        variance += pow((arr[i] - mean), 2);
    }
    return round(sqrt(variance) * 100) / 100.00;
}

#ifndef UTILS_H
#define UTILS_H

double calculate_mean(double arr[], int len);
double calculate_sd(double arr[], int len, double mean);

#endif

#include <Arduino.h>
#include <WiFi.h>
#include "config.h"

void wait_and_connect_to_wifi()
{
    WiFi.begin(SSID, PW);
    Serial.println("");
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(1000);
        Serial.print("[WIFI] Trying to connect to : ");
        Serial.print(SSID);
        Serial.println("...");
    }

    Serial.print("[WIFI] Connected to : ");
    Serial.println(SSID);
    Serial.println("");
}

bool connect_to_wifi()
{
    WiFi.begin(SSID, PW);
    if (WiFi.status() == WL_CONNECTED)
    {
        Serial.print("[WIFI] Re-connected to : ");
        Serial.println(SSID);
        Serial.println();
        return true;
    }

    Serial.println("[WIFI] Not Connected to Wifi");
    return false;
}

#ifndef WIFI_CON_H
#define WIFI_CON_H

void wait_and_connect_to_wifi();
bool connect_to_wifi();

#endif

#include <Arduino.h>

void generateXMLStr(char *xmlchar,
                    double temperature, double humidity, double pressure, double light,
                    double temperature_sd, double humidity_sd, double pressure_sd, double light_sd,
                    String identifier, String timestamp)
{
    String temp = String(temperature);
    String hum = String(humidity);
    String pres = String(pressure);
    String lig = String(light);

    String temp_sd = String(temperature_sd);
    String hum_sd = String(humidity_sd);
    String pres_sd = String(pressure_sd);
    String lig_sd = String(light_sd);

    sprintf(
        xmlchar,
        "<?xml version = \"1.0\" encoding = \"utf8\"?>"
        "<alert>"
        "<identifier>%s</identifier>"
        "<sender> EMONITOR1</sender>"
        "<sent> %s</sent>"
        "<status> Actual</status>"
        "<msgType> Alert</msgType>"
        "<scope> Public</scope>"

        "<info>"
        "<category> Env</category>"
        "<event> Readings</event>"
        "<urgency> Past</urgency>"
        "<severity> Minor</severity>"
        "<certainty> Observed</certainty>"
        "<senderName> EMONITOR1 Device</senderName>"

        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"

        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"
        "<parameter><valueName>%s</valueName><value>%s</value></parameter>"

        "<area><areaDesc>Wadduwa,Sri Lanka</areaDesc></area>"
        "</info>"
        "</alert>",

        identifier.c_str(), timestamp.c_str(),
        "temperature", temp.c_str(),
        "humidity", hum.c_str(),
        "pressure", pres.c_str(),
        "lightIntensity", lig.c_str(),

        "temperature_sd", temp_sd.c_str(),
        "humidity_sd", hum_sd.c_str(),
        "pressure_sd", pres_sd.c_str(),
        "lightIntensity_sd", lig_sd.c_str()

    );
}

#ifndef XML_H
#define XML_H

void generateXMLStr(char *xmlchar,
                    double temperature, double humidity, double pressure, double light,
                    double temperature_sd, double humidity_sd, double pressure_sd, double light_sd,String identifier, String timestamp);

#endif