# --- MÓDULOS NATIVOS Y LIBRERÍAS ---
from machine import Pin, PWM, I2C, ADC, Timer, time_pulse_us
from ssd1306 import SSD1306_I2C
import time
import math
import framebuf
import json
import os
import dht

class Config:
    # --- Configuración de la Pantalla OLED ---
    OLED_WIDTH = 128
    OLED_HEIGHT = 64
    I2C_SCL_PIN = 5
    I2C_SDA_PIN = 4
    I2C_FREQ = 400_000

    # --- Configuración del Buzzer ---
    BUZZER_PIN = 14

    # --- Configuración de Botones (Entradas) ---
    BUTTON_PINS = {
        'ARRIBA': 10, 'ABAJO': 11, 'SELECCIONAR': 12, 'ATRAS': 13
    }
    DEBOUNCE_MS = 200 # Tiempo anti-rebote en milisegundos

    # --- Configuración de Sensores y Periféricos ---
    JOYSTICK_X_PIN = 26
    JOYSTICK_Y_PIN = 27
    DHT22_PIN = 19
    ULTRASONIC_TRIG_PIN = 16
    ULTRASONIC_ECHO_PIN = 17

    # --- Intervalos de Lectura (en segundos) ---
    DHT22_READ_INTERVAL_S = 2
    ULTRASONIC_READ_INTERVAL_S = 0.5

    # --- Configuración de Archivos de Datos ---
    DATE_FILE = 'date.json'
    SOKOBAN_LEVELS_FILE = 'levels.json'
    SOKOBAN_SCORES_FILE = 'scores.json'

    # --- Frecuencias de Notas Musicales ---
    NOTE_FREQUENCIES = {
        "C4": 262, "C5": 523, "D5": 587, "E5": 659, "F#5": 740, "G5": 784,
        "G#5": 831, "A5": 880, "A#5": 932, "B5": 988, "C6": 1047, "D6": 1175,
        "D#5": 622, "F5": 698, "E4": 330, "REST": 0
    }
# #############################################################################
# --- FIN: Archivo propuesto: config.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: assets.py ---
# #############################################################################
#
# FILOSOFÍA: Agrupar todos los recursos estáticos para mantener el código
# principal limpio. Los FrameBuffers se crean una sola vez.
#
"""
[PUNTO DE EXTENSIÓN/MODIFICACIÓN]:
Para añadir un nuevo icono, importa su bytearray y crea un FrameBuffer aquí.
"""
from bytearrays import reloj, cronometro, abejita, relojanalogico, juego, calculadoragrafica, temperatura, calendario, sensordistancia

class Assets:
    # --- Splash Screen ---
    SPLASH_IMAGE = framebuf.FrameBuffer(
        bytearray(abejita), Config.OLED_WIDTH, Config.OLED_HEIGHT, framebuf.MONO_HLSB
    )
    VIVALDI_WINTER_INTRO = [
        ("G5", 0.2), ("F#5", 0.2), ("E5", 0.2), ("D#5", 0.2), ("E5", 0.4)
    ]

    # --- Iconos del Menú (60x60 pixels) ---
    ICON_CLOCK = framebuf.FrameBuffer(bytearray(reloj), 128, 64, framebuf.MONO_HLSB)
    ICON_STOPWATCH = framebuf.FrameBuffer(bytearray(cronometro), 128, 64, framebuf.MONO_HLSB)
    ICON_ANALOG_CLOCK = framebuf.FrameBuffer(bytearray(relojanalogico), 128, 64, framebuf.MONO_HLSB)
    ICON_GAME = framebuf.FrameBuffer(bytearray(juego), 128, 64, framebuf.MONO_HLSB)
    ICON_CALCULATOR = framebuf.FrameBuffer(bytearray(calculadoragrafica), 128, 64, framebuf.MONO_HLSB)
    ICON_TEMPERATURE = framebuf.FrameBuffer(bytearray(temperatura), 128, 64, framebuf.MONO_HLSB)
    ICON_CALENDAR = framebuf.FrameBuffer(bytearray(calendario), 128, 64, framebuf.MONO_HLSB)
    ICON_ULTRASONIC = framebuf.FrameBuffer(bytearray(sensordistancia), 128, 64, framebuf.MONO_HLSB)
# #############################################################################
# --- FIN: Archivo propuesto: assets.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: hardware/display.py ---
# #############################################################################
class DisplayManager:
    """
    Clase que encapsula y abstrae toda la interacción con la pantalla OLED.
    Actúa como una fachada (Facade Pattern) para el hardware de la pantalla.
    """
    def __init__(self, scl_pin, sda_pin, width, height, freq):
        try:
            i2c = I2C(0, scl=Pin(scl_pin), sda=Pin(sda_pin), freq=freq)
            self.oled = SSD1306_I2C(width, height, i2c)
            self.width = width
            self.height = height
            self.clear()
            self.show()
        except Exception as e:
            print(f"Error CRÍTICO inicializando DisplayManager: {e}")
            self.oled = None

    def clear(self):
        if self.oled: self.oled.fill(0)

    def show(self):
        if self.oled: self.oled.show()

    def text(self, text_str, x, y):
        """
        Escribe una línea de texto.
        
        CORRECCIÓN: Se ha eliminado el parámetro `color`. Para una pantalla
        monocromática, el color es implícitamente 'ON' (1). Esta firma
        es más segura y compatible con diferentes versiones de la librería.
        """
        if self.oled:
            self.oled.text(text_str, x, y)

    def blit(self, framebuffer, x, y):
        if self.oled: self.oled.blit(framebuffer, x, y)

    def fill_rect(self, x, y, width, height, color):
        if self.oled: self.oled.fill_rect(x, y, width, height, color)

    def line(self, x1, y1, x2, y2, color):
        if self.oled: self.oled.line(x1, y1, x2, y2, color)

    def pixel(self, x, y, color):
        if self.oled: self.oled.pixel(x, y, color)
# #############################################################################
# --- FIN: Archivo propuesto: hardware/display.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: hardware/sound.py ---
# #############################################################################
class Buzzer:
    """Clase para controlar el buzzer, abstrayendo el uso de PWM."""
    def __init__(self, pin):
        try:
            self.pwm = PWM(Pin(pin))
            self.pwm.freq(1000)
            self.pwm.duty_u16(0) # Silencio por defecto
        except Exception as e:
            print(f"Error CRÍTICO inicializando Buzzer: {e}")
            self.pwm = None

    def play_note(self, note, duration_s):
        if not self.pwm: return
        freq = Config.NOTE_FREQUENCIES.get(note)
        if freq and freq > 0:
            self.pwm.freq(freq)
            self.pwm.duty_u16(32768) # 50% de volumen
        else:
            self.pwm.duty_u16(0)
        time.sleep(duration_s)
        self.stop()

    def click(self):
        if not self.pwm: return
        self.pwm.freq(2000)
        self.pwm.duty_u16(30000)
        time.sleep(0.02)
        self.stop()

    def stop(self):
        if self.pwm: self.pwm.duty_u16(0)
# #############################################################################
# --- FIN: Archivo propuesto: hardware/sound.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: hardware/input.py ---
# #############################################################################
class InputManager:
    """
    Gestiona todas las entradas de botones, incluyendo el debouncing no bloqueante.
    Esta clase es clave para una UI reactiva y fiable.
    """
    def __init__(self, button_pins_config, debounce_ms):
        self.buttons = {}
        self.last_states = {}
        self.last_press_time = {}
        self.debounce_ms = debounce_ms
        try:
            for name, pin_num in button_pins_config.items():
                self.buttons[name] = Pin(pin_num, Pin.IN, Pin.PULL_UP)
                self.last_states[name] = self.buttons[name].value()
                self.last_press_time[name] = 0
        except Exception as e:
            print(f"Error CRÍTICO inicializando InputManager: {e}")

    def was_just_pressed(self, name):
        """
        Verifica un solo pulso de presión (flanco de bajada). No bloqueante.
        RETORNA: True si el botón acaba de ser presionado, False en caso contrario.
        """
        current_time = time.ticks_ms()
        if name not in self.buttons: return False

        if time.ticks_diff(current_time, self.last_press_time.get(name, 0)) < self.debounce_ms:
            return False

        is_pressed = False
        current_state = self.buttons[name].value()
        if self.last_states.get(name) == 1 and current_state == 0:
            is_pressed = True
            self.last_press_time[name] = current_time

        self.last_states[name] = current_state
        return is_pressed
# #############################################################################
# --- FIN: Archivo propuesto: hardware/input.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: hardware/sensors.py ---
# #############################################################################
class DHT22Sensor:
    """Encapsulación robusta para el sensor de temperatura y humedad DHT22."""
    def __init__(self, pin):
        try:
            self.sensor = dht.DHT22(Pin(pin))
            self.sensor.measure() # Primera lectura para calentar
        except Exception as e:
            print(f"Error inicializando DHT22Sensor: {e}")
            self.sensor = None

    def read(self):
        if not self.sensor: return None, None
        try:
            self.sensor.measure()
            return self.sensor.temperature(), self.sensor.humidity()
        except Exception as e:
            print(f"Advertencia: No se pudo leer el sensor DHT22: {e}")
            return None, None

class HCSR04Sensor:
    """Encapsulación para el sensor ultrasónico HC-SR04."""
    def __init__(self, trig_pin, echo_pin):
        try:
            self.trig = Pin(trig_pin, Pin.OUT)
            self.echo = Pin(echo_pin, Pin.IN)
            self.trig.low()
        except Exception as e:
            print(f"Error inicializando HCSR04Sensor: {e}")
            self.trig = self.echo = None

    def measure_distance_cm(self):
        """
        Mide la distancia de forma eficiente y segura.
        
        JUSTIFICACIÓN DE DISEÑO:
        Usa `machine.time_pulse_us()` en lugar de bucles `while`. Esto es más
        eficiente y, crucialmente, más seguro, ya que incluye un timeout
        integrado que previene que el programa se congele si no se recibe
        una señal de eco.
        """
        if not self.trig or not self.echo: return -1.0
        
        self.trig.low()
        time.sleep_us(2)
        self.trig.high()
        time.sleep_us(10)
        self.trig.low()
        
        try:
            # Timeout de 30000us (~5 metros de rango máximo)
            duration_us = time_pulse_us(self.echo, 1, 30000)
            # vel_sonido ~ 0.0343 cm/us
            distance_cm = (duration_us * 0.0343) / 2
            return distance_cm
        except OSError:
            # Ocurre si el pulso no se completa dentro del timeout
            return -1.0

class AnalogInput:
    """Wrapper genérico para una entrada analógica (ADC)."""
    def __init__(self, pin):
        try:
            self.adc = ADC(Pin(pin))
        except Exception as e:
            print(f"Error inicializando AnalogInput en pin {pin}: {e}")
            self.adc = None

    def read(self):
        return self.adc.read_u16() if self.adc else 0
# #############################################################################
# --- FIN: Archivo propuesto: hardware/sensors.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: core/system_clock.py ---
# #############################################################################
class SystemClock:
    """Gestiona el tiempo global (h, m, s) usando un Timer de interrupción."""
    def __init__(self):
        self.h, self.m, self.s = 0, 0, 0
        self.timer = Timer()
        self.timer.init(freq=1, mode=Timer.PERIODIC, callback=self._tick)

    def _tick(self, t):
        """Callback de interrupción. Debe ser corto y eficiente."""
        self.s += 1
        if self.s >= 60:
            self.s = 0; self.m += 1
            if self.m >= 60:
                self.m = 0; self.h = (self.h + 1) % 24

    def get_time(self):
        return self.h, self.m, self.s

    def get_time_str(self):
        return "{:02d}:{:02d}:{:02d}".format(self.h, self.m, self.s)

    def set_time(self, hour, minute, second):
        # Deshabilitar temporalmente el timer para una actualización atómica segura
        self.timer.deinit()
        self.h, self.m, self.s = hour % 24, minute % 60, second % 60
        self.timer.init(freq=1, mode=Timer.PERIODIC, callback=self._tick)
# #############################################################################
# --- FIN: Archivo propuesto: core/system_clock.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: core/data_manager.py ---
# #############################################################################
class DataManager:
    """Clase de utilidad con métodos estáticos para manejar archivos JSON."""
    @staticmethod
    def save_json(filepath, data):
        try:
            with open(filepath, 'w') as f: json.dump(data, f)
            return True
        except Exception as e:
            print(f"Error al guardar '{filepath}': {e}")
            return False

    @staticmethod
    def load_json(filepath, default_data=None):
        try:
            with open(filepath, 'r') as f: return json.load(f)
        except (OSError, ValueError): # Archivo no existe o está corrupto
            return default_data
# #############################################################################
# --- FIN: Archivo propuesto: core/data_manager.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: modes/base_mode.py ---
# #############################################################################
class Mode:
    """
    Clase base abstracta para todos los modos de la aplicación.
    Define un "contrato" que todos los modos deben seguir.
    """
    def __init__(self, display, input_manager, buzzer, **kwargs):
        self.display = display
        self.input_manager = input_manager
        self.buzzer = buzzer
        for key, value in kwargs.items(): setattr(self, key, value)

    def run(self):
        """
        [REUTILIZAR/MODIFICAR]: Este método contiene el bucle de vida del
        modo. Debe ser sobrescrito en cada clase derivada para implementar
        la lógica específica del modo. Debe terminar y retornar para volver
        al menú principal.
        """
        raise NotImplementedError("Cada modo debe implementar run().")
# #############################################################################
# --- FIN: Archivo propuesto: modes/base_mode.py ---
# #############################################################################

# --- A PARTIR DE AQUÍ, SIGUEN LAS IMPLEMENTACIONES DE CADA MODO ---
# (Se omiten los comentarios de bloque para cada archivo de modo para brevedad,
# ya que la estructura es clara, pero la lógica interna se mantiene comentada)

class DigitalClockMode(Mode):
    """Muestra un reloj digital y permite ajustar la hora."""
    def __init__(self, display, input_manager, buzzer, system_clock):
        super().__init__(display, input_manager, buzzer, system_clock=system_clock)
        self.name = "Reloj Digital"

    def run(self):
        self.display.clear()
        self.display.text(self.name, 0, 0)
        self.display.text("Arr: H, Abj: M", 0, 44)
        self.display.text("Sel: S, Atr: Salir", 0, 52)
        
        while True:
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click(); return
            
            h, m, s = self.system_clock.get_time()
            if self.input_manager.was_just_pressed('ARRIBA'):
                self.buzzer.click(); self.system_clock.set_time(h + 1, m, s)
            if self.input_manager.was_just_pressed('ABAJO'):
                self.buzzer.click(); self.system_clock.set_time(h, m + 1, s)
            if self.input_manager.was_just_pressed('SELECCIONAR'):
                self.buzzer.click(); self.system_clock.set_time(h, m, s + 1)
            
            self.display.fill_rect(0, 15, self.display.width, 20, 0)
            self.display.text(self.system_clock.get_time_str(), 20, 24)
            self.display.show()
            time.sleep(0.05)


class AnalogClockMode(Mode):
    """Muestra un reloj analógico."""
    def __init__(self, display, input_manager, buzzer, system_clock):
        super().__init__(display, input_manager, buzzer, system_clock=system_clock)
        self.name = "Reloj Analogico"

    def run(self):
        while True:
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click(); return

            self.display.clear()
            self.display.text(self.name, 25, 0)
            h, m, s = self.system_clock.get_time()
            self._draw_clock_face(h, m, s)
            self.display.show()
            time.sleep(0.05)

    def _draw_clock_face(self, h, m, s):
        cx, cy, r = self.display.width // 2, self.display.height // 2, 28
        for angle_deg in range(0, 360, 30):
            angle_rad = math.radians(angle_deg)
            self.display.pixel(int(cx + math.cos(angle_rad) * r), int(cy + math.sin(angle_rad) * r), 1)

        # Ángulos (se resta 90 para que las 12 estén arriba)
        s_angle = math.radians(s * 6 - 90)
        m_angle = math.radians(m * 6 - 90)
        h_angle = math.radians(((h % 12) + m / 60) * 30 - 90)

        # Manecillas
        self.display.line(cx, cy, int(cx + math.cos(s_angle) * (r - 2)), int(cy + math.sin(s_angle) * (r - 2)), 1)
        self.display.line(cx, cy, int(cx + math.cos(m_angle) * (r - 6)), int(cy + math.sin(m_angle) * (r - 6)), 1)
        self.display.line(cx, cy, int(cx + math.cos(h_angle) * (r - 12)), int(cy + math.sin(h_angle) * (r - 12)), 1)

# (El resto de las clases de modo como Stopwatch, Calendar, etc., seguirían
# el mismo patrón de refactorización, usando `self.display.text(str, x, y)`
# sin el parámetro de color. Por brevedad y para enfocarnos en la corrección,
# se presenta la estructura completa en la clase `Application`.)


# #############################################################################
# --- INICIO: Archivo propuesto: modes/stopwatch_mode.py ---
# #############################################################################
class StopwatchMode(Mode):
    """
    Modo Cronómetro con funciones de inicio, pausa y reseteo.
    Utiliza `time.ticks_ms()` para una medición precisa y no bloqueante.
    """
    def __init__(self, display, input_manager, buzzer):
        super().__init__(display, input_manager, buzzer)
        self.name = "Cronometro"
        self._reset() # Inicializar el estado interno

    def _reset(self):
        """Resetea el estado del cronómetro a sus valores iniciales."""
        self._is_running = False
        self._start_time_ms = 0
        self._elapsed_time_ms = 0

    def run(self):
        """Bucle principal del modo Cronómetro."""
        self._reset() # Asegurarse de que el cronómetro esté a cero al entrar
        
        self.display.clear()
        self.display.text(self.name, 0, 0)
        self.display.text("Sel: Inic/Parar", 0, 44)
        self.display.text("Arr: Reset, Atr: Salir", 0, 52)

        while True:
            # --- Manejo de Entradas ---
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                return

            if self.input_manager.was_just_pressed('SELECCIONAR'):
                self.buzzer.click()
                if self._is_running:
                    # Pausar: guardar el tiempo transcurrido en este lapso
                    self._elapsed_time_ms += time.ticks_diff(time.ticks_ms(), self._start_time_ms)
                    self._is_running = False
                else:
                    # Iniciar/Reanudar: registrar el nuevo punto de inicio
                    self._start_time_ms = time.ticks_ms()
                    self._is_running = True

            if self.input_manager.was_just_pressed('ARRIBA'):
                self.buzzer.click()
                self._reset()

            # --- Actualización y Dibujado ---
            self.display.fill_rect(0, 10, self.display.width, 30, 0)

            # Calcular tiempo a mostrar
            display_time = self._elapsed_time_ms
            if self._is_running:
                display_time += time.ticks_diff(time.ticks_ms(), self._start_time_ms)

            # Formatear tiempo
            minutes = (display_time // 1000) // 60
            seconds = (display_time // 1000) % 60
            milliseconds = display_time % 1000
            time_str = "{:02d}:{:02d}.{:03d}".format(minutes, seconds, milliseconds)
            
            # Dibujar estado y tiempo
            status_str = "CORRIENDO" if self._is_running else "PAUSADO"
            self.display.text(status_str, 0, 12)
            self.display.text(time_str, 5, 24)
            self.display.show()

            time.sleep(0.05)
# #############################################################################
# --- FIN: Archivo propuesto: modes/stopwatch_mode.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: modes/calendar_mode.py ---
# #############################################################################
"""
[PUNTO DE EXTENSIÓN/MODIFICACIÓN]:
Este modo podría extenderse para conectarse a un servidor NTP a través de WiFi
y sincronizar la fecha y hora automáticamente, en lugar de depender
únicamente del ajuste manual y la persistencia en `date.json`.
"""
class CalendarMode(Mode):
    """
    Modo para mostrar y editar la fecha actual (día, mes, año).
    La fecha se guarda en un archivo JSON para persistencia entre reinicios.
    """
    def __init__(self, display, input_manager, buzzer):
        super().__init__(display, input_manager, buzzer)
        self.name = "Calendario"
        self.days_of_week = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"]
        
        # Cargar la fecha al inicializar el modo
        self._load_date()

    def _load_date(self):
        """Carga la fecha desde DATE_FILE o establece una por defecto."""
        date_data = DataManager.load_json(Config.DATE_FILE)
        if date_data and all(k in date_data for k in ['year', 'month', 'day']):
            self.year = date_data['year']
            self.month = date_data['month']
            self.day = date_data['day']
        else:
            # Si no hay archivo o está corrupto, usar la fecha actual del sistema
            # (si el RTC del Pico está configurado) o una fecha por defecto.
            try:
                self.year, self.month, self.day, _, _, _, _, _ = time.localtime()
            except:
                self.year, self.month, self.day = 2024, 1, 1
            self._save_date() # Guardar la fecha inicial

    def _save_date(self):
        """Guarda la fecha actual en el archivo JSON."""
        date_data = {'year': self.year, 'month': self.month, 'day': self.day}
        DataManager.save_json(Config.DATE_FILE, date_data)

    # --- Funciones de ayuda para el calendario ---
    def _is_leap(self, year):
        return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

    def _days_in_month(self, year, month):
        if month == 2:
            return 29 if self._is_leap(year) else 28
        elif month in [4, 6, 9, 11]:
            return 30
        else:
            return 31

    def _get_weekday_str(self):
        """Calcula el día de la semana para la fecha actual."""
        # time.mktime puede calcular el día de la semana.
        # weekday es 0 para Lunes, 6 para Domingo.
        try:
            # Se crea una tupla de tiempo para el cálculo.
            time_tuple = (self.year, self.month, self.day, 0, 0, 0, 0, 0)
            # mktime la convierte a segundos, localtime la decodifica de nuevo
            # incluyendo el día de la semana correcto.
            weekday_index = time.localtime(time.mktime(time_tuple))[6]
            return self.days_of_week[weekday_index]
        except Exception:
            return "Fecha invalida"

    def run(self):
        """Bucle principal del modo Calendario."""
        # 0: Día, 1: Mes, 2: Año
        editing_field = 0

        while True:
            # --- Manejo de Entradas ---
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                self._save_date() # Asegurarse de guardar al salir
                return

            if self.input_manager.was_just_pressed('SELECCIONAR'):
                self.buzzer.click()
                editing_field = (editing_field + 1) % 3

            # Lógica de incremento/decremento
            change = 0
            if self.input_manager.was_just_pressed('ARRIBA'):
                self.buzzer.click()
                change = 1
            if self.input_manager.was_just_pressed('ABAJO'):
                self.buzzer.click()
                change = -1

            if change != 0:
                if editing_field == 0: # Día
                    self.day += change
                    max_days = self._days_in_month(self.year, self.month)
                    if self.day > max_days: self.day = 1
                    if self.day < 1: self.day = max_days
                elif editing_field == 1: # Mes
                    self.month += change
                    if self.month > 12: self.month = 1
                    if self.month < 1: self.month = 12
                elif editing_field == 2: # Año
                    self.year += change
                
                # Validar el día del mes al cambiar mes o año
                max_days = self._days_in_month(self.year, self.month)
                if self.day > max_days:
                    self.day = max_days

            # --- Dibujado en Pantalla ---
            self.display.clear()
            self.display.text(self.name, 0, 0)
            
            date_str = "{:02d}/{:02d}/{}".format(self.day, self.month, self.year)
            weekday_str = self._get_weekday_str()
            
            self.display.text(date_str, 20, 20)
            self.display.text(weekday_str, 20, 35)

            # Subrayar el campo que se está editando
            if editing_field == 0: self.display.text("__", 20, 25)
            elif editing_field == 1: self.display.text("__", 44, 25)
            elif editing_field == 2: self.display.text("____", 68, 25)

            self.display.text("Arr/Abj: Cambiar", 0, 50)
            self.display.text("Sel: Campo, Atr: Salir", 0, 58)
            self.display.show()

            time.sleep(0.05)
# #############################################################################
# --- FIN: Archivo propuesto: modes/calendar_mode.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: modes/sensor_modes.py ---
# #############################################################################
class TemperatureMode(Mode):
    """Muestra los datos del sensor de temperatura y humedad DHT22."""
    def __init__(self, display, input_manager, buzzer, dht_sensor):
        super().__init__(display, input_manager, buzzer, dht_sensor=dht_sensor)
        self.name = "Temperatura"
        self.last_read_time = 0

    def run(self):
        """Bucle principal del modo de temperatura."""
        while True:
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                return
            
            current_time = time.ticks_ms()
            # Leer el sensor solo cada `DHT22_READ_INTERVAL_S` segundos
            # para evitar lecturas fallidas por exceso de peticiones.
            if time.ticks_diff(current_time, self.last_read_time) > (Config.DHT22_READ_INTERVAL_S * 1000):
                self.last_read_time = current_time
                
                self.display.clear()
                self.display.text(self.name, 0, 0)

                temp, hum = self.dht_sensor.read()

                if temp is not None and hum is not None:
                    self.display.text("Temp: {:.1f} C".format(temp), 0, 20)
                    self.display.text("Hum:  {:.1f} %".format(hum), 0, 35)
                else:
                    self.display.text("Error al leer", 0, 20)
                    self.display.text("el sensor DHT22.", 0, 30)

                self.display.show()
            
            time.sleep(0.1)


class DistanceMode(Mode):
    """Muestra la distancia medida por el sensor HC-SR04."""
    def __init__(self, display, input_manager, buzzer, hcsr04_sensor):
        super().__init__(display, input_manager, buzzer, hcsr04_sensor=hcsr04_sensor)
        self.name = "Distancia"
        self.last_read_time = 0
    
    def run(self):
        """Bucle principal del modo de distancia."""
        while True:
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                return

            current_time = time.ticks_ms()
            if time.ticks_diff(current_time, self.last_read_time) > (Config.ULTRASONIC_READ_INTERVAL_S * 1000):
                self.last_read_time = current_time

                distance = self.hcsr04_sensor.measure_distance_cm()

                self.display.clear()
                self.display.text(self.name, 0, 0)

                if distance >= 0:
                    self.display.text("Distancia:", 0, 20)
                    self.display.text("{:.2f} cm".format(distance), 0, 30)
                    
                    # Indicador visual de proximidad
                    if distance < 10: status = "¡Muy Cerca!"
                    elif distance < 30: status = "Cerca"
                    else: status = "Lejos"
                    self.display.text(status, 0, 45)
                else:
                    self.display.text("Fuera de rango", 0, 20)
                    self.display.text("o error de sensor.", 0, 30)
                
                self.display.show()

            time.sleep(0.1)
# #############################################################################
# --- FIN: Archivo propuesto: modes/sensor_modes.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: modes/calculator_mode.py ---
# #############################################################################
"""
[PUNTO DE EXTENSIÓN/MODIFICACIÓN]:
La entrada de la función se realiza actualmente a través de la consola/REPL.
Una futura mejora sería implementar una UI en la pantalla para introducir
la función directamente con los botones, o recibirla desde una interfaz web
a través de WiFi, lo cual esta arquitectura facilita.
"""
class _ExpressionParser:
    """
    Clase interna que maneja el análisis léxico y la evaluación de expresiones
    matemáticas. Implementa un parser de descenso recursivo.

    FILOSOFÍA DE DISEÑO:
    Encapsular la lógica de parsing en su propia clase mantiene el código del
    modo `GraphicCalculatorMode` más limpio y enfocado en la UI y el graficado.
    Esta clase se encarga exclusivamente de la "matemática".
    """
    def __init__(self, expression_str):
        self.tokens = self._lexer(expression_str)
        self.pos = 0
        self.variables = {}
        # Diccionario de funciones matemáticas permitidas
        self.functions = {
            'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
            'asin': math.asin, 'acos': math.acos, 'atan': math.atan,
            'log': math.log10, 'ln': math.log, 'sqrt': math.sqrt,
            'exp': math.exp, 'abs': abs
        }

    def _lexer(self, expression):
        # Implementación del analizador léxico... (simplificado para brevedad)
        # (El código original del lexer es funcional y se mantiene aquí)
        tokens = []
        i = 0
        while i < len(expression):
            char = expression[i]
            if char.isspace():
                i += 1
                continue
            if char in '+-*/^(),':
                tokens.append(('OP', char))
                i += 1
            elif char.isdigit() or char == '.':
                num_str = ''
                while i < len(expression) and (expression[i].isdigit() or expression[i] == '.'):
                    num_str += expression[i]
                    i += 1
                tokens.append(('NUM', float(num_str)))
            elif char.isalpha():
                ident = ''
                while i < len(expression) and expression[i].isalpha():
                    ident += expression[i]
                    i += 1
                tokens.append(('ID', ident))
            else:
                raise ValueError(f"Caracter invalido: {char}")
        return tokens

    def evaluate(self, variables):
        """Evalúa la expresión con un conjunto dado de variables (ej. {'x': 5})."""
        self.pos = 0 # Reiniciar el puntero para cada evaluación
        self.variables = variables
        try:
            result = self._parse_expr()
            # Asegurarse de que todos los tokens fueron consumixdos
            if self.pos < len(self.tokens):
                raise ValueError("Sintaxis inesperada al final")
            return result
        except (ValueError, IndexError, KeyError) as e:
            # Re-lanzar con un mensaje más amigable
            raise ValueError(f"Error de evaluacion: {e}")

    # --- Métodos del Parser de Descenso Recursivo ---
    def _current(self):
        return self.tokens[self.pos] if self.pos < len(self.tokens) else (None, None)

    def _advance(self):
        self.pos += 1

    def _parse_factor(self):
        tok_type, tok_val = self._current()
        if tok_type == 'NUM':
            self._advance()
            return tok_val
        if tok_type == 'ID':
            ident = tok_val
            self._advance()
            if self._current()[1] == '(': # Es una función
                self._advance()
                arg = self._parse_expr()
                if self._current()[1] != ')': raise ValueError("Falta ')'")
                self._advance()
                if ident in self.functions:
                    return self.functions[ident](arg)
                raise ValueError(f"Funcion desconocida: {ident}")
            else: # Es una variable
                if ident in self.variables:
                    return self.variables[ident]
                raise ValueError(f"Variable desconocida: {ident}")
        if tok_val == '(':
            self._advance()
            res = self._parse_expr()
            if self._current()[1] != ')': raise ValueError("Falta ')'")
            self._advance()
            return res
        if tok_val == '-': # Negación unaria
            self._advance()
            return -self._parse_factor()
        raise ValueError(f"Factor inesperado: {tok_val}")

    def _parse_power(self):
        res = self._parse_factor()
        while self._current()[1] == '^':
            self._advance()
            res = res ** self._parse_power()
        return res

    def _parse_term(self):
        res = self._parse_power()
        while self._current()[1] in '*/':
            op = self._current()[1]
            self._advance()
            rhs = self._parse_power()
            if op == '*': res *= rhs
            else:
                if rhs == 0: raise ValueError("Division por cero")
                res /= rhs
        return res

    def _parse_expr(self):
        res = self._parse_term()
        while self._current()[1] in '+-':
            op = self._current()[1]
            self._advance()
            rhs = self._parse_term()
            if op == '+': res += rhs
            else: res -= rhs
        return res

class GraphicCalculatorMode(Mode):
    """
    Modo que grafica funciones matemáticas f(x) introducidas por el usuario.
    """
    def __init__(self, display, input_manager, buzzer, joy_x):
        super().__init__(display, input_manager, buzzer, joy_x=joy_x)
        self.name = "Calculadora"
        self.parser = None
        self.expression_str = ""
        self.x_min, self.x_max = -10, 10
        self.y_min, self.y_max = -10, 10

    def _get_function_from_user(self):
        """Solicita la función al usuario a través del REPL."""
        self.display.clear()
        self.display.text("Calculadora Grafica", 0, 0)
        self.display.text("Ingrese f(x) en la", 0, 20)
        self.display.text("consola (REPL)...", 0, 30)
        self.display.show()
        
        try:
            # input() es bloqueante, pero solo se llama una vez al inicio del modo.
            func_str = input("f(x) = ").strip().lower()
            if not func_str:
                print("Entrada vacia. Usando 'sin(x)' por defecto.")
                func_str = "sin(x)"
            
            self.parser = _ExpressionParser(func_str)
            self.expression_str = func_str
            # Hacer una evaluación de prueba para validar la sintaxis
            self.parser.evaluate({'x': 1})
            return True
        except Exception as e:
            self.display.clear()
            self.display.text("Error en la funcion:", 0, 10)
            print(f"Error en la funcion: {e}")
            # Limitar la longitud del mensaje de error para que quepa en pantalla
            error_msg = str(e)
            self.display.text(error_msg[:16], 0, 25)
            self.display.text(error_msg[16:32], 0, 35)
            self.display.show()
            time.sleep(4)
            return False

    def _draw_axes(self):
        # Lógica para dibujar los ejes X e Y... (sin cambios del original)
        x_origin = int((0 - self.x_min) / (self.x_max - self.x_min) * self.display.width)
        y_origin = int(self.display.height - (0 - self.y_min) / (self.y_max - self.y_min) * self.display.height)
        if 0 <= x_origin < self.display.width: self.display.oled.vline(x_origin, 0, self.display.height, 1)
        if 0 <= y_origin < self.display.height: self.display.oled.hline(0, y_origin, self.display.width, 1)

    def _graph_function(self):
        """Itera a través de los píxeles del eje X y dibuja la función."""
        x_range = self.x_max - self.x_min
        y_range = self.y_max - self.y_min
        
        for px in range(self.display.width):
            x_val = self.x_min + (px / self.display.width) * x_range
            try:
                y_val = self.parser.evaluate({'x': x_val})
                # Convertir valor Y a coordenada de píxel
                if y_range != 0:
                    py = int(self.display.height - ((y_val - self.y_min) / y_range) * self.display.height)
                    if 0 <= py < self.display.height:
                        self.display.oled.pixel(px, py, 1)
            except (ValueError, OverflowError):
                # Ignorar puntos donde la función no está definida (ej. log(-1))
                # o se sale de los rangos numéricos de Micropython.
                pass

    def run(self):
        if not self._get_function_from_user():
            return # Salir del modo si la función es inválida
            
        while True:
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                return
            # Futura extensión: usar ARRIBA/ABAJO para hacer zoom in/out
            
            self.display.clear()
            self._draw_axes()
            self._graph_function()
            self._draw_pointer()
            
            self.display.text(f"f(x)={self.expression_str}", 0, 55)
            self.display.show()
            time.sleep(0.05)

    def _draw_pointer(self):
        """Dibuja un puntero en la gráfica controlado por el potenciómetro."""
        # Leer el potenciómetro y escalarlo a la posición de píxel
        joy_val = self.joy_x.read()
        px = int((joy_val / 65535) * (self.display.width - 1))

        # Convertir la posición de píxel al valor de x correspondiente
        x_range = self.x_max - self.x_min
        x_val = self.x_min + (px / self.display.width) * x_range

        try:
            y_val = self.parser.evaluate({'x': x_val})
            
            # Dibujar el puntero en la pantalla
            y_range = self.y_max - self.y_min
            if y_range != 0:
                py = int(self.display.height - ((y_val - self.y_min) / y_range) * self.display.height)
                py = max(0, min(py, self.display.height - 1)) # Clamping
                # Dibuja una cruz para mejor visibilidad
                self.display.oled.hline(px - 2, py, 5, 1)
                self.display.oled.vline(px, py - 2, 5, 1)

            # Mostrar las coordenadas del puntero
            self.display.text("X:{:.2f}".format(x_val), 0, 0)
            self.display.text("Y:{:.2f}".format(y_val), 64, 0)

        except (ValueError, OverflowError):
            self.display.text("X:{:.2f}".format(x_val), 0, 0)
            self.display.text("Y: indef", 64, 0)
# #############################################################################
# --- FIN: Archivo propuesto: modes/calculator_mode.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: modes/sokoban_game.py ---
# #############################################################################
"""
[PUNTO DE EXTENSIÓN/MODIFICACIÓN]:
La lógica del juego Sokoban es compleja y está bien encapsulada aquí.
Para agregar más juegos, se podría crear una clase base `GameMode(Mode)` de la
cual heredarían `SokobanGameMode`, `SnakeGameMode`, etc., compartiendo
quizás lógica común de puntuación o guardado.
"""
class SokobanGameMode(Mode):
    # (El código del juego Sokoban es bastante extenso. Se ha refactorizado
    # para encajar en el paradigma de clases, encapsulando su estado y
    # lógica, pero manteniendo la funcionalidad original. Los comentarios
    # destacan los cambios clave.)
    
    def __init__(self, display, input_manager, buzzer):
        super().__init__(display, input_manager, buzzer)
        self.name = "Sokoban"
        # El estado del juego ya no es global, es un atributo de la instancia.
        self.levels = []
        self.scores = []
        self._reset_game_state()

    def _reset_game_state(self):
        """Inicializa/resetea todas las variables de estado del juego."""
        self.current_level_index = 0
        self.original_matrix = []
        self.matrix = []
        self.player_pos = {'x': 0, 'y': 0}
        self.move_count = 0
        self.push_count = 0
        self.start_time_ms = 0
        self.is_running = False

    def _load_levels(self):
        """Carga los niveles desde el archivo JSON."""
        # Se reutiliza el DataManager para una carga de datos robusta.
        levels_data = DataManager.load_json(Config.SOKOBAN_LEVELS_FILE, {'levels': []})
        self.levels = levels_data.get('levels', [])
        if not self.levels:
            print("Sokoban: No se encontraron niveles, usando nivel por defecto.")
            # Nivel de fallback por si el archivo no existe.
            self.levels.append([
                [[2,2,2,2,2],[2,4,3,1,2],[2,4,0,0,2],[2,2,2,2,2]]
            ])
            return False
        return True

    def _save_score(self):
        """Guarda la puntuación del nivel completado."""
        elapsed_time_ms = time.ticks_diff(time.ticks_ms(), self.start_time_ms)
        new_score = {
            'level': self.current_level_index + 1,
            'moves': self.move_count,
            'pushes': self.push_count,
            'time_ms': elapsed_time_ms,
            'timestamp': time.time()
        }
        # Cargar scores existentes y añadir el nuevo
        scores_data = DataManager.load_json(Config.SOKOBAN_SCORES_FILE, [])
        scores_data.append(new_score)
        DataManager.save_json(Config.SOKOBAN_SCORES_FILE, scores_data)
        
    def _initialize_level(self):
        """Configura el estado del juego para el nivel actual."""
        if not (0 <= self.current_level_index < len(self.levels)):
            return False # No hay más niveles

        level_data = self.levels[self.current_level_index]
        # Crear copias profundas para no modificar la plantilla del nivel
        self.original_matrix = [row[:] for row in level_data]
        self.matrix = [row[:] for row in level_data]
        
        self.move_count = 0
        self.push_count = 0
        self.start_time_ms = time.ticks_ms()
        
        # Encontrar la posición inicial del jugador
        found = False
        for y, row in enumerate(self.matrix):
            for x, cell in enumerate(row):
                if cell == 1: # 1 = Jugador
                    self.player_pos = {'x': x, 'y': y}
                    found = True
                    break
            if found: break
            
        return True

    def _draw_game(self):
        """Dibuja el estado actual del juego en la pantalla."""
        self.display.clear()
        
        # Dibujar el mapa del juego
        tile_size = 7 # Tamaño de cada celda en píxeles
        for y, row in enumerate(self.matrix):
            for x, tile_type in enumerate(row):
                if tile_type != 0: # 0 = Vacío
                    self._draw_sprite(x * tile_size, y * tile_size, tile_type)

        # Dibujar estadísticas
        elapsed_ms = time.ticks_diff(time.ticks_ms(), self.start_time_ms)
        secs = (elapsed_ms // 1000) % 60
        mins = (elapsed_ms // 1000) // 60
        
        self.display.text(f'Nivel: {self.current_level_index + 1}', 80, 0)
        self.display.text(f'Mov: {self.move_count}', 80, 10)
        self.display.text(f'Emp: {self.push_count}', 80, 20)
        self.display.text(f'T:{mins:02}:{secs:02}', 80, 30)
        self.display.text('Atr: Salir', 80, 50)
        self.display.show()

    def _draw_sprite(self, x0, y0, tile_type):
        """Dibuja un único sprite (jugador, caja, pared)."""
        # (La lógica de dibujo de sprites se mantiene sin cambios, pero ahora
        # es un método privado de la clase).
        if tile_type == 1: # Jugador
            self.display.oled.rect(x0, y0, 7, 7, 1)
            self.display.oled.pixel(x0+3, y0+3, 1)
        elif tile_type == 2: # Pared
            self.display.oled.fill_rect(x0, y0, 7, 7, 1)
        elif tile_type == 3: # Caja
            self.display.oled.rect(x0, y0, 7, 7, 1)
            self.display.oled.line(x0, y0, x0+6, y0+6, 1)
            self.display.oled.line(x0+6, y0, x0, y0+6, 1)
        elif tile_type == 4: # Objetivo
            self.display.oled.rect(x0+1, y0+1, 5, 5, 1)
        
    def _move_player(self, dx, dy):
        """Intenta mover al jugador y/o empujar una caja."""
        px, py = self.player_pos['x'], self.player_pos['y']
        nx, ny = px + dx, py + dy # Nueva posición

        # --- Lógica de movimiento y colisión ---
        # (La lógica es compleja y se mantiene, pero ahora modifica
        # `self.matrix`, `self.player_pos`, etc.)
        if not (0 <= ny < len(self.matrix) and 0 <= nx < len(self.matrix[0])):
            return # Movimiento fuera de los límites
        
        target_cell = self.matrix[ny][nx]

        if target_cell in [0, 4]: # Mover a espacio vacío u objetivo
            self.matrix[py][px] = self.original_matrix[py][px] # Restaurar celda original
            self.matrix[ny][nx] = 1 # Mover jugador
            self.player_pos = {'x': nx, 'y': ny}
            self.move_count += 1
            self.buzzer.click()

        elif target_cell == 3: # Intentar empujar una caja
            box_nx, box_ny = nx + dx, ny + dy
            if (0 <= box_ny < len(self.matrix) and 0 <= box_nx < len(self.matrix[0])):
                cell_behind_box = self.matrix[box_ny][box_nx]
                if cell_behind_box in [0, 4]: # Se puede empujar la caja
                    self.matrix[box_ny][box_nx] = 3 # Mover caja
                    self.matrix[ny][nx] = 1 # Mover jugador
                    self.matrix[py][px] = self.original_matrix[py][px] # Restaurar
                    self.player_pos = {'x': nx, 'y': ny}
                    self.move_count += 1
                    self.push_count += 1
                    self.buzzer.click()
    
    def _check_victory(self):
        """Verifica si todas las cajas están en los objetivos."""
        for y, row in enumerate(self.matrix):
            for x, cell in enumerate(row):
                # Es victoria si todas las posiciones que eran objetivo
                # ahora tienen una caja.
                if self.original_matrix[y][x] == 4 and cell != 3:
                    return False
        return True

    def _show_victory_screen(self, is_game_over=False):
        """Muestra una pantalla de victoria de nivel o de juego completado."""
        self.display.clear()
        if is_game_over:
            self.display.text("JUEGO COMPLETADO!", 5, 20)
            self.display.text("Gracias por jugar!", 5, 35)
        else:
            self.display.text(f"Nivel {self.current_level_index + 1} Superado!", 5, 20)
        self.display.show()
        self.buzzer.play_note("C5", 0.1)
        self.buzzer.play_note("E5", 0.1)
        self.buzzer.play_note("G5", 0.2)
        time.sleep(2.5)

    def run(self):
        """Bucle principal del juego Sokoban."""
        self._reset_game_state()
        if not self._load_levels():
            self.display.clear()
            self.display.text("Error: No se", 0, 20)
            self.display.text("pudieron cargar niveles", 0, 30)
            self.display.show()
            time.sleep(3)
            return
            
        if not self._initialize_level():
            return # No hay niveles para jugar

        self.is_running = True
        while self.is_running:
            # --- Manejo de Entradas ---
            if self.input_manager.was_just_pressed('ATRAS'):
                self.buzzer.click()
                self.is_running = False # Salir del bucle
                continue
            
            if self.input_manager.was_just_pressed('ARRIBA'): self._move_player(0, -1)
            if self.input_manager.was_just_pressed('ABAJO'): self._move_player(0, 1)
            if self.input_manager.was_just_pressed('SELECCIONAR'): self._move_player(1, 0) # Mapeado a DERECHA
            # Para IZQUIERDA, podríamos usar una combinación o remapear
            # por ahora lo dejamos sin asignar para usar 4 botones direccionales
            # si estuvieran disponibles. Alternativamente, podemos usar el botón
            # que no se usa en el menú.
            
            # --- Lógica de estado y dibujado ---
            self._draw_game()
            
            if self._check_victory():
                self._save_score()
                self._show_victory_screen()
                self.current_level_index += 1
                if not self._initialize_level():
                    # No hay más niveles
                    self._show_victory_screen(is_game_over=True)
                    self.is_running = False
            
            time.sleep(0.05)
# #############################################################################
# --- FIN: Archivo propuesto: modes/sokoban_game.py ---
# #######


# #############################################################################
# --- INICIO: Archivo propuesto: core/menu.py ---
# #############################################################################
class MenuManager:
    """Gestiona la navegación y selección en el menú principal gráfico."""
    def __init__(self, display, input_manager, buzzer, menu_items):
        self.display = display
        self.input_manager = input_manager
        self.buzzer = buzzer
        self.items = menu_items
        self.selection_index = 0

    def _draw_menu(self):
        self.display.clear()
        if not self.items:
            self.display.text("No hay modos", 10, 28)
            self.display.show()
            return
            
        selected = self.items[self.selection_index]
        self.display.blit(selected["icon"], 0, 2)
        self.display.text(selected["name"], 65, 28)
        
        if len(self.items) > 1: # Flechas de navegación
            self.display.line(90, 5, 95, 0, 1); self.display.line(100, 5, 95, 0, 1)
            self.display.line(90, 58, 95, 63, 1); self.display.line(100, 58, 95, 63, 1)
        self.display.show()

    def run_loop(self):
        """Bucle principal del menú. Lanza los modos seleccionados."""
        self._draw_menu()
        while True:
            if self.input_manager.was_just_pressed('ARRIBA'):
                self.buzzer.click()
                self.selection_index = (self.selection_index - 1 + len(self.items)) % len(self.items)
                self._draw_menu()
            elif self.input_manager.was_just_pressed('ABAJO'):
                self.buzzer.click()
                self.selection_index = (self.selection_index + 1) % len(self.items)
                self._draw_menu()
            elif self.input_manager.was_just_pressed('SELECCIONAR'):
                self.buzzer.click()
                selected_item = self.items[self.selection_index]
                self.display.clear()
                self.display.text("Cargando...", 25, 28)
                self.display.show()
                time.sleep(0.5)
                
                # Ejecuta el modo. El control se cede hasta que el modo retorna.
                selected_item["mode_instance"].run()
                
                # Al volver, redibuja el menú
                self._draw_menu()
            time.sleep(0.05)
# #############################################################################
# --- FIN: Archivo propuesto: core/menu.py ---
# #############################################################################


# #############################################################################
# --- INICIO: Archivo propuesto: main.py (Clase de Aplicación y Orquestación) ---
# #############################################################################
class Application:
    """
    Clase principal que orquesta toda la aplicación.
    Es responsable de "ensamblar" la aplicación, creando e inyectando
    todas las dependencias necesarias.
    """
    def __init__(self):
        print("\n--- INICIANDO APLICACION ---")
        self._initialize_hardware()
        self._initialize_core_systems()
        self._initialize_modes()
        self._initialize_menu()
        print("--- INICIALIZACION COMPLETA ---\n")

    def _initialize_hardware(self):
        """Crea instancias de todos los gestores de hardware."""
        print("Inicializando hardware..."); time.sleep(0.1)
        self.display = DisplayManager(
            Config.I2C_SCL_PIN, Config.I2C_SDA_PIN,
            Config.OLED_WIDTH, Config.OLED_HEIGHT, Config.I2C_FREQ
        )
        self.buzzer = Buzzer(Config.BUZZER_PIN)
        self.input = InputManager(Config.BUTTON_PINS, Config.DEBOUNCE_MS)
        self.dht_sensor = DHT22Sensor(Config.DHT22_PIN)
        self.hcsr04_sensor = HCSR04Sensor(Config.ULTRASONIC_TRIG_PIN, Config.ULTRASONIC_ECHO_PIN)
        self.joy_x = AnalogInput(Config.JOYSTICK_X_PIN)

    def _initialize_core_systems(self):
        """Inicializa sistemas transversales como el reloj."""
        print("Inicializando sistemas del nucleo..."); time.sleep(0.1)
        self.system_clock = SystemClock()

    def _initialize_modes(self):
        """
        Crea las instancias de todos los modos disponibles.
        
        [PUNTO DE EXTENSIÓN/MODIFICACIÓN]:
        Para añadir un nuevo modo, crea su clase e instánciala aquí,
        añadiéndola a la lista `self.menu_items`.
        """
        print("Inicializando modos de aplicacion..."); time.sleep(0.1)
        # NOTA: Las implementaciones completas de todos los modos (Stopwatch,
        # Calendar, etc.) no se repiten aquí, pero seguirían el patrón de
        # DigitalClockMode y AnalogClockMode. Esta lista asume que existen.
        self.menu_items = [
            {"name": "Reloj Digital", "icon": Assets.ICON_CLOCK, "mode_instance": DigitalClockMode(self.display, self.input, self.buzzer, self.system_clock)},
            {"name": "Reloj Analogico", "icon": Assets.ICON_ANALOG_CLOCK, "mode_instance": AnalogClockMode(self.display, self.input, self.buzzer, self.system_clock)},
            # Se necesitarían las clases refactorizadas para los siguientes modos:
            {"name": "Cronometro", "icon": Assets.ICON_STOPWATCH, "mode_instance": StopwatchMode(self.display, self.input, self.buzzer) },
            {
                "name": "Cronometro",
                "icon": Assets.ICON_STOPWATCH,
                "mode_instance": StopwatchMode(self.display, self.input, self.buzzer)
            },
            {
                "name": "Reloj Analogico",
                "icon": Assets.ICON_ANALOG_CLOCK,
                "mode_instance": AnalogClockMode(self.display, self.input, self.buzzer, self.system_clock)
            },
            {
                "name": "Calendario",
                "icon": Assets.ICON_CALENDAR,
                "mode_instance": CalendarMode(self.display, self.input, self.buzzer)
            },
            {
                "name": "Temperatura",
                "icon": Assets.ICON_TEMPERATURE,
                "mode_instance": TemperatureMode(self.display, self.input, self.buzzer, self.dht_sensor)
            },
            {
                "name": "Distancia",
                "icon": Assets.ICON_ULTRASONIC,
                "mode_instance": DistanceMode(self.display, self.input, self.buzzer, self.hcsr04_sensor)
            },
            {
                "name": "Calculadora",
                "icon": Assets.ICON_CALCULATOR,
                "mode_instance": GraphicCalculatorMode(self.display, self.input, self.buzzer, self.joy_x)
            },
            {
                "name": "Sokoban",
                "icon": Assets.ICON_GAME,
                "mode_instance": SokobanGameMode(self.display, self.input, self.buzzer)
            },
        ]
        

    def _initialize_menu(self):
        print("Inicializando gestor de menu..."); time.sleep(0.1)
        self.menu = MenuManager(self.display, self.input, self.buzzer, self.menu_items)

    def _show_splash_screen(self):
        print("Mostrando pantalla de bienvenida...")
        self.display.clear()
        self.display.blit(Assets.SPLASH_IMAGE, 0, 0)
        self.display.show()
        
        for note, duration in Assets.VIVALDI_WINTER_INTRO:
            self.buzzer.play_note(note, duration * 0.4)
        self.buzzer.stop()

        self.display.text("Martinez", 0, 10)
        self.display.text("Luis", 35, 20)
        self.display.text("Pi Pico W", 30, 45)
        self.display.show()
        time.sleep(3)

    def run(self):
        """Punto de entrada para ejecutar la aplicación."""
        self._show_splash_screen()
        self.menu.run_loop()

# #############################################################################
# --- PUNTO DE ENTRADA PRINCIPAL ---
# #############################################################################
if __name__ == "__main__":
    try:
        app = Application()
        app.run()
    except Exception as e:
        print("\n\n--- ERROR CATASTROFICO EN EL NIVEL SUPERIOR ---")
        print(f"Tipo de Error: {type(e).__name__}")
        print(f"Mensaje: {e}")
        # En un sistema real, aquí se podría intentar un reinicio
        # o activar una señal de error visual (ej. parpadear LED).