from machine import Pin, I2C
from lcd_i2c import LCD
import time

# Configuración de pines SDA y SCL para I2C
sda = Pin(21, Pin.OUT)
scl = Pin(22, Pin.OUT)

NUM_ROWS = 2
NUM_COLS = 16

# Configuración de I2C y LCD
i2c = I2C(0, sda=sda, scl=scl, freq=400000)
lcd_addr = i2c.scan()[0]  
lcd = LCD(addr=lcd_addr, cols=NUM_COLS, rows=NUM_ROWS, i2c=i2c)
lcd.begin()
lcd.print("CODERE")

# Pines de entrada y salida
pin_red = Pin(4, Pin.IN, Pin.PULL_DOWN)
pin_grupo = Pin(18, Pin.IN, Pin.PULL_DOWN)
pin_confirmacion_red = Pin(5, Pin.IN, Pin.PULL_DOWN)

pin_relay_general = Pin(19, Pin.OUT)
boton_tiempo = Pin(23, Pin.IN, Pin.PULL_DOWN)

salida_red_abrir = Pin(27, Pin.OUT)
salida_red_cerrar = Pin(13, Pin.OUT)
salida_grupo_abrir = Pin(14, Pin.OUT)
salida_grupo_cerrar = Pin(15, Pin.OUT)

tiempo_inicio_grupo = None
tiempo_fin_grupo = None
ultima_pantalla = ("", "")

def mostrar_en_lcd(linea1, linea2=""):
    global ultima_pantalla
    lcd.clear()
    lcd.print(linea1[:16])
    lcd.set_cursor(0, 1)
    lcd.print(linea2[:16])
    ultima_pantalla = (linea1, linea2)

def cuenta_regresiva(mensaje, segundos=15):
    for i in range(segundos, 0, -1):
        lcd.clear()
        lcd.print(mensaje[:16])
        lcd.set_cursor(0, 1)
        lcd.print(f"{i} segundos")
        time.sleep(1)

def calcular_tiempo_grupo():
    if tiempo_inicio_grupo is None:
        return "No hay datos", "aún"
    tiempo_actual = tiempo_fin_grupo if tiempo_fin_grupo else time.time()
    tiempo_total = int(tiempo_actual - tiempo_inicio_grupo)
    horas = tiempo_total // 3600
    minutos = (tiempo_total % 3600) // 60
    segundos = tiempo_total % 60
    return "Tiempo en GRUPO", f"{horas}h {minutos}m {segundos}s"

def abrir_interruptor(pin):
    pin.on()
    time.sleep(5)
    pin.off()

def cerrar_interruptor(pin):
    pin.on()
    time.sleep(5)
    pin.off()

def transferir_a_grupo():
    global tiempo_inicio_grupo
    mostrar_en_lcd("Transf. a GRUPO", "Ejecutando...")
    abrir_interruptor(salida_red_abrir)
    time.sleep(1)
    cerrar_interruptor(salida_grupo_cerrar)
    tiempo_inicio_grupo = time.time()
    mostrar_en_lcd("Fuente: GRUPO", "Energía estable")

def transferir_a_red():
    global tiempo_fin_grupo
    mostrar_en_lcd("Transf. a RED", "Ejecutando...")
    abrir_interruptor(salida_grupo_abrir)
    time.sleep(1)
    cerrar_interruptor(salida_red_cerrar)
    tiempo_fin_grupo = time.time()
    mostrar_en_lcd("Fuente: RED", "Energía estable")

def funcion_inicializar():
    mostrar_en_lcd("Inicializando...")
    pin_relay_general.on()
    abrir_interruptor(salida_grupo_abrir)
    cerrar_interruptor(salida_red_cerrar)
    mostrar_en_lcd("Fuente: RED", "Energía estable")

funcion_inicializar()
estado_actual = "RED"
mostrar_en_lcd("Fuente: RED", "Energía estable")

while True:
    red_estado = pin_red.value()
    grupo_estado = pin_grupo.value()
    pin5_estado = pin_confirmacion_red.value()
    print(f"DEBUG: Red: {red_estado} | Grupo: {grupo_estado} | Confirmación Red (Pin5): {pin5_estado}")

    # Corte de red
    if estado_actual == "RED" and red_estado == 0:
        mostrar_en_lcd("Corte de RED", "Verificando GRUPO")
        grupo_activo = False
        for _ in range(10):
            if pin_grupo.value() == 1:
                grupo_activo = True
                break
            time.sleep(1)

        if not grupo_activo:
            mostrar_en_lcd("GRUPO NO DISP.", "Esperando RED o GRUPO")
            print("Grupo no arrancó. Esperando red...")

            # Esperar a que vuelva la red
            while pin_red.value() == 0:
                time.sleep(1)

            mostrar_en_lcd("Fuente: RED", "Energía estable")
            continue

        cuenta_regresiva("Transf. a GRUPO", 15)
        transferir_a_grupo()
        estado_actual = "GRUPO"

    # Vuelve la red y se puede transferir
    elif estado_actual == "GRUPO" and red_estado == 1 and pin5_estado == 1:
        cuenta_regresiva("Transf. a RED", 15)
        transferir_a_red()
        estado_actual = "RED"
        if pin_grupo.value() == 1:
            mostrar_en_lcd("Fuente:RED", "Apaga el Grupo")

    # Actualizar mensaje cuando grupo se apaga después de volver a red
    if estado_actual == "RED" and ultima_pantalla == ("Fuente:RED", "Apaga el Grupo") and pin_grupo.value() == 0:
        mostrar_en_lcd("Fuente:RED", "Energia Estable")

    # Mostrar tiempo cuando se presiona el botón
    if boton_tiempo.value() == 1:
        mensaje1, mensaje2 = calcular_tiempo_grupo()
        pantalla_anterior = ultima_pantalla
        mostrar_en_lcd(mensaje1, mensaje2)
        time.sleep(5)
        mostrar_en_lcd(*pantalla_anterior)

    time.sleep(1)