#include <WiFi.h>
#include <PubSubClient.h>
#include <math.h>
#include <FS.h>
#include "SPIFFS.h"

int trigpin1 = 13;
int echopin1 = 12;
int trigpin2 = 4;
int echopin2 = 5;
int buttonpin = 14;
int ledpin = 15;
int estado = 0;
bool anterior = HIGH;
char anterior_r = '0';
int contador = 0;

//ligação com adafruit.io----------------------------------------------------------------
#define IO_USERNAME  "Mayke"
#define IO_KEY       "aio_AFRH02ORPidYZyjUZ7eOZKHn4NzD"
const char* ssid = "Wokwi-GUEST";
const char* password ="";

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 callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Messagem recebida [");
  Serial.print(topic);
  Serial.print("] ");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
    //messageTemp += (char)payload[i]; <----------Usar quando tiver uma mensagem na resposta do bloco
  }
  Serial.println();

  if (contador > 0){
    if (anterior_r == (char)payload[0]) {
    } else{
      alterar_estado();
      anterior_r = (char)payload[0];
    }
  }
}

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("Mayke/feeds/serial", "Iniciando Comunicação");

      //... e subscribe.
      client.subscribe("Mayke/feeds/rbutton"); // <<<<----- mudar aqui
    } else {
      Serial.print("Falha, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5s");
      delay(5000);
    }
  }
}
//---------------------------------------------------------------------------------------

#define sound_speed 0.034
#define LIMITE_DISTANCIA 350
#define LIMITE_TEMPO 3000

float distanciaS1, distanciaS2;
unsigned long tempoIN = 0;
unsigned long tempoOUT = 0;
bool led_ativado = false;

void alterar_estado(){
  if (estado == 0){
    estado = 1;
  }else{
    estado = 0;
  }

  char s_led[8];
  dtostrf(estado,1,2,s_led);
  client.publish("Mayke/feeds/led", s_led);
}

// void salvarContador(int valor) {
//   File file = SPIFFS.open("/contador.txt", FILE_WRITE);
//   if (!file) {
//     Serial.println("Erro ao abrir o arquivo para gravação!");
//     return;
//   }
//   file.print(valor);  // Escreve o valor no arquivo
//   file.close();       // Fecha o arquivo
//   Serial.println("Contador salvo no SPIFFS.");
// }

// int lerContador() {
//   File file = SPIFFS.open("/contador.txt", FILE_READ);
//   if (!file) {
//     Serial.println("Arquivo não encontrado. Retornando valor padrão: 0.");
//     return 0;  // Retorna 0 se o arquivo não existir
//   }
//   String valor = file.readString(); // Lê o conteúdo do arquivo como string
//   file.close();                     // Fecha o arquivo
//   return valor.toInt();             // Converte a string para inteiro e retorna
// }

void setup() {
  Serial.begin(9200);

  // if (!SPIFFS.begin(true)) {
  //   Serial.println("Erro ao montar o SPIFFS!");
  //   return;
  // } else {
  //   Serial.println("SPIFFS montado com sucesso!");
  // }

// Restaurar valor do contador
  // contador = lerContador();
  // Serial.print("Número de pessoas restaurado: ");
  // Serial.println(contador);


  pinMode(trigpin1, OUTPUT);
  pinMode(echopin1, INPUT);
  pinMode(trigpin2, OUTPUT);
  pinMode(echopin2, INPUT);

  pinMode(buttonpin, INPUT_PULLUP);
  pinMode(ledpin, OUTPUT);

  digitalWrite(ledpin, LOW);

  setup_wifi();
  client.setServer(mqttserver, 1883); // Publicar
  client.setCallback(callback); // Receber mensagem
  client.publish("Mayke/feeds/led", "0");
}

long lerDistancia(int trig, int echo){ //função de leitura de sensor
  digitalWrite(trig, LOW);
  delayMicroseconds(2);
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  
  long duracao = pulseIn(echo, HIGH);

  long distancia = duracao * sound_speed / 2;

  return distancia;
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  long distanciaS1 = lerDistancia(trigpin1, echopin1);
  long distanciaS2 = lerDistancia(trigpin2, echopin2);

//bloco do botão--------------------------------------------------------------------
  bool press = digitalRead(buttonpin);

  if (press == LOW && anterior == HIGH){
    alterar_estado();
  }
  anterior = press;
  delay(100);
  //---------------------------------------------------------------------------------
  
//leitura dos sensores ------------------------------------------------------------
  if (distanciaS1 <= LIMITE_DISTANCIA && tempoIN == 0) { //detectar movimentação no sensor interno
    tempoIN = millis();
    Serial.print("tempo em que sensor 1 foi ativado: ");
    Serial.println(tempoIN);
    client.publish("Mayke/feeds/serial", "Sensor interno ativado!");

  }
  
  if (distanciaS2 <= LIMITE_DISTANCIA && tempoOUT == 0) { //detectar movimentação no sensor externo
    tempoOUT = millis();
    Serial.print("tempo em que sensor 2 foi ativado: ");
    Serial.println(tempoOUT);
    client.publish("Mayke/feeds/serial", "Sensor externo ativado!");
  }
  //--------------------------------------------------------------------------------

//computagem de movimentação -----------------------------------------------------
  if ((tempoIN > 0 && tempoOUT > 0) && (tempoIN != tempoOUT)){ //verificar movimentação
    if (tempoOUT < tempoIN){ //verificar entrada na sala
      Serial.println("Movimentação detectada!");
      Serial.println("Alguém entrou na sala.");
      contador++;
      client.publish("Mayke/feeds/serial", "Alguém entrou na sala.");
    }else if (tempoIN < tempoOUT){ //verificar saída da sala
      if (contador > 0){
      Serial.println("Movimentação detectada!");
      Serial.println("Alguém saiu da sala.");
      contador--;
      client.publish("Mayke/feeds/serial", "Alguém saiu da sala.");
      }
    }
  
  // salvarContador(contador);
    
//zerar sensores após movimentação
    tempoOUT = 0;
    tempoIN = 0;
    Serial.print("Pessoas na sala: ");
    Serial.println(contador);
    char s_cont[8];
    dtostrf(contador,1,2,s_cont);
    client.publish("Mayke/feeds/serial", "Pessoas na sala: ");
    client.publish("Mayke/feeds/serial", s_cont);
    client.publish("Mayke/feeds/contador", s_cont);
    delay(1000);
  }
  //---------------------------------------------------------------------------------

//resetar sensores se não houver movimentação
  unsigned long momento = millis();//momento atual
  if (tempoIN > 0 && (momento - tempoIN)>LIMITE_TEMPO){
    tempoIN = 0; //resetar tempo do sensor interno depois de 3 segundos ativado sem movimentação
    Serial.println("Sensor 1 resetado por 'tempo de movimentação excedido'.");
    client.publish("Mayke/feeds/serial", "Sensor interno resetado por 'tempo de movimentação excedido'.");
  }
  if (tempoOUT > 0 && (momento - tempoOUT)>LIMITE_TEMPO){
    tempoOUT = 0;  //resetar tempo do sensor externo depois de 3 segundos ativado sem movimentação
    Serial.println("Sensor 2 resetado por 'tempo de movimentação excedido'.");
    client.publish("Mayke/feeds/serial", "Sensor externo resetado por 'tempo de movimentação excedido'.");
  }

//  ligar/desligar iluminação
  if (estado == 1){
    digitalWrite(ledpin, HIGH);
  }else{
    digitalWrite(ledpin, LOW);
  }

//desligar iluminação automaticamente com a sala vazia
  if (estado == 1 && contador == 0){
    client.publish("Mayke/feeds/serial", "Todas as pessoas saíram da sala, desligando iluminação em 1 segundo ....");
    delay (1000);
    digitalWrite(ledpin, LOW);
    alterar_estado();
    client.publish("Mayke/feeds/serial", "Iluminação desligada.");
  }

  delay(1000);
}