import machine 
from lcd_i2c import LCD
from machine import ADC, Pin, I2C
import micropython
import network
import time
from umqtt.simple import MQTTClient

#indico red de wifi y clave
ssid = 'Wokwi-GUEST'
wifipassword = ''

#Definimos modo Station (conectarse a Access Point remoto)
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
#conectamos al wifi 
sta_if.connect(ssid, wifipassword)
print("Conectando")
while not sta_if.isconnected():
    print(".", end="")
    time.sleep(0.1)
print("Conectado a Wifi!")
#vemos cuales son las ip
print(sta_if.ifconfig())

#Datos Server MQTT(Broker)
mqtt_server = 'io.adafruit.com'
port = 1883
user = 'ulisesdz18'
password = 'aio_VCiA05Op6bnYCZoDSfpt8Z4yz37F'
client_id = 'calefon'
topic_AprendidoApagado = 'ulisesdz18/feeds/ApagadoAprendido'
topic_LedTemperatura = 'ulisesdz18/feeds/EstadoLedTemperatura'
topic_LedTemporizador = 'ulisesdz18/feeds/EstadoLedTemperatura'
topic_TemperaturaActual = 'ulisesdz18/feeds/TemperaturaActual'
topic_TemperaturaLimite = 'ulisesdz18/feeds/TemperaturaLimite'
topic_Temporizador = 'ulisesdz18/feeds/Temporizador'

#Pines 
Led_Rojo = Pin(9, Pin.OUT) #este Led indica si esta encendido ó apagado
led_rgb = {
    "rojo": Pin(8, Pin.OUT),
    "verde": Pin(7, Pin.OUT),
    "azul": Pin(6, Pin.OUT)
}
sensor_ntc = ADC(2) #sensor de temperatura-analógico 
sensor_ntc.atten(ADC.ATTN_11DB)

#lcd i2c
I2C_ADDR = 0x27 #DEC 39, HEX 0x27
i2c = I2C(0, scl=Pin(4), sda=Pin(5), freq=800000)
lcd = LCD(addr=I2C_ADDR, cols=20, rows=4, i2c=i2c)

#Variables Globales
temperatura_objetivo = 50 #en grados Celsius
temporizador_objetivo = 1 #tiempo en minutos
temporizador_restante = 0 #tiempo restante en segundos
estado_actual = "inicio"
temperatura_actual = 0
proyecto_encendido = True

#definimos funciones 
def cambiar_color_rgb(color):
    """Enciende un color especifico en el LED RGB y apaga los demás"""
    for key in led_rgb:
        led_rgb[key].value(1 if key == color else 0)

def iniciar_temporizador():
    global estado_actual, temporizador_restante
    temporizador_restante = temporizador_objetivo * 60
    estado_actual = "temporizador"
    cambiar_color_rgb("azul")
    print(f"temorizador iniciado: {temporizador_objetivo} minutos")

def actualizar_temporizador():
    global estado_actual, temporizador_restante

    if temporizador_restante > 0:
        temporizador_restante -= 1
        minutos = temporizador_restante // 60
        segundos = temporizador_restante % 60
        print(f"Tiempo restante: {minutos} minutos, {segundos} segundos")
        lcd.clear()
        lcd.putstr(f"Temp: {temperatura_actual:.1f}C\nTimer: {minutos:02}:{segundos:02}")
    else:
        estado_actual = "tiempo_completado"
        cambiar_color_rgb("amarillo")
        print("Temporizador completado")

def medir_temperatura():
    global temperatura_actual
    # Simulación de lectura del sensor NTC
    temperatura_actual += 1  # Incremento simulado para pruebas
    if temperatura_actual >= temperatura_objetivo:
        estado_actual = "temperatura_alcanzada"
        cambiar_color_rgb("verde")
    lcd.putstr(f"Temp: {temperatura_actual:.1f}C")
    client.publish(topic_TemperaturaActual, str(temperatura_actual))

def funcion_callback(topic, mensaje):
    global proyecto_encendido, temporizador_objetivo, temperatura_objetivo

    try:
        # Decodificar el mensaje recibido
        mensaje_decodificado = mensaje.decode("utf-8")
        print(f"Mensaje recibido en {topic}: {mensaje_decodificado}")

        # Verificar el tópico y actualizar variables globales
        if topic == topic_AprendidoApagado:
            proyecto_encendido = (mensaje_decodificado == "ON")
            led_rojo.value(proyecto_encendido)  # Encender/apagar LED rojo
            print(f"Proyecto {'encendido' if proyecto_encendido else 'apagado'}")

        elif topic == topic_Temporizador:
            try:
                temporizador_objetivo = int(mensaje_decodificado)
                print(f"Nuevo temporizador: {temporizador_objetivo} minutos")
            except ValueError:
                print("Error: valor de temporizador inválido")

        elif topic == topic_TemperaturaLimite:
            try:
                temperatura_objetivo = int(mensaje_decodificado)
                print(f"Nueva temperatura objetivo: {temperatura_objetivo} °C")
            except ValueError:
                print("Error: valor de temperatura inválido")

    except Exception as e:
        print(f"Error en mensaje_recibido: {e}")

#intentamos conectarnos al broker MQTT
 try:
    conexionMQTT = MQTTClient(client_id, mqtt_server,user=user,password=password,port=int(port))
    conexionMQTT.set_callback(callback_alarma)
    conexionMQTT.connect()
    conexionMQTT.subscribe(topic_AprendidoApagado)
    conexionMQTT.subscribe(topic_Temporizador)
    conexionMQTT.subscribe(topic_TemperaturaLimite)
    print("Conectado con Broker MQTT")
except OSError as e:
    #Si fallo la conexion, reiniciamos todo
    print("Fallo la conexion al Broker, reiniciando...")
    time.sleep(5)
    machine.reset()

def main():
    global proyecto_encendido
    conectar_mqtt()
    while True:
        if proyecto_encendido:
            client.check_msg()
            medir_temperatura()
            if estado_actual == "temporizador":
                actualizar_temporizador()
        except OSError as e:
        print("Error ",e)
        time.sleep(5)
        machine.reset()