#include <WiFi.h>
#include "DHTesp.h"
/*
#include <FirebaseESP32.h>
#include "addons/TokenHelper.h"
#include "addons/RTDBHelper.h"



// variáveis Firebase //
FirebaseData dados;
FirebaseConfig config;
FirebaseAuth auth;

//# variáveis Firebase
const char* url = "https://gs-iot-5484a-default-rtdb.firebaseio.com/",
            * apiKey = "skr2p0cdKAyamUp4yABAHBGz088ccnaF3RX1p671";
            
            String basePath = "/Dados/"; // caminho de envio dos dados


unsigned long id;
*/

//# variáveis para uso do sensor de temperatura e umidade //
const byte dht_pin = 13; // pino do sensor

DHTesp dht;

float graus;
byte umidade;


//# variáveis para uso do sensor de fluxo //
const byte fluxo_pin = 25; // pino do sensor

unsigned short int fluxo;

//# variáveis para uso dos sensores infravermelho //
const byte infra_pin = 26;

bool infra;


//# sistema
unsigned int lastUpdate = millis();

//# Variáveis de regulagem
unsigned int regulagem_temperatura = 0, regulagem_fluxo = 0, regulagem_umidificar = 0;

#define climatizador 2
#define aquecedor 4
#define umidificador 16

//# Protótipos de função
void PegarDados(), EnviarDados(), Init(), RegularSistema();

void setup() {
  Init();
}

void loop()
{
  PegarDados();
  RegularSistema();
  delay(250);

  if (millis() - lastUpdate > 1000)
  {
    //EnviarDados();

    lastUpdate = millis();
  }
}


void Init()
{
  Serial.begin(9600);

  pinMode(fluxo_pin, INPUT);
  pinMode(infra_pin, INPUT_PULLDOWN);
  pinMode(climatizador, OUTPUT);
  pinMode(aquecedor, OUTPUT);
  pinMode(umidificador, OUTPUT);

  /*
  // # Conexão wifi //
  WiFi.disconnect();
  delay(1000);
  Serial.println("Conectando");
  WiFi.begin("Wokwi-GUEST", "", 6); //? Wokwi

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

  Serial.println("_—‾C͟o͟n͟e͟c͟t͟a͟d͟o‾—_");


  // # Conexão Firebase //
  config.database_url = url;
  config.api_key = apiKey;

  if (!Firebase.signUp(&config, &auth, "", ""))
  {
    Serial.println("Erro ao conectar ao Firebase");
    Serial.printf("%s\n", config.signer.signupError.message.c_str());

    Serial.println("Reiniciando ESP");
    delay(2000);
    ESP.restart();
  }

  config.token_status_callback = tokenStatusCallback;
  Firebase.begin(&config, &auth);
  Firebase.reconnectWiFi(true);
  Serial.println("_Conectado ao Firebase_");
  */

  //# Inicialização DHT
  dht.setup(dht_pin, DHTesp::DHT22);
}


void PegarDados()
{
  TempAndHumidity  dht_data = dht.getTempAndHumidity();

  graus = dht_data.temperature;
  Serial.println("Temperatura: "+String(graus));
  
  umidade = dht_data.humidity;
  Serial.println("Umidade: "+String(umidade));

  fluxo = map(analogRead(fluxo_pin), 0, 4095, 0, 6);
  Serial.println("Fluxo: "+String(fluxo));

  infra = digitalRead(infra_pin);
  Serial.println("Irradiação: "+String(infra));
}

/*
void EnviarDados()
{
  if (Firebase.ready())
  {
    //# Get current index
    if (Firebase.getInt(dados, "/indexAtual"))
    {
      id = 1 + dados.intData();

      Serial.println("Index: " + String(id));
    }
    else
    {
      Serial.println("Erro ao coletar index");
      Serial.println(dados.errorReason());

      id = 1;
    }

    //# Temperatura
    if (Firebase.setFloat(dados, basePath + String(id) + "/Temperatura", graus))
    {
      Serial.println("Temperatura enviada");
    }
    else
    {
      Serial.println("Erro ao enviar temperatura");
      Serial.println(dados.errorReason());
    }

    //# Umidade
    if (Firebase.setInt(dados, basePath + String(id) + "/Umidade", umidade))
    {
      Serial.println("Umidade enviado");
    }
    else
    {
      Serial.println("Erro ao enviar Umidade");
      Serial.println(dados.errorReason());
    }

    //# Fluxo
    if (Firebase.setInt(dados, basePath + String(id) + "/Fluxo", fluxo))
    {
      Serial.println("Fluxo enviada");
    }
    else
    {
      Serial.println("Erro ao enviar Fluxo");
      Serial.println(dados.errorReason());
    }

    //# Infravermelho
    if (Firebase.setInt(dados, basePath + String(id) + "/Infravermelho", infra))
    {
      Serial.println("Infravermelho enviada");
    }
    else
    {
      Serial.println("Erro ao enviar Infravermelho");
      Serial.println(dados.errorReason());
    }

    //# Atualizar index
    if (Firebase.setInt(dados, "/indexAtual", id))
    {
      Serial.println("Index atualizado");
    }
    else
    {
      Serial.println("Erro ao atualizar index");
      Serial.println(dados.errorReason());
    }
  }
}
*/

void RegularSistema()
{
  regulagem_temperatura = 0;
  regulagem_fluxo = 0;
  regulagem_umidificar = 0;

  // temperatura
  if (graus < 23.5)
  {
    regulagem_temperatura += map(constrain(graus, 16, 23.5), 23, 16 ,0, 255); // ligar aquecedor dada diferença de graus atual para ideal
  }
  else if (graus > 23.5)
  {
    regulagem_fluxo += map(constrain(graus, 23.5, 30), 23.5, 30 ,0, 255); // ligar climatizador dada diferença de graus atual para ideal
  }

  // umidade
  if (umidade < 45)
  {
    regulagem_umidificar += map(constrain(umidade, 0, 100), 0, 100 ,0, 255); // ligar climatizador dada diferença de umidade atual para ideal
  }
  else if (umidade > 45)
  {
    regulagem_fluxo += map(constrain(umidade, 0, 100), 0, 100 ,0, 255); // ligar Umidificador dada diferença de umidade atual para ideal
  }

  // fluxo
  if (fluxo < 1)
  {
    regulagem_fluxo += 255*0.05; // ligar Umidificador levemente caso não haja fluxo de ar
  }

  // infra
  if (infra == 1)
  {
    regulagem_fluxo = 255; // ligar climatizador caso houver irradiação infravermelha no ambiente a ponto de ser detectável
  }

  // Controle do ambiente
  if (regulagem_temperatura == 0 &&  regulagem_fluxo == 0 && regulagem_umidificar == 0)
  {
    digitalWrite(aquecedor, LOW);
    analogWrite(climatizador, LOW);
    digitalWrite(umidificador, LOW);
  }
  else
  {
    analogWrite(aquecedor, constrain(regulagem_temperatura, 0, 255));
    analogWrite(climatizador, constrain(regulagem_fluxo, 0, 255));
    analogWrite(umidificador, constrain(regulagem_umidificar, 0, 255));
  }
}


/* Obs.
Funcionalidades do firebase desativadas por consumirem muito do Wokwi, mas podem
utilizadas se descomentadas
*/