import machine
import time
import dht
from umqttsimple import MQTTClient
from wifi_lib import conecta
from defs import *


# Conexão ao Wi-Fi
print("Conectando...")
station = conecta("Wokwi-GUEST", "")
if not station.isconnected():
    print("Falha na conexão")
    raise SystemExit  # Saia do programa se a conexão falhar
else:
    print("Conectado wifi")
    
# Conexão ao Broker MQTT
print("Conectando Broker MQTT")
client = MQTTClient(mqtt_client_id, mqtt_server, mqtt_port, mqtt_user, mqtt_password)
try:
    client.connect()
    print("Conectado ao Broker MQTT!")
except Exception as e:
    print("Falha ao conectar ao Broker MQTT:", e)
    raise SystemExit  # Saia do programa se a conexão falhar

# Variável para controlar liga ou desliga dht
sensor_ativo = False

# Configurações do DHT22 e LEDs
dht_pin = machine.Pin(15)
dht_sensor = dht.DHT22(dht_pin)

red_pin = machine.Pin(4, machine.Pin.OUT)
green_pin = machine.Pin(0, machine.Pin.OUT)
blue_pin = machine.Pin(2, machine.Pin.OUT)

# Função para configurar o LED RGB
def set_led_color(red, green, blue):
    red_pin.value(not red)
    green_pin.value(not green)
    blue_pin.value(not blue)

# Função de leitura do sensor dht
def leitura_temperatura_humidade():
    try:
        dht_sensor.measure()
        temp = dht_sensor.temperature()
        hum = dht_sensor.humidity()
        return temp, hum
    except OSError as e:
        print("Erro ao fazer leitura no DHT22:", e)
        return None, None

# Controle de LED baseado na temperatura
def obter_status_temperatura(temp):
    if temp is not None:
        if temp < 5:
            set_led_color(0, 0, 1)  # Azul
            return "Temperatura muito fria"
        elif 5 <= temp <= 10:
            set_led_color(0, 1, 1)  # Ciano claro
            return "Temperatura fria"
        elif 10 < temp <= 18:
            set_led_color(0, 1, 1)  # Ciano
            return "Temperatura um pouco fria"
        elif 18 < temp <= 25:
            set_led_color(0, 1, 0)  # Verde
            return "Temperatura ideal"
        elif 25 < temp <= 28:
            set_led_color(1, 1, 0)  # Amarelo
            return "Temperatura um pouco quente"
        elif 28 < temp <= 32:
            set_led_color(1, 0, 1)  # Magenta
            return "Temperatura quente"
        else:
            set_led_color(1, 0, 0)  # Vermelho
            return "Temperatura muito quente"
    else:
        return "Falha ao ler a temperatura"

# Função para verificar a umidade
def obter_status_umidade(hum):
    if hum is not None:
        if hum < 30:
            return "Muito seco"
        elif 30 <= hum < 50:
            return "Abaixo do ideal"
        elif 50 <= hum <= 80:
            return "Ideal"
        else:
            return "Muito úmido"
    else:
        return "Falha ao ler a umidade"

# Função para publicar dados MQTT
def publicar_mqtt(client, temperatura, umidade):
    MQTT_TOPIC_TEMPERATURA = 'pucpr/wallace/temperatura'
    MQTT_TOPIC_UMIDADE = 'pucpr/wallace/umidade'

    if temperatura is not None:
        client.publish(MQTT_TOPIC_TEMPERATURA, str(temperatura))
    if umidade is not None:
        client.publish(MQTT_TOPIC_UMIDADE, str(umidade))

# Função para controle do sensor via MQTT
def controle_dht(topic, msg):
    global sensor_ativo
    comando = msg.decode("utf-8").strip()
    print(f"Comando recebido: {comando}")

    if comando == "LIGAR":
        sensor_ativo = True
        print("Ligado")
    elif comando == "DESLIGAR":
        sensor_ativo = False
        print("Desligado")

# Subscrevendo ao tópico de controle
client.set_callback(controle_dht)
client.subscribe('pucpr/wallace/controle')  # Tópico para controle do sensor

# Loop principal para leitura e envio de dados
while True:
    client.check_msg()  # Verificar se há mensagens MQTT recebidas

    if sensor_ativo:  # Coleta dados apenas se o sensor estiver ativo
        temperatura, umidade = leitura_temperatura_humidade()
        if temperatura is not None and umidade is not None:
            status_temperatura = obter_status_temperatura(temperatura)
            status_umidade = obter_status_umidade(umidade)

            # Imprimir tudo em uma única linha
            print("Temperatura: {}°C ({}) | Umidade: {}% ({})".format(
                temperatura, status_temperatura, umidade, status_umidade))

            # Publicar no MQTT
            publicar_mqtt(client, temperatura, umidade)
        else:
            print("Erro na leitura do sensor.")
    
    time.sleep(3)  # Intervalo de 3 segundo