# Cet exemple illustre un périphérique de capteur de Temperature et Humidité et aussi une commande de Relais.
# La valeur locale du capteur est mise à jour toutes les secondes, et il enverra une notification.
# à tout périphérique central connecté toutes les n secondes.
#****************************************************************************************************
import bluetooth
import random
import struct
import time
#******************************************
from machine import Pin
import dht
#******************************************
from ble_advertising import advertising_payload
from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_INDICATE_DONE = const(20) # Option GATT indication faite
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)
_FLAG_INDICATE = const(0x0020)

# org.bluetooth.service.environmental_sensing :
#_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
_ENV_SENSE_UUID = bluetooth.UUID("0000181A-0000-1000-8000-00805F9B34FB")
# org.bluetooth.characteristic.temperature :
_TEMP_CHAR = (
    bluetooth.UUID("00002A6E-0000-1000-8000-00805F9B34FB"), #0x2A6E
    _FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,
)

# Ajout de la caracteristique humidité : https://www.bluetooth.com/specifications/assigned-numbers/
_HUM_CHAR = (
    bluetooth.UUID("00002A6F-0000-1000-8000-00805F9B34FB"), #0x2A6F
    _FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,
)


_ENV_SENSE_SERVICE = (
    _ENV_SENSE_UUID,
    (_TEMP_CHAR, _HUM_CHAR,),
)

# Definir un nouveau service UUID :
_RELAIS_SERVICE_UUID = bluetooth.UUID("F5A128FE-227D-4C9E-AD2C-11D0FD6ED640")
#Ajouter une caractéristique de commande UUID:
_RELAIS_CHAR = (
    bluetooth.UUID("F5A1289E-227D-4C9E-AD2C-11D0FD6ED640"),
    _FLAG_READ | _FLAG_WRITE | _FLAG_INDICATE,
)

#le nouveau service
_RELAIS_SENSE_SERVICE = (
    _RELAIS_SERVICE_UUID,
    (_RELAIS_CHAR,),
)

# org.bluetooth.characteristic.gap.appearance.xml
_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)



class BLECapteurActionneur:
    def __init__(self, ble, name="ESP32MyTemp"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        self._connections = set()
        # Recuperer les handlers des caracteristiques 
        ((self._handle_t,self._handle_h,),(self._handle_r,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,_RELAIS_SENSE_SERVICE,))
        self._payload = advertising_payload(name=name, appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER)
        self._advertise()

    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_INDICATE_DONE:
            conn_handle, value_handle, status = data
        #Nouveu event pour gerer la demande d'ecriture de la caractéristique Relais (Commande Relais) 
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            if value_handle == self._handle_r:
                # Lire la commande reçu et l'afficher sur l'interface serie :
                received_data = self._ble.gatts_read(self._handle_r).decode('utf-8')
                """La fonction self._ble.gatts_read(self._handle_r) renvoie probablement des données au format bytes (octets). Cela signifie que la variable received_data est une séquence d'octets.

Dans votre cas, vous avez utilisé .decode('utf-16') pour décoder ces octets en une chaîne de caractères en utilisant l'encodage UTF-16. Cependant, l'UTF-16 peut inclure des caractères nuls (\x00) qui peuvent affecter la comparaison de chaînes.
"""
                received_data = received_data.replace('\x00', '') # enlever les caractères non visibles pour faire la comparaison
                if received_data == "ON" :
                    print("Commande Relais reçu : ON")
                else:
                    print("Commande Relais reçu : OFF")
                
                pass
    # Ajouter la fonction set_temperature :        
    def set_temperature(self, temp_deg_c, notify=False, indicate=False):
        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
        # Write the local value, ready for a central to read.
        #struct.pack("<h", int(temp_deg_c * 100))
        self._ble.gatts_write(self._handle_t, temp_deg_c)
        if notify or indicate:
            for conn_handle in self._connections:
                if notify:
                    # Notify connected centrals.
                    self._ble.gatts_notify(conn_handle, self._handle_t)
                if indicate:
                    # Indicate connected centrals.
                    self._ble.gatts_indicate(conn_handle, self._handle_t)
    # Ajouter la fonction set_humidity :
    def set_humidity(self, humidity, notify=False, indicate=False):
        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
        # Write the local value, ready for a central to read.
        self._ble.gatts_write(self._handle_h, humidity)
        if notify or indicate:
            for conn_handle in self._connections:
                if notify:
                    # Notify connected centrals.
                    self._ble.gatts_notify(conn_handle, self._handle_h)
                if indicate:
                    # Indicate connected centrals.
                    self._ble.gatts_indicate(conn_handle, self._handle_h)
    
    def set_data(self, data): #Modifier la valeur de l'etat du Relais
        self._ble.gatts_write(self._handle_r, data)
    def read_data(self): # Lire la valeur de l'etat du Relais
        return (self._ble.gatts_read(self._handle_r).decode('utf-16'))
    def bl_connexion(self):
        return(len(self._connections))
    def _advertise(self, interval_us=500000):
        self._ble.gap_advertise(interval_us, adv_data=self._payload)
        
def simulate_dht11_data(interval_seconds):
    while True:
        humidity = round(random.uniform(20, 80), 2)  # Entre 20% et 80%
        temperature = round(random.uniform(18, 30), 2)  # Entre 18°C et 30°C
        yield humidity, temperature
        time.sleep(interval_seconds)
        

def capteur_actionneur():
    ble = bluetooth.BLE()
    temp = BLECapteurActionneur(ble)
    interval_seconds = 10  #interval de changement de la data
    simulated_data_generator = simulate_dht11_data(interval_seconds)
    
    n= 10 # nombre de secondes pour notification
    i =0
    
    while True:
        if temp.bl_connexion() <= 0:
            print("En attente de connexion ...")
        else:
            # Write every second, notify every 10 seconds.
            i = (i + 1) % n
            # Capteur DHT 11 Lecture de la  Temperature ou Humidity :
            humidity, temperature = next(simulated_data_generator)
            # Afficher la valeur envoyée :
            print(f"Temperature = {temperature:3.1f} C &  Humidity = {humidity:3.1f} %")
            # Formater la Temperature  :
            #data_le = struct.pack("<h", int(temperature * 100))
            data_le = str(int(temperature * 100)).encode('utf-8')
            temp.set_temperature(data_le, notify=i == 0, indicate=True)
            # Formater Lumidité :
            #data_h = struct.pack("<h", int(humidity * 100))
            data_h = str(int(humidity * 100)).encode('utf-8')
            temp.set_humidity(data_h, notify=i == 0, indicate=True)
        time.sleep_ms(2000)

if __name__ == "__main__":
    capteur_actionneur()