"""from machine import Pin, ADC, I2C, PWM
import ssd1306  # Bibliothèque pour l'écran OLED
import time
import random  # Pour générer des valeurs aléatoires pour le capteur de gaz

# Initialisation des composants
capteur_gaz = ADC(Pin(34))  # Capteur de fumée/gaz MQ-2 (simulation)
capteur_gaz.atten(ADC.ATTN_11DB)  # Pour capturer toute l'échelle (0-3.3V)
buzzer = Pin(2, Pin.OUT)  # Buzzer connecté à la pin GPIO2
led = Pin(4, Pin.OUT)  # LED connectée à la pin GPIO4
bouton = Pin(5, Pin.IN, Pin.PULL_UP)  # Bouton poussoir connecté à GPIO5
moteur = PWM(Pin(15))  # Moteur simulé connecté à GPIO15
moteur.freq(1000)  # Fréquence PWM pour contrôler le moteur

# Initialisation de l'écran OLED SSD1306 (I2C)
i2c = I2C(0, scl=Pin(22), sda=Pin(21))  # Bus I2C pour l'écran OLED
oled = ssd1306.SSD1306_I2C(128, 64, i2c)  # Initialisation de l'écran OLED (128x64)

# Seuil de détection pour les niveaux de gaz/fumée
seuil_danger = 1500  # Seuil au-delà duquel une alerte sera activée

# Fonction pour afficher les informations sur l'écran OLED
def afficher_niveau(niveau):
    oled.fill(0)  # Effacer l'écran
    oled.text("Detecteur de Gaz", 0, 0)
    oled.text("Niveau Gaz/Fumee:", 0, 20)
    oled.text(str(niveau), 0, 40)
    if niveau >= seuil_danger:
        oled.text("!!! ALERTE !!!", 0, 55)  # Affichage d'une alerte si le niveau est dangereux
    oled.show()

# Fonction pour démarrer le moteur
def demarrer_moteur():
    oled.fill(0)
    oled.text("Moteur actif", 0, 20)
    oled.text("Transformation", 0, 40)
    oled.text("Gaz -> Energie", 0, 55)
    oled.show()
    moteur.duty(512)  # Puissance moyenne pour le moteur (ajuster si nécessaire)
    print("Moteur démarré")

# Fonction pour arrêter le moteur
def arreter_moteur():
    moteur.duty(0)  # Arrêter le moteur
    print("Moteur arrêté")

# Boucle principale
while True:
    # Simuler une lecture de gaz avec une valeur aléatoire entre 0 et 3000
    niveau = random.randint(0, 3000)  # Générer un nombre aléatoire entre 0 et 3000
    afficher_niveau(niveau)  # Affichage sur l'écran OLED

    # Vérifier si le niveau détecté est supérieur ou égal au seuil danger
    if niveau >= seuil_danger:
        led.on()  # Allumer la LED pour indiquer un danger
        buzzer.on()  # Activer le buzzer pour alerter l'utilisateur

        print("ALERTE ! Niveau de gaz élevé. En attente de confirmation...")
        debut_alerte = time.time()  # Enregistrer le temps de début de l'alerte

        # Attendre que le bouton soit pressé ou que le délai expire
        while time.time() - debut_alerte < 10:  # Délai de 10 secondes
            if bouton.value() == 0:  # Bouton pressé
                print("Alerte confirmée par l'utilisateur.")
                led.off()
                buzzer.off()
                break
            time.sleep(0.1)  # Petit délai pour éviter une boucle trop rapide

        else:  # Si le délai expire sans intervention
            print("Pas d'intervention. Démarrage du moteur.")
            demarrer_moteur()
            led.off()
            time.sleep(5)  # Laisser le moteur fonctionner pendant 5 secondes
            arreter_moteur()

    else:
        led.off()  # Éteindre la LED
        buzzer.off()  # Désactiver le buzzer

    time.sleep(2)  # Pause entre chaque mesure (2 seconde)
"""

from machine import Pin, ADC, I2C, PWM, unique_id
import ssd1306
import time
import random
import network
import ujson
from umqtt.simple import MQTTClient

# ======================================================
# CONFIGURATION (TOKEN MIS À JOUR)
# ======================================================
WIFI_SSID = "Wokwi-GUEST"
WIFI_PASSWORD = ""

# Serveur ThingsBoard Cloud (Europe)
THINGSBOARD_HOST = "mqtt.eu.thingsboard.cloud"
THINGSBOARD_TOKEN = "K5SouMhmsnDyJuzGhzll" 

# ======================================================
# INITIALISATION DES COMPOSANTS
# ======================================================
# Capteur de Gaz (ADC 34)
capteur_gaz = ADC(Pin(34))
capteur_gaz.atten(ADC.ATTN_11DB) # Lecture de 0 à 3.3V

# Sorties : Buzzer (2), LED (4)
buzzer = Pin(2, Pin.OUT)
led = Pin(4, Pin.OUT)
# Entrée : Bouton (5) avec résistance interne
bouton = Pin(5, Pin.IN, Pin.PULL_UP)

# Moteur : Ventilateur (PWM sur Pin 15)
moteur = PWM(Pin(15))
moteur.freq(1000)
moteur.duty(0)

# Écran OLED I2C (SCL=22, SDA=21)
try:
    i2c = I2C(0, scl=Pin(22), sda=Pin(21))
    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
except Exception as e:
    print(" Écran OLED non détecté :", e)

# Paramètre
SEUIL_DANGER = 1500

# ======================================================
# ✅ FONCTIONS DE RÉSEAU
# ======================================================
def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print("Connexion au WiFi Wokwi...")
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        while not wlan.isconnected():
            time.sleep(0.5)
            print(".", end="")
    print("\n WiFi Connecté. IP :", wlan.ifconfig()[0])

def connect_mqtt():
    # Génération d'un ID client unique
    client_id = "ESP32_GAS_" + str(random.getrandbits(24))
    # User = Token, Password = vide
    client = MQTTClient(client_id, THINGSBOARD_HOST, user=THINGSBOARD_TOKEN, password="")
    try:
        print("Liaison avec ThingsBoard...")
        client.connect()
        print(" MQTT Connecté avec succès !")
        return client
    except Exception as e:
        print(" Erreur MQTT :", e)
        return None

# ======================================================
# ✅ LOGIQUE D'AFFICHAGE ET ENVOI
# ======================================================
def rafraichir_ecran(valeur, etat):
    try:
        oled.fill(0)
        oled.text("SYSTEME GAZ", 20, 0)
        oled.text("-" * 16, 0, 10)
        oled.text("Niveau: {}".format(valeur), 0, 30)
        oled.text("Etat: {}".format(etat), 0, 50)
        oled.show()
    except:
        pass

def envoyer_donnees(client, niveau, danger):
    try:
        payload = ujson.dumps({"niveau_gaz": niveau, "danger": danger})
        client.publish("v1/devices/me/telemetry", payload)
        print(" Télémétrie envoyée :", payload)
        return True
    except:
        return False

# ======================================================
# ✅ BOUCLE PRINCIPALE (MAIN)
# ======================================================
connect_wifi()
mqtt = connect_mqtt()

print("\n--- Démarrage du monitoring ---\n")

while True:
    try:
        # 1. Lecture du niveau de gaz
        # Note : On utilise random pour la simulation Wokwi, décommentez capteur_gaz.read() pour le réel
        niveau = random.randint(300, 2800) 
        # niveau = capteur_gaz.read() # <--- Capteur réel
        
        danger = 1 if niveau >= SEUIL_DANGER else 0
        
        # 2. Reconnexion automatique MQTT
        if mqtt is None:
            mqtt = connect_mqtt()
        
        # 3. Envoi à ThingsBoard
        if mqtt:
            if not envoyer_donnees(mqtt, niveau, danger):
                mqtt = None # Marquer pour reconnexion

        # 4. Gestion des alertes
        if danger:
            print(" ALERTE : Gaz détecté !")
            rafraichir_ecran(niveau, "DANGER !!")
            led.on()
            buzzer.on()
            
            # Attente de 10 secondes pour une action humaine (Bouton)
            bouton_presse = False
            start = time.time()
            while time.time() - start < 10:
                if bouton.value() == 0: # Bouton pressé (Pull-up)
                    bouton_presse = True
                    print(" Alerte arrêtée par l'utilisateur.")
                    break
                time.sleep(0.1)
            
            # Si personne n'a appuyé -> On active le moteur (extraction)
            if not bouton_presse:
                print(" Activation automatique du moteur...")
                rafraichir_ecran(niveau, "MOTEUR ON")
                moteur.duty(1023) # Vitesse max
                time.sleep(5)
                moteur.duty(0)
            
            led.off()
            buzzer.off()
        else:
            rafraichir_ecran(niveau, "NORMAL")
            led.off()
            buzzer.off()
            moteur.duty(0)

        # Pause de 5 secondes avant la prochaine lecture pour ThingsBoard
        time.sleep(5)

    except Exception as e:
        print(" Erreur :", e)
        time.sleep(2)