# ############################################################################
# **   Proyecto       : Clase Componente, Led Semaforo, RGB, Torreta
# **   Herramienta    : https://www.wokwi.com        
# **                   : Thonny aplicacion de escritorio descargar en www.thonny.org
# **   Compilador     : wokwi Simulador online
# **   Version        : 1.0
# **   Fecha/Hora     : 19-05-2026, 5:55 am, 
# **    
# **   Descripción del programa :
# **         Programa prende y apaga un Led, Semaforo Torreta, Led RGB, 
# **         la clase base es componentes donde los pines son los argumentos 
# **         de que inicializan el constructor, se utiliza programación Orientada a Objetos 
# **         (POO) - Concurrencia con Hilos (Threads)
# **      
# ** 
# **   Versión        : 1
# **   Revisión       : A
# **   Release        : 0
# **   Bugs & Fixes   :
# **   Date           : 08/11/2024
# **   
# **   By             : Jorge Anzaldo    
# **   contact        : [email protected]
# **   twitter x      : @janzaldob
#############################################################################

# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# :                       Bibliotecas / Modulos                      |                            :
# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
                
import _thread
from classLed import Led
from classLed import Semaforo
from classLed import Torreta
from classLed import RGB

class Hilo:
    """
    Clase de Alta Abstracción encargada de administrar la concurrencia.
    Aplica el principio de encapsulamiento al empaquetar la colección de 
    componentes y automatizar su lanzamiento multihilo.
    """
    def __init__(self, *componentes):
        # Recibe N cantidad de objetos y los almacena en una lista interna
        self._componentes = list(componentes)

    def _ciclo_componente(self, componente):
        """Método interno que ejecuta el ciclo infinito polimórfico de un componente."""
        while True:
            componente.prender()
            componente.apagar()

    def iniciar(self):
        """
        Recorre la lista interna de componentes y lanza un hilo 
        independiente para cada uno, logrando un desacoplamiento total.
        """
        for comp in self._componentes:
            # Se pasa el componente actual como argumento al hilo
            _thread.start_new_thread(self._ciclo_componente, (comp,))

# +-------------------------------------------------------------------------------
# |              V A R I A B L E S  G L O B A L E S   U   O B J E T O S          |
# +-------------------------------------------------------------------------------
# 1. Instanciación independiente de los componentes de hardware
led_interno= Led(2) 
semaforo    = Semaforo(21, 19, 18)
torreta     = Torreta(4, 15,13, 12, 14, 27, 26, 25)
rgb         = RGB(5, 17, 16) 

# 2. Inyección de objetos directo al constructor del Gestor de Hilos
hilos_sistema = Hilo(semaforo, torreta, rgb)

# ===============================================================================
# ||                                                                            ||
# ||        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__': 
    
    led_interno.mensaje("Iniciando el sistema concurrente automatizado...")
    
    # Un solo método se encarga de la iteración y la creación de hilos de fondo
    hilos_sistema.iniciar()
    
    print("Hilos de fondo activos. Entrando al ciclo del hilo principal.")
    
    # Hilo Principal (Main Thread): Mantiene el control del LED Testigo
    while True:
        led_interno.parpadear()

        

# ********************************************************************************
#                                                                           
#        R E F E R E N C I A S  / C O M E N T A R I O S  
#
# CONCURRENCIA :
# la concurrencia se refiere a la capacidad de ejecutar varias tareas de manera 
# "simultánea" o "aparentemente simultánea", con el objetivo de mejorar la eficiencia 
# y el rendimiento de un programa, especialmente en situaciones donde hay muchas 
# operaciones de I/O (entrada/salida) que podrían estar bloqueando la ejecución del 
# programa, como leer y escribir archivos, hacer peticiones HTTP, interactuar con 
# bases de datos, etc.
# 
# Es importante entender que la concurrencia en Python no significa necesariamente 
# ejecución paralela en todos los casos, sino más bien una forma de organizar 
# las tareas de modo que puedan progresar sin esperar a que una tarea termine para 
# comenzar la siguiente.
#
# Formas de lograr concurrencia en Python:
#
# Hilos (Threads): Python proporciona el módulo threading para trabajar con hilos. 
# Un hilo es un proceso liviano que se ejecuta dentro de un proceso. 
# Cada hilo tiene su propio flujo de control, pero comparten el mismo espacio 
# de memoria. Esto significa que los hilos son útiles para tareas concurrentes, 
# pero no necesariamente para tareas intensivas en CPU, ya que debido al Global 
# Interpreter Lock (GIL) en CPython, solo un hilo puede ejecutar código Python en 
# un momento dado (aunque operaciones de I/O pueden ejecutarse en paralelo).
                                                                        
# *********************************************************************************