#include <ESP32Servo.h>
#include <SPI.h>
#include <SD.h>
#include <ThreeWire.h>
#include <RtcDS1302.h>
#include <WiFi.h>
#include <PubSubClient.h>

File arquivo;
//-----------------------------------------------Internet e MQTT -----------------------------------------------
WiFiClient espClient; //Cria um objeto espClient que consegue conectar a um IP de internet especifico
PubSubClient client(espClient); // Cria um objeto "client" com o objeto espClient como parâmetro

const char* ssid = "Wokwi-GUEST";
const char* password = "";
const char* mqtt_server = "test.mosquitto.org";

#define POT 33 //Pino do potenciometro
//---------------------------------------------------SDCARD-----------------------------------------------------
const int IO = 27;    // DAT
const int SCLK = 14;  // CLK
const int CE = 26;    // RST
#define SD_CS 5     // Pino Chip Select do cartão microSD 
ThreeWire myWire(IO, SCLK, CE);
RtcDS1302<ThreeWire> Rtc(myWire);


//----------------------------------------------------LDR-------------------------------------------------------
#define LDR_Referencia 34 // Pino do LDR de referência
#define LDR_Horizontal 35 // Pino do LDR horizontal
#define LDR_Vertical 32 // Pino do LDR vertical

//----------------------------------------------------RTC-------------------------------------------------------
#define SDA 21 // Pino SDA do RTC
#define SCL 22 //Pino SCL do RTC
//---------------------------------------------------SERVO------------------------------------------------------
// Definindo os servos e suas variáveis de controle
Servo horizontal; // Define o objetivo para o servo horizontal
int servoH = 10; // Define o ponto de partida para o servo horizontal
int servoHLimitLow = 10; //Limite mínimo que o servo horizontal pode atingir
int servoHLimitHigh = 170; //Limite máximo que o servo horizontal pode atingir

Servo vertical; // Define o objeto para o servo vertical
int servoV = 90;
int servoVLimitLow = 45; //Limite mínimo que o servo vertical pode atingir
int servoVLimitHigh = 110; //Limite máximo que o servo vertical pode atingir

// ----------------------------------------Variáveis de controle de tempo-------------------------------
unsigned long tempoAnterior = 0;   // Armazena o tempo anterior
unsigned long intervaloAtivo = 300000;  // 5 minutos em milissegundos
unsigned long tempoExecucao = 30000;  // 30 segundos de execução ativa

void setup() {
  Serial.begin(115200); //Início da comunicação serial
  ConectarWifi();
  client.setServer(mqtt_server, 1883);

  //inicializarSD(); // Inicializa o cartão microSD
  //criarArquivo(); // Cria ou abre o arquivo no cartão SD
 
  //pinos dos servos
  horizontal.attach(15); 
  vertical.attach(4);

  pinMode(LDR_Referencia, INPUT);  // LDR de referência
  pinMode(LDR_Horizontal, INPUT);  // LDR horizontal
  pinMode(LDR_Vertical, INPUT);  // LDR vertical
  pinMode(POT, INPUT);

  // Inicializando os servos nas posições iniciais
  horizontal.write(servoH); 
  vertical.write(servoV); 
}

void loop() {
  conectarMQTT();
  publicarDados();
  
  /*RtcDateTime now = Rtc.GetDateTime();
  Serial.println();

  int horaAtual = now.Hour(); // Hora atual

  // Verifica se a hora está entre 07:00 e 18:00
  if (horaAtual >= 5 && horaAtual < 19) {
    unsigned long tempoAtual = millis();

    // Verifica se passaram 5 minutos desde a última execução
    if (tempoAtual - tempoAnterior >= intervaloAtivo) {
      tempoAnterior = tempoAtual;  // Atualiza o tempo anterior para o atual

      // Dentro do intervalo de 30 segundos de execução ativa
      unsigned long tempoExecucaoInicio = millis(); //retorna o tempo em milissegundos desde que o Arduino foi ligado
      while (millis() - tempoExecucaoInicio < tempoExecucao) {
        LDRServo();        // Ajusta os servos com base nos LDRs
        delay(500);  // Aguarda 1 segundo antes de repetir
      }
      // Após os 30 segundos, o valor da hora é gravado no SD 
      gravarValorLDR();
      
    }
  } else {
    delay(300000); // Aguarda 5 minutos antes de verificar novamente
  }*/
  LDRServo();
  delay(500);
}

void LDRServo(){
  int LDRRef = analogRead(LDR_Referencia);
  int LDRH = analogRead(LDR_Horizontal);
  int LDRV = analogRead(LDR_Vertical);
  Serial.println(LDRH);
  client.publish("TOPICO_LDR", String(LDRRef).c_str());

//Cálculo das diferenças de bits entre os LDR's
  int tol = 40;
  int dhor = LDRRef - LDRH;
  int dver = LDRRef - LDRV;

  // Ajuste do servo horizontal com base se o LDR de referência sofre menos intensidade luminosa e verifica se está na tolerância
    if (LDRH > LDRRef + tol) {
    servoH--; 
       if (servoH < servoHLimitLow) {
      servoH = servoHLimitLow;
    }
    horizontal.write(servoH);
   
  } else if (LDRH < LDRRef - tol) {
    servoH++; 
     if (servoH > servoHLimitHigh) {
      servoH = servoHLimitHigh;
    }
       horizontal.write(servoH);
  }
  
  client.publish("TOPICO_servoH", String(servoH).c_str());
  
    // Ajuste do servo vertical com base se o LDR de referência sofre mais intensidade luminosa e verifica se está na tolerância
    if (LDRV > LDRRef + tol) {
      servoV--; 
      if (servoV < servoVLimitLow) {
        servoV = servoVLimitLow;
      }
      
      vertical.write(servoV);
      //// Ajuste do servo vertical com base se o LDR de referência sofre menos intensidade luminosa
    } else if (LDRV < LDRRef - tol) {
      servoV++; 
      if (servoV > servoVLimitHigh) {
        servoV = servoVLimitHigh;
      }
      vertical.write(servoV);
    }

    client.publish("TOPICO_servoV", String(servoV).c_str());
}

void inicializarSD() {
  if (!SD.begin(SD_CS)) {
    Serial.println("Erro ao inicializar o cartão SD");
    return;
  }
  Serial.println("Cartão SD inicializado com sucesso!");
}

void criarArquivo() { // Função para criar ou abrir o arquivo no cartão SD
  
  arquivo = SD.open("/ldr_dados.txt", FILE_WRITE);
  
  if (arquivo) {
    arquivo.println("Leitura LDR");
    arquivo.close();
    Serial.println("Arquivo criado com sucesso!");
  } else {
    Serial.println("Erro ao abrir o arquivo");
  }
}

/*void gravarValorLDR() {  //Função para ler o valor do LDR e gravar no arquivo
  // Obtém a data e hora atual
  RtcDateTime now = Rtc.GetDateTime();
  
  int LDRRef = analogRead(LDR_Referencia);
  int LDRH = analogRead(LDR_Horizontal);
  int LDRV = analogRead(LDR_Vertical);

  char horasSD[9]; // Para armazenar a string formatada (HH:MM:SS)

  // Abre o arquivo no cartão SD para gravação
  arquivo = SD.open("/ldr_dados.txt", FILE_APPEND);  // Abre para adicionar no final do arquivo
  sprintf(horasSD, "%02d:%02d:%02d", now.Hour(),now.Minute(), now.Second());
  
  if (arquivo) {
    // Grava o valor do LDR no arquivo com a data e hora
    arquivo.print(now.Day());
    arquivo.print("/");
    arquivo.print(now.Month());
    arquivo.print("/");
    arquivo.print(now.Year());
    arquivo.print(" ");
    arquivo.print(horasSD);
    arquivo.print(" ");
    arquivo.print(LDRRef);
    arquivo.print(" ");
    arquivo.print(LDRH);
    arquivo.print(" ");
    arquivo.println(LDRV);

    arquivo.close();
    Serial.println("Dado gravado no cartão SD!");
  } else {
    Serial.println("Erro ao abrir o arquivo para gravar");
  }
}*/

void ConectarWifi(){
  WiFi.mode(WIFI_STA); //ele irá se conectar a uma rede Wi-Fi existente, atuando como cliente.
  WiFi.begin(ssid,password);
  while(!WiFi.status() == WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }
  Serial.print("Conectado ao WiFi!");
}

void conectarMQTT(){
  while (!client.connected()) { // Função que retorna se o cliente conectou - true ou false
    Serial.print("Tentando conectar ao MQTT...");
    if (client.connect("espClient")) { //Função para conectar o cliente
      Serial.println("Conectado");
    } else {
      Serial.print("Falha");
      Serial.print(client.state()); //função para retornar o estado do cliente
      Serial.println(" Tente denovo em 5 segundos");
      delay(5000);
    }
  }
}

void publicarDados(){
  int ValorPot = analogRead(POT);
  client.publish("TOPICO_WOKWIII", String(ValorPot).c_str());
  Serial.println(ValorPot);
  delay(500);
}