//---------------------------------------------DHT-----------------------------------------
#include "DHT.h"
#define DHTPIN 32 //não usar 35 ou 34
#define DHTTYPE DHT22 
DHT dht(DHTPIN, DHTTYPE); 

#define dhtinterval 60000
unsigned long previousMillis = 0;

  float h;
  float t;
  float f;

void dhtcheck(){
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);

  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  float hif = dht.computeHeatIndex(f, h);
  float hic = dht.computeHeatIndex(t, h, false);

  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= dhtinterval){
    Serial.print(F("Humidity: "));
    Serial.print(h);
    Serial.print(F("%  Temperature: "));
    Serial.print(t);
    Serial.println(F("°C "));
    
    previousMillis = currentMillis;
  }
}  

//---------------------------------------SPIFFS------------------------------------------
#include <FS.h>
#include "SPIFFS.h"
#include <time.h>

const char* ntpServer = "a.st1.ntp.br";
const long gmt = -10800;
const int horarioverao = 3600;
String s;

String gettime(){
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)){
    Serial.println("falha obter tempo");
  } 
  char buffer[20];
  strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S",&timeinfo);
  return String(buffer);
}

void writeFile(String state, String path) {  //escreve conteúdo em um arquivo
  File rFile = SPIFFS.open(path, "a");       //a para anexar
  if (!rFile) {
    Serial.println("Erro ao abrir arquivo!");
  } else {
    Serial.print("tamanho");
    Serial.println(rFile.size());
    rFile.println(state);
    Serial.print("Gravou: ");
    Serial.println(state);
  }
  rFile.close();
}

String readFile(String path) {
  Serial.println("Read file");
  File rFile = SPIFFS.open(path, "r");  //r+ leitura e escrita
  if (!rFile) {
    Serial.println("Erro ao abrir arquivo!");
  } else {
    Serial.print("----------Lendo arquivo ");
    Serial.print(path);
    Serial.println("  ---------");
    while (rFile.position() < rFile.size()) {
      s = rFile.readStringUntil('\n');
      s.trim();
      Serial.println(s);
    }
    rFile.close();
    return s;
  }
}

void formatFile() {
  Serial.println("Formantando SPIFFS");
  SPIFFS.format();
  Serial.println("Formatou SPIFFS");
}

void openFS(void) {
  if (!SPIFFS.begin()) {
    Serial.println("\nErro ao abrir o sistema de arquivos");
  } else {
    Serial.println("\nSistema de arquivos aberto com sucesso!");
  }
}

//-------------------------------------MQTT-----------------------------------------------
#include<WiFi.h>
#include <PubSubClient.h>

#define IO_USERNAME  "J0110G" //<----------Mudar para o seu
#define IO_KEY       "aio_zOCH24vX5YtgRTMoeClNZ5YSihpD" //<----------Mudar para o seu
const char* ssid = "NPITI-IoT";
const char* password ="NPITI-IoT";

const char* mqttserver = "io.adafruit.com";
const int mqttport = 1883;
const char* mqttUser = IO_USERNAME;
const char* mqttPassword = IO_KEY;

WiFiClient espClient;
PubSubClient client(espClient);
unsigned long lastMsg = 0;
#define MSG_BUFFER_SIZE	(50)
char msg[MSG_BUFFER_SIZE];
int value = 0;

void setup_wifi() {

  delay(10);
 
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  randomSeed(micros());

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Tentando conexão MQTT...");
    // Create a random client ID
    String clientId = "ESP32 - Sensores";
    clientId += String(random(0xffff), HEX);
    // Se conectado
    if (client.connect(clientId.c_str(), mqttUser, mqttPassword)) {
      Serial.println("conectado");
      // Depois de conectado, publique um anúncio ...
      // client.publish("J0110G/feeds/pessoas-na-sala", "Iniciando Comunicação");
      // client.publish("J0110G/feeds/temperatura-da-sala", "Iniciando Comunicação");
      // client.publish("J0110G/feeds/umidade-da-sala", "Iniciando Comunicação");

    } else {
      Serial.print("Falha, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5s");
      delay(5000);
    }
  }
}

//----------------------------------DISTÂNCIA-----------------------------------------

#define pino_trigger1 27
#define pino_echo1 26
#define pino_trigger2 25
#define pino_echo2 33

#define soundSpeed 0.034
#define distanciaMinima 10
// Definição das variáveis

bool sensor1Ativo = false;
bool sensor2Ativo = false;

unsigned long tempoSensor1;
unsigned long tempoSensor2;

long  duracaoPulso1;
float distanciaCm1;

long  duracaoPulso2;
float distanciaCm2;

int contadorPessoas = 0;
int y=0;

void entrou(){
  contadorPessoas++;
  Serial.print("ENTROU - Pessoas na sala: ");
  Serial.println(contadorPessoas);
  String log = " Temperatura: " + String(dht.readTemperature()) + "°C" + "  Umidade: " + String(dht.readHumidity()) + "%" + " - ENTROU, Pessoas na sala: " + String(contadorPessoas);
  writeFile(log, "/log.txt");

}

void saiu(){
  if (contadorPessoas > 0){
    contadorPessoas--;
    Serial.print("SAIU - Pessoas na sala: ");
    Serial.println(contadorPessoas);
    String log = " Temperatura: " + String(dht.readTemperature()) + "°C" + "  Umidade: " + String(dht.readHumidity()) + "%" + " - SAIU, Pessoas na sala: " + String(contadorPessoas);  
    writeFile(log, "/log.txt");
  }else{
    Serial.println("Não há ninguem na Sala");
  }
}

//-------------------------------------------------------------------------------------

void setup() {
  //formatFile();
  Serial.begin(115200);
  pinMode(pino_trigger1, OUTPUT);
  pinMode(pino_echo1, INPUT);
  pinMode(pino_trigger2, OUTPUT);
  pinMode(pino_echo2, INPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  dht.begin();
  
  setup_wifi();
  client.setServer(mqttserver, 1883);

  Serial.println("abrir arquivo");
  openFS();
  Serial.println("ler arquivo");
  String test = readFile("/log.txt");
  char ultimo = test[test.length() - 1];
  contadorPessoas = ultimo - '0';
}

void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  //delay(10000);

  unsigned long now = millis();
  if (now - lastMsg > 7000) {
    lastMsg = now;
  char s_pessoas[8];
  char s_t[8];
  char s_h[8];

  dtostrf(contadorPessoas,1,2,s_pessoas);
  client.publish("J0110G/feeds/pessoas-na-sala", s_pessoas);
  dtostrf(dht.readTemperature(),1,2,s_t);
  client.publish("J0110G/feeds/temperatura-da-sala", s_t);
  dtostrf(dht.readHumidity(),1,2,s_h);
  client.publish("J0110G/feeds/umidade-da-sala", s_h);
  }

  dhtcheck();

  digitalWrite(pino_trigger1, LOW);
  delayMicroseconds (2);
  digitalWrite(pino_trigger1, HIGH);
  delayMicroseconds(10);
  digitalWrite(pino_trigger1, LOW);
  duracaoPulso1 = pulseIn(pino_echo1, HIGH); //Captura a duração do pulso
  distanciaCm1 = duracaoPulso1 * soundSpeed / 2; // Cálculo da Distância
  
  if(distanciaCm1 < distanciaMinima && distanciaCm2 > distanciaMinima && y==0){
    sensor1Ativo = true;
    tempoSensor1 = millis();
  }

  digitalWrite(pino_trigger2, LOW);
  delayMicroseconds (2);
  digitalWrite(pino_trigger2, HIGH);
  delayMicroseconds(10);
  digitalWrite(pino_trigger2, LOW);
  duracaoPulso2 = pulseIn(pino_echo2, HIGH); //Captura a duração do pulso
  distanciaCm2 = duracaoPulso2 * soundSpeed / 2; // Cálculo da Distância
 
   if(distanciaCm1 > distanciaMinima && distanciaCm2 < distanciaMinima && y==0){
    sensor2Ativo = true;
    tempoSensor2 = millis();
  }

  if(sensor1Ativo && sensor2Ativo && y==0){
    if(tempoSensor1 < tempoSensor2){
      entrou();
      digitalWrite(13, HIGH);
      delay(1000);
      digitalWrite(13, LOW);
    }else{
      saiu();
      digitalWrite(12, HIGH);
      delay(1000);
      digitalWrite(12, LOW);
    }
    sensor1Ativo = false;
    sensor2Ativo = false;
    y=1;
  }if (distanciaCm1 >= distanciaMinima && distanciaCm2 >= distanciaMinima ){
    y=0;
  }
  
}