// Inclure les bibliothèques nécessaires
#include <DHT.h>
#include <Adafruit_NeoPixel.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <WiFiClientSecure.h>

// Définir les constantes et les broches
#define DHTPIN 27
#define DHTTYPE DHT22
#define POTPIN 35
#define LED_COUNT 1
#define LED_PIN_R 12
#define LED_PIN_G 13
#define LED_PIN_B 14
#define LDR_PIN 33
const int LED_PIN = 2;
const float GAMMA = 0.7;
const float RL10 = 50;
const char* ssid = "Wokwi-GUEST";
const char* password = "";

// Configuration pour HiveMQ Cloud
const char* mqtt_server_cloud = "prosper-dafq7h.a01.euc1.aws.hivemq.cloud";
const int mqtt_port_cloud = 8883;
const char* mqtt_user_cloud = "ProsperCluster";
const char* mqtt_password_cloud = "Jqb?5PCHeF7S4*Gr9m.$p"; 

// Configuration pour HiveMQ Local
const char* mqtt_server_local = "host.wokwi.internal";
const int mqtt_port_local = 1883;
const char* mqtt_user_local = "admin-user";
const char* mqtt_password_local = "admin-password";

const char* clientID = "ESP32Client";

// Initialiser les objets
DHT dht(DHTPIN, DHTTYPE);
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN_R, NEO_GRB + NEO_KHZ800);
WiFiClient wifiClient;
WiFiClientSecure espClient; 
PubSubClient client(wifiClient); 

// Déclarer les variables globales pour stocker les anciennes valeurs
float oldTemperature = 0.0;
float oldHumidity = 0.0;
float oldValeurControler = 0.0;
float oldLux = 0.0;

// Déclarer les variables globales
unsigned long previousMillis = 0;
const long interval = 1000;
bool climActif = false;
bool deshumidActif = false;
bool lumiereActif = false;
bool remote = false;
bool modeAuto = true;

//Methodes
void afficherMesures(float Temperature, float Humidite, float ValeurControler) {
  if (isnan(Humidite) || isnan(Temperature)) {
      Serial.println("Echec de lecture du capteur DHT");
      return;
    }
    Serial.print(F("Temperature : "));
    Serial.println(Temperature);
    Serial.print(F("Humidite : "));
    Serial.println(Humidite);
    Serial.print(F("ValeurVirtuel : "));
    Serial.println((ValeurControler));
}

void gererLEDs(float Temperature, float Humidite, float lux) {
    if (modeAuto) {
      // Contrôler la LED RGB en fonction de la température et de l'humidité
      digitalWrite(LED_PIN_R, (Temperature > 25 || Humidite > 60) ? HIGH : LOW);  
      digitalWrite(LED_PIN, (lux > 0.30)? LOW : HIGH);
      climActif = (Temperature > 25);
      deshumidActif = (Humidite > 60);
      lumiereActif = (lux <= 0.30);
        } else {
    // Contrôle manuel
    // Les appareils sont contrôlés manuellement par l'utilisateur
    // Ajouter ici la logique pour le contrôle manuel
    }
      // Contrôler la LED en fonction du LDR
      Serial.println(climActif ? "Climatiseur : Actif" : "Climatiseur : HS");
      Serial.println(deshumidActif ? "Deshumidificateur : Actif" : "Deshumidificateur : HS");
      Serial.println(lumiereActif ? "Lumiere : Actif" : "Lumiere : HS");
      Serial.print("Luminosite : ");
      Serial.print(lux);
      Serial.println(" lux");
}

void envoyerDonnees(float temperature, float humidity, float ValeurControler, float luminosite, bool climActif, bool deshumidActif, bool lumiereActif, bool modeAuto) 
{

  // Créer un message JSON pour les données
  String dataToSend = "\n{\"temperature\":" + String(temperature) + ",\n\"humidite\":" + String(humidity) + ",\n\"ValeurControler\":" + String(ValeurControler) + ",\n\"luminosite\":" + String(luminosite) + ",\n\"climActif\":" + String(climActif) + ",\n\"deshumidActif\":" + String(deshumidActif) + ",\n\"lumiereActif\":" + String(lumiereActif) + ",\n\"ButtonA\":" + String(modeAuto) + ",\n\"ButtonM\":" + String(!modeAuto) +"}";
  
  // Envoyer les données au topic MQTT avec QoS 1
  client.publish("iot/solution", dataToSend.c_str(), true);
  Serial.println("Données publiées avec succes\n");
}

bool checkMQTTServer() {
  WiFiClient tempClient;
  if (tempClient.connect(remote? mqtt_server_cloud : mqtt_server_local, remote? mqtt_port_cloud : mqtt_port_local)) {
    tempClient.stop();
    return true;
  } else {
    return false;
  }
}

void printErrorDetails(int rc) {
  switch (rc) {
    case MQTT_CONNECTION_TIMEOUT:
      Serial.println("Délai de connexion dépassé");
      break;
    case MQTT_CONNECTION_LOST:
      Serial.println("Connexion perdue");
      break;
    case MQTT_CONNECT_FAILED:
      Serial.println("Échec de la connexion");
      break;
    case MQTT_DISCONNECTED:
      Serial.println("Déconnecté");
      break;
    case MQTT_CONNECTED:
      Serial.println("Connecté");
      break;
    case MQTT_CONNECT_BAD_PROTOCOL:
      Serial.println("Protocole incorrect");
      break;
    case MQTT_CONNECT_BAD_CLIENT_ID:
      Serial.println("ID client incorrect");
      break;
    case MQTT_CONNECT_UNAVAILABLE:
      Serial.println("Serveur indisponible");
      break;
    case MQTT_CONNECT_BAD_CREDENTIALS:
      Serial.println("Identifiants incorrects");
      break;
    case MQTT_CONNECT_UNAUTHORIZED:
      Serial.println("Non autorisé");
      break;
    default:
      Serial.println("Erreur inconnue");
      break;
  }
  }

void reconnect() {
  while (!client.connected()) {
    Serial.print("Connexion au broker MQTT...\n");
    Serial.print("Serveur: ");
    Serial.println(remote ? mqtt_server_cloud : mqtt_server_local);
    Serial.print("Port: ");
    Serial.println(remote ? mqtt_port_cloud : mqtt_port_local);
    Serial.print("Utilisateur: ");
    Serial.println(remote ? mqtt_user_cloud : mqtt_user_local);

    if (client.connect(clientID, remote? mqtt_user_cloud : mqtt_user_local, remote? mqtt_password_cloud : mqtt_password_local)) {
      Serial.println(remote? "connection a votre Cloud reussi!" : "connection a votre broker local reussi!");
      // S'abonner au topic avec QoS 1
      client.subscribe("iot/solution");
    } else {
      Serial.print("échec, rc=");
      Serial.print(client.state());
      int rc = client.state();
      Serial.print(" : ");
      printErrorDetails(rc);
      Serial.println(" nouvelle tentative dans 5 secondes");
      delay(5000);
    }
  }
}

//Principale
void setup() {
  Serial.begin(115200);
  Serial.println("Solution IOT Part I!");
  WiFi.begin(ssid, password);
  dht.begin();
  strip.begin();
  strip.show(); // Initialisez toutes les LED avec la couleur 0 (éteintes)
  pinMode(LED_PIN_R, OUTPUT);
  pinMode(LED_PIN_G, OUTPUT);
  pinMode(LED_PIN_B, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  pinMode(LDR_PIN, INPUT);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connexion au WiFi...");
  }
  Serial.println("Connecté au WiFi");
  
  // Vérifier si le serveur MQTT est accessible
  if (checkMQTTServer()) {
    Serial.println("Serveur MQTT trouvé");
  } else {
    Serial.println("Serveur MQTT non trouvé");
    while (true);
  }
  // Configurer le client sécurisé avec le certificat racine
  client.setClient(wifiClient);
  client.setServer(mqtt_server_local, mqtt_port_local);
  // Connexion au broker MQTT
  reconnect();
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
    // Vérifier si le système est en mode automatique
  if (modeAuto) {
  // Mesurer les capteurs
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    float Humidite = dht.readHumidity();
    float Temperature = dht.readTemperature();
    int analogValue = analogRead(LDR_PIN);
    int PotentioValeur = analogRead(POTPIN);
    float voltage = analogValue / 4059. * 5;
    float resistance = 2000 * voltage / (1 - voltage / 5);
    float lux = (pow(RL10 * 1e3 * pow(10, GAMMA) / resistance, (1 / GAMMA)))/1000;
    float ValeurControler = map (PotentioValeur, 0, 4095, 20, 25);

    // Comparer les nouvelles valeurs avec les anciennes
    if (Humidite != oldHumidity || Temperature != oldTemperature || ValeurControler != oldValeurControler || lux != oldLux) {
      // Si une valeur a changé, mettre à jour les anciennes valeurs et publier les données
      oldHumidity = Humidite;
      oldTemperature = Temperature;
      oldValeurControler = ValeurControler;
      oldLux = lux;

    afficherMesures(Temperature, Humidite, ValeurControler);
    gererLEDs(Temperature, Humidite, lux);
    envoyerDonnees(Temperature, Humidite , ValeurControler, lux, climActif, deshumidActif, lumiereActif, modeAuto);
    }
  }
  }
  delay(10); //
}