# ############################################################################
# **    Proyecto       : Manejo de Semaforo con POO Composición
# **    Herramienta    : https://www.wokwi.com        
# **    Compilador     : wokwi Simulador online
# **    Version        : 1.0
# **    Fecha/Hora     : 1-10-2024, 3:45 am, 
# **    
# **   Descripción del programa :      
# **         Este programa simula el funcionamiento de 2 semaforos en un cruce 
# **         vehicular, se utiliza programacion Orientada a Objetos (POO)
# **         y el concepto de composicion 
# ** 
# **   Versión        : 1
# **   Revisión       : A
# **   Release        : 0
# **   Bugs & Fixes   :
# **   Date           : 1/10/2024
# **   
# **   By             : Jorge Anzaldo    
# **   contact        : [email protected]
# **   twitter x      : @janzaldob
#############################################################################

# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# :                       Librerias / Bibliotecas / Modulos                      |                            :
# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

from machine import Pin     
import time                 

# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# |                    Definición y Desarrollo de Clases                     |
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Led:
    def __init__(self, pin):
        self.pin = Pin(pin, Pin.OUT)
        print(f'Objeto {self} construido') 

    def mensaje(self, texto):
        print(texto)

    def prender(self, tiempoPrendido=1, tiempoApagado=0):      
        self.pin.value(1)
        time.sleep(tiempoPrendido)
        if tiempoApagado != 0:
            self.pin.value(0)
            time.sleep(tiempoApagado)

    def apagar(self, tiempo=0):
        self.pin.value(0)
        time.sleep(tiempo)

    def pausar(self, tiempo):
        time.sleep(tiempo)

    def parpadear(self, iteraciones=3):
        for i in range(iteraciones):
            self.prender(0.2, 0.2)

    def __str__(self):
        return f'Led {self.pin}'

    def __del__(self):
        self.apagar()
        print(f"Objeto {self} destruido")

class Semaforo:
    def __init__(self, pin_rojo, pin_amarillo, pin_verde):
        # Creación de los LEDs internos (composición)
        self._ledR = Led(pin_rojo)
        self._ledA = Led(pin_amarillo)
        self._ledV = Led(pin_verde)
        print(f'Objeto {self} construido')

    def funcionar(self):
        self._ledR.prender(3)
        self._ledA.prender(1)
        self._ledV.prender(3)
        self._ledV.parpadear()

    def __str__(self):
        return f'Semaforo ({self._ledR}, {self._ledA}, {self._ledV})'
    
    def __del__(self):
        # No necesitamos eliminar los LEDs manualmente, Python lo hará
        print(f"Objeto {self} destruido")

class SistemaSemaforo:
    def __init__(self, pins_semaforo1, pins_semaforo2):
        # Creación de los semáforos internos (composición)
        self._s1 = Semaforo(*pins_semaforo1)
        self._s2 = Semaforo(*pins_semaforo2)
        print(f'Objeto {self} construido')

    def sincronizar(self, t1, t2, t3):
        self._s1._ledR.prender(0.1, 0)
        self._s2._ledV.prender(0.1, 0)
        self._s1._ledR.pausar(t1)
        self._s2._ledV.apagar()
        self._s2._ledA.prender(0.1, 0)
        self._s2._ledR.pausar(t2)
        self._s2._ledA.parpadear(5)
        self._s1._ledR.apagar()
        self._s1._ledV.prender(0.1, 0)
        self._s2._ledR.prender(0.1, 0)
        self._s2._ledR.pausar(t3)
        self._s1._ledV.apagar()
        self._s1._ledA.prender(0.1, 0)
        self._s2._ledR.pausar(t2)
        self._s1._ledA.parpadear(5)
        self._s1._ledR.apagar()
        self._s2._ledR.apagar()

    def __str__(self):
        return f'SistemaSemaforo [{self._s1}, {self._s2}]'
    
    def __del__(self):
        print(f"Objeto {self} destruido")

# +-------------------------------------------------------------------------------
# |                        V A R I A B L E S                                      |
# +-------------------------------------------------------------------------------

config_semaforo1 = (18, 17, 16)  # (rojo, amarillo, verde)
config_semaforo2 = (27, 26, 25)  # (rojo, amarillo, verde)

sistema = SistemaSemaforo(config_semaforo1, config_semaforo2)

# ===============================================================================
# ||                                                                            ||
# ||        P R O G R A M A / F U N C I O N    P R I N C I P A L                ||
# ||                                                                            ||
# =============================================================================== 
if __name__ == '__main__':    
    while True:
        sistema.sincronizar(5, 2, 5)

# ********************************************************************************
#                                                                           
#                   R E F E R E N C I A S  / C O M E N T A R I O S  
#
#                        ***  Composición :  ***
#
#
# La composición se refiere a la forma en que una clase puede contener instancias de otras clases 
# como parte de su estado. En lugar de heredar de una clase base, una clase puede tener uno o más 
# objetos de otras clases como atributos. Esto permite construir estructuras más complejas de manera 
# más flexible y modular.
# 
# Ventajas 
# Reutilización de Código: Puedes reutilizar clases existentes sin depender de una jerarquía de herencia.
# Flexibilidad: Cambiar la implementación de una clase es más fácil, ya que no afecta a las clases que la utilizan.
# Menor Acoplamiento: Reduce la dependencia entre clases, lo que facilita el mantenimiento y las pruebas.  
#                                                                       
# *********************************************************************************