import network
import time
import dht
import ujson
import machine
import ubinascii

from machine import Pin, ADC
from umqtt.simple import MQTTClient

WIFI_SSID = "Wokwi-GUEST"
WIFI_PASSWORD = ""

MQTT_BROKER = "broker.hivemq.com"
MQTT_PORT = 1883
MQTT_CLIENT_ID = "smartagro_b_" + ubinascii.hexlify(machine.unique_id()).decode()

ROOT = "fazenda_equipe"

TOPIC_CLIMA = (ROOT + "/estufa/clima").encode()
TOPIC_SOLO = (ROOT + "/canteiro/umidade").encode()
TOPIC_CONTROLE = (ROOT + "/estufa/controle").encode()

dht_sensor = dht.DHT22(Pin(15))

ldr = ADC(Pin(34))
ldr.atten(ADC.ATTN_11DB)

exaustor = Pin(26, Pin.OUT)
grow_light = Pin(25, Pin.OUT)

TEMPERATURA_LIMITE = 28
LUMINOSIDADE_LIMITE = 35
UMIDADE_SOLO_ALTA = 80
UMIDADE_AR_ALTA = 75

TEMPO_EXTRA_EXAUSTOR = 60000
VALIDADE_SOLO = 30000
INTERVALO_PUBLICACAO = 5000
INTERVALO_LOOP = 200

umidade_solo = 0
ultima_msg_solo = None

modo = "auto"
comando_exaustor = False
comando_luz = False

fan_hold_until = 0

ultima_temp = 25.0
ultima_umid = 50.0
ultima_luz = 50

estado_fan = False
estado_luz = False


def conectar_wifi():
    wifi = network.WLAN(network.STA_IF)
    wifi.active(True)

    if not wifi.isconnected():
        print("Conectando ao WiFi...")
        wifi.connect(WIFI_SSID, WIFI_PASSWORD)

        while not wifi.isconnected():
            time.sleep(0.5)

    print("WiFi conectado!")
    print("IP:", wifi.ifconfig()[0])


def receber_mensagem(topic, msg):
    global umidade_solo, ultima_msg_solo
    global modo, comando_exaustor, comando_luz

    try:
        dados = ujson.loads(msg)

        if topic == TOPIC_SOLO:
            umidade_solo = float(dados.get("umidade_solo", 0))
            ultima_msg_solo = time.ticks_ms()
            print("Umidade do solo recebida:", umidade_solo)

        elif topic == TOPIC_CONTROLE:
            modo = dados.get("modo", modo)

            if "exaustor" in dados:
                comando_exaustor = bool(dados["exaustor"])

            if "grow_light" in dados:
                comando_luz = bool(dados["grow_light"])

            print("Comando recebido:", dados)

    except Exception as erro:
        print("Erro ao processar MQTT:", erro)


def conectar_mqtt():
    cliente = MQTTClient(
        MQTT_CLIENT_ID,
        MQTT_BROKER,
        port=MQTT_PORT,
        keepalive=60
    )

    cliente.set_callback(receber_mensagem)
    cliente.connect()

    cliente.subscribe(TOPIC_SOLO)
    cliente.subscribe(TOPIC_CONTROLE)

    print("Conectado ao broker HiveMQ!")
    print("Inscrito nos topicos MQTT.")

    return cliente


def conectar_mqtt_com_retry():
    while True:
        try:
            return conectar_mqtt()
        except OSError as erro:
            print("Falha ao conectar no broker:", erro)
            time.sleep(3)


def ler_sensores():
    global ultima_temp, ultima_umid, ultima_luz

    try:
        dht_sensor.measure()
        ultima_temp = dht_sensor.temperature()
        ultima_umid = dht_sensor.humidity()
    except OSError as erro:
        print("Falha na leitura do DHT22:", erro)

    valor_ldr = ldr.read()
    ultima_luz = 100 - int((valor_ldr / 4095) * 100)

    return ultima_temp, ultima_umid, ultima_luz


def controlar_sistema(temperatura, umidade_ar, luminosidade):
    global fan_hold_until, estado_fan, estado_luz

    agora = time.ticks_ms()

    if modo == "manual":
        estado_fan = comando_exaustor
        estado_luz = comando_luz
    else:
        estado_luz = luminosidade < LUMINOSIDADE_LIMITE

        solo_valido = (
            ultima_msg_solo is not None
            and time.ticks_diff(agora, ultima_msg_solo) < VALIDADE_SOLO
        )

        if (
            solo_valido
            and umidade_solo >= UMIDADE_SOLO_ALTA
            and umidade_ar >= UMIDADE_AR_ALTA
        ):
            fan_hold_until = time.ticks_add(agora, TEMPO_EXTRA_EXAUSTOR)

        temperatura_alta = temperatura > TEMPERATURA_LIMITE
        tempo_extra = time.ticks_diff(fan_hold_until, agora) > 0

        estado_fan = temperatura_alta or tempo_extra

    exaustor.value(1 if estado_fan else 0)
    grow_light.value(1 if estado_luz else 0)


def publicar_dados(cliente, temperatura, umidade_ar, luminosidade):
    dados = {
        "temp": temperatura,
        "umid_ar": umidade_ar,
        "luz": luminosidade,
        "exaustor": estado_fan,
        "grow_light": estado_luz
    }

    mensagem = ujson.dumps(dados)
    cliente.publish(TOPIC_CLIMA, mensagem.encode())

    print("Dados enviados:", mensagem)


def imprimir_status(temperatura, umidade_ar, luminosidade):
    print("--------------------------")
    print("Temperatura:", temperatura, "C")
    print("Umidade do ar:", umidade_ar, "%")
    print("Luminosidade:", luminosidade, "%")
    print("Umidade do solo:", umidade_solo, "%")
    print("Exaustor:", "LIGADO" if estado_fan else "DESLIGADO")
    print("Grow Light:", "LIGADA" if estado_luz else "DESLIGADA")
    print("Modo:", modo)


conectar_wifi()
cliente = conectar_mqtt_com_retry()

proximo_envio = time.ticks_ms()

while True:
    try:
        cliente.check_msg()

        agora = time.ticks_ms()

        if time.ticks_diff(agora, proximo_envio) >= 0:
            temperatura, umidade_ar, luminosidade = ler_sensores()
            controlar_sistema(temperatura, umidade_ar, luminosidade)
            imprimir_status(temperatura, umidade_ar, luminosidade)
            publicar_dados(cliente, temperatura, umidade_ar, luminosidade)
            proximo_envio = time.ticks_add(agora, INTERVALO_PUBLICACAO)
        else:
            controlar_sistema(ultima_temp, ultima_umid, ultima_luz)

        time.sleep_ms(INTERVALO_LOOP)

    except OSError as erro:
        print("Erro de comunicacao:", erro)
        time.sleep(3)

        try:
            cliente.disconnect()
        except Exception:
            pass

        conectar_wifi()
        cliente = conectar_mqtt_com_retry()

    except Exception as erro:
        print("Erro:", erro)
        time.sleep(3)