# 1.- ---------------- Encabezado ----------------------------------------------
# Autor : Jorge Anzaldo
# Fecha : 27/04/2026
# Descripcion del programa : 
# Uso de Herencia Simple para controlar una Torre de 8 LEDs.
# Se hereda de la clase base Led para crear una secuencia compleja.
# Identificación de Constructores y Destructores en Herencia Simple.

# 2.- ---------------- Importación de Módulos y Bibliotecas --------------------
from machine import Pin
import time

# 3.- ---------------- Definición de Funciones o Clases ------------------------

class Led:
    """Clase Base: Representa un único LED físico."""
    # === CONSTRUCTOR DE LA CLASE BASE ===
    def __init__(self, numeroPin):
        self.numeroPin = numeroPin
        # COMPOSICIÓN: Atributo que es una instancia de otra clase (Pin)
        self.led = Pin(self.numeroPin, Pin.OUT)
        print(f"[CONSTRUCTOR LED] Instancia en pin {self.numeroPin} creada.")

    def prender(self, tiempo=0):
        self.led.on()
        if tiempo > 0:
            time.sleep(tiempo)
            self.led.off()

    def apagar(self):
        self.led.off()
    """El método __str__ personaliza lo que se muestra al hacer print(objeto) o str(objeto). """
    """ Aquí devuelve un texto con el pin GPIO del LED."""

    def __str__(self):
        return f"LED(GPIO {self.numeroPin})"

    # === DESTRUCTOR DE LA CLASE BASE ===
    def __del__(self):
        self.apagar()
        print(f"[DESTRUCTOR LED] El objeto en pin {self.numeroPin} fue destruido.")


class TorreLed(Led):
    """Subclase: Gestiona 8 LEDs mediante Herencia Simple."""
    
    # === CONSTRUCTOR DE LA SUBCLASE ===
    def __init__(self, lista_pines):
        # Nota: Aquí se crean 8 objetos Led, disparando 8 veces el constructor base
        self.lista_leds = []
        for p in lista_pines:
            led = Led(p)
            self.lista_leds.append(led)
        print(f"\n>>> [CONSTRUCTOR TORRE] Sistema de {len(self.lista_leds)} LEDs listo.\n")

    def encendido_secuencial(self, velocidad=0.1):
        for objeto_led in self.lista_leds:
            objeto_led.prender()
            time.sleep(velocidad)

    def apagar_todo(self):
        for objeto_led in self.lista_leds:
            objeto_led.apagar()

    """ __str__(): define qué texto mostrar cuando usas print() con este objeto"""
    def __str__(self):
        return f"TorreLed de {len(self.lista_leds)} elementos"

    # === DESTRUCTOR DE LA SUBCLASE ===
    def __del__(self):
        self.apagar_todo()
        print(f"[DESTRUCTOR TORRE] {self} ha sido removido de memoria.")

# 4.- ---------------- Variables u Objetos Globales ----------------------------
pines = [13, 12, 14, 27, 26, 25, 33, 32]

# 5.- ---------------- Bloque Principal ----------------------------------------
if __name__ == "__main__":
    # Al ejecutar esta línea, se disparan los constructores
    torreta = TorreLed(pines)
    
    try:
        while True:
            torreta.encendido_secuencial(0.1)
            torreta.apagar_todo()
            time.sleep(0.5)
    except KeyboardInterrupt:
        # Al detener el programa, el recolector de basura de Python
        # llamará a los destructores automáticamente.
        print("\nCerrando sistema...")

# 6.- ---------------- Documentación y Comentarios------------------------------

"""
REPASO PARA EL EXAMEN:

1. CLASE Y OBJETOS: Una clase es la plantilla (molde) y los objetos son las 
   instancias creadas a partir de ella[cite: 8, 9].
2. COMPOSICIÓN: Se observa en 'self.led = Pin(...)', donde nuestra clase 
   utiliza internamente otra clase para funcionar.
3. HERENCIA SIMPLE: 'TorreLed' hereda la estructura de 'Led'. Al ser una 
   clase hija, puede usar o extender las capacidades del padre.
4. CICLO DE VIDA: 
   - El CONSTRUCTOR __ini__()reserva memoria e inicializa atributos.
   - El DESTRUCTOR __del__() libera recursos (apaga el hardware) antes de que el 
     objeto desaparezca.
   - Representación textual __str__() define qué texto mostrar al hacer print(objeto)  
     no afecta la memoria, solo la representación visible del objeto.
"""