import time
import machine
import network
from machine import Pin, I2C, ADC
from umqtt.simple import MQTTClient
from lcd_i2c import LCD
import math  # Asegúrate de importar esta librería

# Configuración WiFi
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())

# Configuración MQTT
mqtt_server = 'io.adafruit.com'
port = 1883
user = 'ulisesdz18'
password = 'aio_jNQw99DOR79dTaATaGdPUhA6sUF9'
client_id = 'calefon'
topic_ApagadoEncendido = 'ulisesdz18/feeds/ApagadoEncendido'
topic_TemperaturaActual = 'ulisesdz18/feeds/TemperaturaActual'
topic_TemperaturaLimite = 'ulisesdz18/feeds/TemperaturaLimite'
topic_Temporizador = 'ulisesdz18/feeds/Temporizador'

# Pines
led_rojo = Pin(9, Pin.OUT)  # Indica si está encendido
led_rgb = {
    "rojo": Pin(8, Pin.OUT),
    "verde": Pin(7, Pin.OUT),
    "azul": Pin(6, Pin.OUT)
}
sensor_ntc = ADC(2)  # Sensor de temperatura
sensor_ntc.atten(ADC.ATTN_11DB)

# Configuración del LCD
I2C_ADDR = 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
last_publish_time = 0  # Variable para controlar el tiempo de publicación en MQTT
last_temperatura = None  # Para almacenar la última temperatura publicada

# Resistencia fija para el divisor de voltaje (ajústalo según tu configuración)
R_f = 10000  # 10k ohmios (resistencia de referencia del divisor de voltaje)

# Funciones
def cambiar_color_rgb(color):
    """Controla el LED RGB"""
    for key in led_rgb:
        led_rgb[key].value(1 if key == color else 0)

def iniciar_temporizador():
    """Inicia el temporizador"""
    global estado_actual, temporizador_restante
    temporizador_restante = temporizador_objetivo * 60
    estado_actual = "temporizador"
    cambiar_color_rgb("azul")
    print(f"Temporizador iniciado: {temporizador_objetivo} minutos")
    lcd.clear()
    lcd.print("Temporizador activo")
    lcd.set_cursor(col=0, row=1)
    lcd.print(f"Duración: {temporizador_objetivo} min")

def actualizar_temporizador():
    """Actualiza el 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.print(f"Temp: {temperatura_actual:.1f}C")
        lcd.set_cursor(col=0, row=1)
        lcd.print(f"Timer: {minutos:02}:{segundos:02}")
    else:
        estado_actual = "tiempo_completado"
        cambiar_color_rgb("amarillo")
        print("Temporizador completado")

def convertir_a_temperatura(valor_adc):
    """Convierte el valor del ADC a temperatura en grados Celsius usando un divisor de voltaje"""
    # Convertir el valor del ADC (0-4095) a voltaje
    voltaje = (valor_adc / 4095) * 3.3
    # Calcular la resistencia del NTC usando la ley de Ohm
    R_ntc = R_f * (3.3 / voltaje - 1)
    # Fórmula simple para la conversión NTC (ajustar según tu sensor específico)
    # Temperatura en grados Celsius (puede requerir ajuste dependiendo del NTC)
    temperatura = 1 / (0.001129148 + 0.000234125 * math.log(R_ntc) + 0.0000000876741 * (math.log(R_ntc))**3) - 273.15
    return temperatura

def medir_temperatura():
    """Lee la temperatura y actualiza el estado"""
    global temperatura_actual, estado_actual
    # Leer el valor del ADC
    valor_adc = sensor_ntc.read()
    # Convertir el valor del ADC a temperatura
    temperatura_actual = convertir_a_temperatura(valor_adc)
    
    # Mostrar la temperatura en el LCD
    lcd.clear()
    lcd.print(f"Temp: {temperatura_actual:.1f}C")
    lcd.set_cursor(col=0, row=1)
    lcd.print("Monitoreando...")
    
    if temperatura_actual >= temperatura_objetivo:
        estado_actual = "temperatura_alcanzada"
        cambiar_color_rgb("verde")
        lcd.clear()
        lcd.print("Temp alcanzada!")

def publicar_mqtt():
    """Envía la temperatura al broker MQTT solo si ha cambiado"""
    global last_publish_time, last_temperatura
    current_time = time.time()
    
    # Publicar solo si la temperatura ha cambiado o ha pasado más de 10 segundos
    if current_time - last_publish_time >= 10 or temperatura_actual != last_temperatura:
        # Publicar solo si la temperatura ha cambiado
        client.publish(topic_TemperaturaActual, str(temperatura_actual))
        last_publish_time = current_time
        last_temperatura = temperatura_actual  # Actualizamos el último valor de temperatura
        print(f"Temperatura publicada: {temperatura_actual:.1f}C")

def funcion_callback(topic, mensaje):
    """Callback para manejar mensajes MQTT"""
    global proyecto_encendido, temporizador_objetivo, temperatura_objetivo
    topic = topic.decode("utf-8")
    mensaje = mensaje.decode("utf-8")
    print(f"Mensaje recibido en {topic}: {mensaje}")

    if topic == topic_ApagadoEncendido:
        proyecto_encendido = (mensaje == "ON")
        led_rojo.value(proyecto_encendido)
        print(f"Proyecto {'encendido' if proyecto_encendido else 'apagado'}")
        lcd.clear()
        lcd.print("Sistema encendido" if proyecto_encendido else "Sistema apagado")
    elif topic == topic_Temporizador:
        try:
            temporizador_objetivo = int(mensaje)
            print(f"Nuevo temporizador: {temporizador_objetivo} minutos")
        except ValueError:
            print("Valor de temporizador inválido")
    elif topic == topic_TemperaturaLimite:
        try:
            temperatura_objetivo = int(mensaje)
            print(f"Nueva temperatura objetivo: {temperatura_objetivo} °C")
        except ValueError:
            print("Valor de temperatura inválido")

# Conexión MQTT
def conectar_mqtt():
    global client
    client = MQTTClient(client_id, mqtt_server, user=user, password=password, port=port)
    client.set_callback(funcion_callback)
    client.connect()
    client.subscribe(topic_ApagadoEncendido)
    client.subscribe(topic_Temporizador)
    client.subscribe(topic_TemperaturaLimite)
    print("Conectado al broker MQTT")

# Main
def main():
    global proyecto_encendido

    conectar_mqtt()
    lcd.begin()
    lcd.print("Iniciando sistema...")
    time.sleep(10)

    while True:
        try:
            client.check_msg()
            if proyecto_encendido:
                medir_temperatura()
                publicar_mqtt()  # Publica solo si la temperatura ha cambiado
                if estado_actual == "temporizador":
                    actualizar_temporizador()
        except OSError as e:
            print("Error: ", e)
            time.sleep(5)
            machine.reset()

if __name__ == "__main__":
    main()