//******************************************************************************
//
// Para este exemplo, precisamos instalar a biblioteca PubSubClient, criada por
// Nick O'Leary, pelo menu Sketch > Include Library > Manage Libraries...
//
// Mais informações sobre a biblioteca:
// https://github.com/knolleary/pubsubclient/
//
// Atenção para as limitações da biblioteca:
// https://github.com/knolleary/pubsubclient/#limitations
//
//******************************************************************************

//******************************************************************************
//
// Para este exemplo, precisamos instalar a biblioteca DHT sensor library,
// criada pela Adafruit, pelo menu Sketch > Include Library > Manage Libraries...
//
// Ao tentar instalar a bilbioteca DHT sensor library, o programa irá avisar que
// ela depende da biblioteca Adafruit Unified Sensor. Nesse momento, você deve
// escolher a opção "Install all" ou "Instalar todas".
//
// Outra opção é baixar e instalar as duas bibliotecas manualmente:
// https://github.com/adafruit/Adafruit_Sensor/archive/master.zip
// https://github.com/adafruit/DHT-sensor-library/archive/master.zip
//
//******************************************************************************
#include <Wire.h>              
#include <LiquidCrystal_I2C.h>  
#include <WiFi.h>

///########### configuração do wifi
#define ssid "Wokwi-GUEST"
#define password  ""

// https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/src/WiFiClient.h
#include <WiFiClient.h>

// https://www.hivemq.com/blog/mqtt-client-library-encyclopedia-arduino-pubsubclient/
// https://github.com/knolleary/pubsubclient
#include <PubSubClient.h>


//Cristal Liquido
LiquidCrystal_I2C lcd ( 0x27, 16, 2 );  

// MQTT Broker
const char* mqttBroker = "broker.hivemq.com";

// O client deve ser global
WiFiClient wiFiClient;
PubSubClient mqttClient(wiFiClient);
unsigned long tempoUltimaMensagem;

int LUM_PIN = 34; 
int LED_PIN = 25;
//Configuração para o buzzer
#define tempo 10
int frequencia = 0;
int BUZ_PIN = 33;
int pot;
bool skip = true;

bool conectarWiFi() {
  Serial.println("Tentando estabelecer uma conexao com a rede Wi-Fi...");
  const unsigned long tempoInicial = millis();
  WiFi.begin(ssid, password);
  
  do {
    
    if (WiFi.status() == WL_CONNECTED) {
      Serial.println("Conexao Wi-Fi estabelecida com sucesso!");
      
      IPAddress ip = WiFi.localIP();
      Serial.print("IP local: ");
      Serial.printf("%d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);  
      return true;
    }
    
    delay(1000);
    
  } while ((millis() - tempoInicial) < 30000L);
  
  Serial.println("Impossivel estabelecer uma conexao com a rede Wi-Fi!");
  
  return false;
}

bool verificarWiFi() {
  if (WiFi.status() == WL_CONNECTED)
    return true;
  
  Serial.println("Conexao Wi-Fi perdida.");
  WiFi.disconnect(true);
  delay(5000);
  
  return conectarWiFi();
}

bool conectarMQTT() {
  Serial.println("Tentando estabelecer uma conexao com o broker MQTT...");
  
  const unsigned long tempoInicial = millis();
  
  char clientId[32];
  sprintf(clientId, "inteli_%02X%02X%02X%02X%02X%02X%02X%02X",
    random(256), random(256), random(256), random(256),
    random(256), random(256), random(256), random(256));
  
  do {
    
    // Outras opções de conexão, como usuário e senha etc.:
    // https://github.com/knolleary/pubsubclient/blob/master/src/PubSubClient.h#L145
    if (mqttClient.connect(clientId)) {
      if (!mqttClient.subscribe("inteli/devices/#")) {
        Serial.println("Erro ao se inscrever em inteli/devices/#");
      }
      if (!mqttClient.subscribe("flavinhogp")) {
        Serial.println("Erro ao se inscrever em flavinhogp");
      }
      
      Serial.print("Conectado ao broker MQTT utilizando o client id ");
      Serial.print(clientId);
      Serial.println(", e inscrito no tópico inteli/devices/#");
      
      return true;
    }
    delay(1000);
    
    if (!verificarWiFi())
      break;
    
  } while ((millis() - tempoInicial) < 30000L);
  Serial.println("Impossivel estabelecer uma conexao com o broker MQTT!"); 
  return false;
}

bool verificarMQTT() {
  if (!verificarWiFi())
    return false;
  
  if (mqttClient.connected())
    return true;
  
  Serial.println("Conexao com o broker perdida.");
  
  mqttClient.disconnect();
  delay(5000);
  return conectarMQTT();
}

void mensagemRecebida(char* topic, byte* payload, unsigned int length) {
  String mensagem = "";
  Serial.print("Mensagem recebida! Topic: ");
  Serial.print(topic);
  Serial.print(" - Payload (");
  Serial.print(length);
  Serial.print(" bytes): ");
  // Imprime char por char por causa de algum possível \0 no meio do array,
  // além do fato de que o array payload não é garantido terminar com um \0...
  for (int i = 0; i < length; i++) {
    mensagem += (char)payload[i];
  }
  Serial.println(mensagem);

  if(strcmp(topic, "inteli/devices/led" ) == 0 ){
    if(mensagem == "liga") {
    Serial.println("LIGA");
    digitalWrite(LED_PIN, HIGH);
    }
    if(mensagem == "desliga") {
    Serial.println("DESLIGA");
    digitalWrite(LED_PIN, LOW);
    }
  } 
  
  //if(mensagem == "ligaLed") digitalWrite(LED_PIN, HIGH);
  //if(mensagem == "desligaLed") digitalWrite(LED_PIN, LOW);
  if(mensagem == "som") tocaSom();
  // Poderíamos tratar o topic e o payload aqui para executar
  // alguma ação mais interessante! :)
  Serial.println();

}

void setup() {
  Serial.begin(115200);
  //Display
  lcd.init ( ); 
  lcd.setCursor ( 0, 0 );

  //Sensores e atuadores
  pinMode(BUZ_PIN,OUTPUT); 
  pinMode(LED_PIN, OUTPUT);

  // Para evitar perder as primeiras mensagens do console
  Serial.println();
  Serial.flush();
  delay(1000);
  Serial.println();
  Serial.flush();
  delay(1000);
  
  Serial.println("Iniciando...");
  
  WiFi.mode(WIFI_STA);
  conectarWiFi();
  
  mqttClient.setBufferSize(256); // Em bytes (o valor padrão também é 256)
  mqttClient.setKeepAlive(60); // Em segundos
  mqttClient.setSocketTimeout(15); // Em segundos
  mqttClient.setCallback(mensagemRecebida);
  mqttClient.setServer(mqttBroker, 1883);
  tempoUltimaMensagem = millis();
  // Tentativa de aumentar a entropia do Arduino, para tentar deixar o
  // random() de duas placas diferentes um pouco mais "aleatório" e diferente
  // entre as placas... Só por causa da geração do client id aleatório.
  // Se o client id fosse conhecido/fixo/configurável pelo usuário, não
  // seria necessário... Mas também não faria mal deixar aí! ;)
  randomSeed(micros());
  conectarMQTT();
  Serial.println("Iniciando o envio...");
}

void tocaSom() {

  for (frequencia = 150; frequencia < 1800; frequencia += 1) 
  {
    tone(BUZ_PIN, frequencia, tempo); 
    delay(1);
  }
  for (frequencia = 1800; frequencia > 150; frequencia -= 1) 
  {
    tone(BUZ_PIN, frequencia, tempo); 
    delay(1);
  }

}

void loop() {

    
  if (!verificarMQTT())
    return;
  
  // mqttClient.loop() deveria ser executado sempre que possível. Por isso,
  // diferente dos exemplos IoTHttpXXX, aqui no final do loop() não estamos
  // utilizando um delay(), que atrasaria a execução de mqttClient.loop().
  // É dentro de mqttClient.loop() que é enviada a notificação de mensagem
  // recebida e afins...
  mqttClient.loop();
  
  // Ver comentário acima!
  //Serial.println();
  //Serial.println("Aguardando para repetir o processo...");
  //delay(5000);

   float luminosidade = analogRead(LUM_PIN);
   //float temperatura = analogRead(TEMP_PIN);
   char payload[16];
    
     

  const unsigned long agora = millis();
  if ((agora - tempoUltimaMensagem) >= 5000L) {
    tempoUltimaMensagem = agora;
    
    // Mais opções de envio:
    // https://github.com/knolleary/pubsubclient/blob/master/src/PubSubClient.h#L151
    lcd.clear();
    lcd.printf("ESP32 COM MQTT");
    lcd.setCursor ( 0, 1 );  
    lcd.printf("LUM: %.1f LUX",luminosidade);
    lcd.backlight ( );
    
    sprintf(payload, "%.2f", luminosidade);
    Serial.print("Enviando luminosidade...");
    Serial.println(payload);
    if (mqttClient.publish("inteli/devices/luminosidade", payload)) {
      Serial.println("Luminosidade enviada!");
    } else {
      Serial.println("Erro ao enviar a luminosidade!");
    }

    //sprintf(payload, "%.2f", temperatura);
    //Serial.print("Enviando temperatura...");
    //Serial.println(payload);
   // if (mqttClient.publish("inteli/sensor/temperatura", payload)) {
    //  Serial.println("Temperatura enviada!");
    //} else {
   //   Serial.println("Erro ao enviar a temperatura!");
   // }
      
    Serial.println();
    Serial.println("Aguardando para repetir o processo...");
    Serial.println();
  }
}