import machine
import network
import time
from machine import Pin, PWM
import dht
import ujson
from umqtt.simple import MQTTClient
import uasyncio as asyncio

# Configurações MQTT
MQTT_CLIENT_ID = "micropython-weather-demo"
MQTT_BROKER = "test.mosquitto.org"
MQTT_USER = ""
MQTT_PASSWORD = ""
MQTT_TOPIC_PUBLISH = "wokwi-weather10-kobi"  # Tópico para enviar dados de temperatura
MQTT_TOPIC_CONTROL = "wokwi-servo-control-kobi"  # Tópico para receber comandos do Node-RED
MQTT_TOPIC_LED = "wokwi-led-control-kobi"  # Tópico para receber comandos do LED


led_verde = Pin(4, Pin.OUT)
led_amarelo = Pin(16, Pin.OUT)
led_vermelho = Pin(5, Pin.OUT)

trigger_pin = Pin(18, Pin.OUT)  # Trigger no Pino 18
echo_pin = Pin(17, Pin.IN)       # Echo no Pino 17

# Inicializa a conexão com a rede WiFi
def connect_to_wifi():
    print("Conectando ao WiFi", end="")
    sta_if = network.WLAN(network.STA_IF)
    sta_if.active(True)
    sta_if.connect('Wokwi-GUEST', '')
    while not sta_if.isconnected():
        print(".", end="")
        time.sleep(0.1)
    print(" Conectado!")

# Conecta ao broker MQTT
def connect_to_mqtt():
    client = MQTTClient(MQTT_CLIENT_ID, MQTT_BROKER, user=MQTT_USER, password=MQTT_PASSWORD)
    client.connect()
    return client


# Conexão WiFi e MQTT
connect_to_wifi()
client = connect_to_mqtt()
print("Conectado ao MQTT!")


def read_ultrasonic_distance(trigger_pin, echo_pin):
    trigger_pin.value(0)
    time.sleep_us(2)
    trigger_pin.value(1)
    time.sleep_us(10)
    trigger_pin.value(0)

    while echo_pin.value() == 0:
        pass
    start = time.ticks_us()

    while echo_pin.value() == 1:
        pass
    end = time.ticks_us()

    duration = time.ticks_diff(end, start)
    distance_cm = (duration * 0.0343) / 2
    return distance_cm


def led_on():
    led.value(1)  # Liga o LED


def led_off():
    led.value(0)  # Desliga o LED


# Função de callback para comandos recebidos via MQTT
def sub_cb(topic, msg):
    print("Mensagem recebida:", msg)  # Log para verificar a mensagem recebida
    
    try:
        data = ujson.loads(msg)  # Converte a mensagem recebida de JSON para um dicionário
        if isinstance(data, list) and len(data) > 0:
            # Pega o último item da lista
            ultimo_item = data[-1]
            distancia = ultimo_item.get('y', 0)
            
            # Lógica para acender os LEDs baseado na distância
            if distancia > 30:
                # Liga o LED vermelho
                led_verde.value(0)
                led_amarelo.value(0)
                led_vermelho.value(1)
                print(f"Distância: {distancia} cm, LED Verde ligado")
            elif distancia < 15:
                # Liga o LED verde
                led_vermelho.value(0)
                led_verde.value(1)
                led_amarelo.value(0)
                print(f"Distância: {distancia} cm, LED Vermelho ligado")
            else:
                # Liga o LED amarelo
                led_amarelo.value(1)
                led_verde.value(0)
                led_vermelho.value(0)
                print(f"Distância: {distancia} cm, LED Amarelo ligado")
    except ValueError:
        print("Erro ao processar mensagem JSON")


client.set_callback(sub_cb)
client.subscribe(MQTT_TOPIC_LED)


# Função para verificar mensagens de controle (servo/LED) recebidas
async def check_messages():
    global client
    while True:
        try:
            if client is not None:
                client.check_msg()  # Verifica novas mensagens
            else:
                print("Cliente MQTT é None, tentando reconectar...")
                await reconnect_mqtt()


            await asyncio.sleep(1)
        except OSError as e:
            if e.args[0] == -1:
                print("Erro ao verificar mensagens: -1 (possível desconexão)")
                await reconnect_mqtt()
            else:
                print("Erro ao verificar mensagens:", e)
                await asyncio.sleep(2)
                await reconnect_mqtt()


# Função para reconectar ao broker MQTT se houver desconexão
async def reconnect_mqtt():
    global client
    try:
        if client is not None:
            print("Tentando reconectar...")
            client = connect_to_mqtt()
            client.set_callback(sub_cb)
            client.subscribe(MQTT_TOPIC_LED)
            print("Reconectado ao MQTT!")
        else:
            print("Erro: Cliente MQTT é None.")
    except Exception as e:
        print("Erro ao reconectar:", e)


# Função principal para leitura do sensor, potenciômetro e publicação dos dados
async def main():
    global client
    try:
        while True:
            distance = read_ultrasonic_distance(trigger_pin, echo_pin)
            print("Distância: ", distance, "cm")



            # Criação do payload com temperatura, umidade e valor do potenciômetro
            data = {
                "distancia": distance
            }


            # Conversão para JSON e publicação
            json_data = ujson.dumps(data)


            try:
                client.publish(MQTT_TOPIC_PUBLISH, json_data)
                print("Dados publicados:", json_data)
            except OSError as e:
                print("Erro ao publicar:", e)
                await reconnect_mqtt()


            await asyncio.sleep(5)  # Envia os dados a cada 5 segundos


    except KeyboardInterrupt:
        if client is not None:
            client.disconnect()
        print("Desconectado do broker MQTT.")


# Função para rodar as tarefas principais
async def run():
    await asyncio.gather(main(), check_messages())


asyncio.run(run())