#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif

#include <PubSubClient.h>
#include <DHT.h>

// Pin definitions
#define CAPTEUR_TEMPERATURE 15
#define CAPTEUR_NIVEAU 34
#define BTN_CONFORME 13
#define BTN_NONCONFORME 12
#define BTN_ALIM 5
#define BTN_PRESS 2
#define BTN_OPER 4


// Sensor tracking
int valTempRaw = 0;
int valNiveauRaw = 0;

// Button state tracking
int btn[5];
int btnPrev[5] = {HIGH,HIGH,HIGH,HIGH,HIGH}; // bouton relâché = HIGH

// WiFi and MQTT settings
const char* ssid = "Wokwi-GUEST";
const char* password = "";
const char* mqtt_server = "test.mosquitto.org"; // FlowFuse MQTT broker server

// MQTT client credentials
//const char* mqtt_client_id = "ESP32"; 
//const char* mqtt_username = "ESP32";
//const char* mqtt_password = "ESP3225";

// MQTT topic for water level and stop control
const char* mqtt_topic_temperature = "mes/temperature";
const char* mqtt_topic_niveau = "mes/niveau";
const char* mqtt_topic_prod_conforme = "mes/production/conforme";
const char* mqtt_topic_prod_nonconforme = "mes/production/nonconforme";
const char* mqtt_topic_arret_alim = "mes/arret/alimentation";
const char* mqtt_topic_arret_press = "mes/arret/pression";
const char* mqtt_topic_arret_oper = "mes/arret/operateur";

//MTBF and MTTR related
const char* mqtt_topic_reprise_alim = "mes/arret/reprise/alimentation";
const char* mqtt_topic_reprise_press = "mes/arret/reprise/pression";
const char* mqtt_topic_reprise_oper = "mes/arret/reprise/operateur";

WiFiClient espClient;

unsigned long previousMillis = 0;

// Function to connect to WiFi
void setup_wifi() {
    delay(10);
    Serial.println();
    Serial.print("Connecting to ");
    Serial.print(ssid);
    WiFi.begin(ssid, password);

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

    Serial.println("\nWiFi connected");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
}

// Callback function to handle messages from subscribed topics
void callback(char* topic, byte* payload, unsigned int length) {
    String msg;
    for (int i = 0; i < length; i++) {
        msg += (char)payload[i];
    }
    Serial.print("Message reçu sur ");
  Serial.print(topic);
  Serial.print(" : ");
  Serial.println(msg);

}
PubSubClient client(mqtt_server,1883,callback,espClient); 
// Function to connect to MQTT broker
void reconnect() {
    while (!client.connected()) {
        Serial.println("Attempting MQTT connection...");
        
        //if (client.connect(mqtt_client_id, mqtt_username, mqtt_password)) {
          if (client.connect("test")) {
            Serial.println("Connected to MQTT broker");
            //client.subscribe(mqtt_topic_led); // Subscribe to LED control topic
        } else {
            Serial.print("Failed, rc=");
            Serial.print(client.state());
            Serial.println(" trying again in 5 seconds");
            delay(5000);
        }
    }
}

void setup() {
    
    Serial.begin(115200);
    
  pinMode(BTN_CONFORME, INPUT);
  pinMode(BTN_NONCONFORME, INPUT);
  pinMode(BTN_ALIM, INPUT);
  pinMode(BTN_PRESS, INPUT);
  pinMode(BTN_OPER, INPUT);
   

    setup_wifi();
    client.setServer(mqtt_server, 1883);
    client.setCallback(callback);
}

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

    unsigned long currentMillis = millis();
  // Publishes new temperature and humidity every 10 seconds
  if (currentMillis - previousMillis > 10000) {
    previousMillis = currentMillis;

   
            // --- Read sensors with change detection ---
    int tempRaw = analogRead(CAPTEUR_TEMPERATURE);
    int niveauRaw = analogRead(CAPTEUR_NIVEAU);

    // Capteur température (0V=10°C ; 5V=100°C)
    float temperature = 10 + (tempRaw / 4095.0) * (100.0 - 10.0);

    // Capteur niveau (0V=0% ; 5V=100%)
    float niveauPct = (niveauRaw / 4095.0) * 100.0;

    if (abs(valTempRaw - tempRaw) > 10) {
        valTempRaw = tempRaw;
        client.publish(mqtt_topic_temperature, String(temperature).c_str());
        Serial.println((int)temperature + 10000); // Unique code for temperature
    }

    if (abs(valNiveauRaw - niveauRaw) > 10) {
        valNiveauRaw = niveauRaw;
        client.publish(mqtt_topic_niveau, String(niveauPct).c_str());
        Serial.println((int)niveauPct + 20000); // Unique code for level
    }
  

    // Read all buttons
     btn[0] = digitalRead(BTN_CONFORME);
    btn[1] = digitalRead(BTN_NONCONFORME);
    btn[2] = digitalRead(BTN_ALIM);
    btn[3] = digitalRead(BTN_PRESS);
    btn[4] = digitalRead(BTN_OPER);

   // Actions boutons + reprise
    for(int i=0;i<5;i++){
      // Détecter appui
      if(btn[i]==LOW && btnPrev[i]==HIGH){
        switch(i){
          case 0: client.publish(mqtt_topic_prod_conforme,"1"); Serial.println("Produit conforme"); break;
          case 1: client.publish(mqtt_topic_prod_nonconforme,"1"); Serial.println("Produit non conforme"); break;
          case 2: client.publish(mqtt_topic_arret_alim,"1"); Serial.println("Arret alimentation"); break;
          case 3: client.publish(mqtt_topic_arret_press,"1"); Serial.println("Arret pression"); break;
          case 4: client.publish(mqtt_topic_arret_oper,"1"); Serial.println("Arret operateur"); break;
        }
      }
      // Détecter relâchement (reprise)
      if(btn[i]==HIGH && btnPrev[i]==LOW){
        switch(i){
          case 2: client.publish(mqtt_topic_reprise_alim,"1"); Serial.println("Reprise alimentation"); break;
          case 3: client.publish(mqtt_topic_reprise_press,"1"); Serial.println("Reprise pression"); break;
          case 4: client.publish(mqtt_topic_reprise_oper,"1"); Serial.println("Reprise operateur"); break;
        }
      }
      btnPrev[i] = btn[i];
    }
    delay(1000);
}
}