main.py

# ============================================================================
# MAIN.PY - PSIC-O-TRONIC
# Motor principal del juego
# ============================================================================

import time
import gc
import network
import ujson
from machine import Pin, I2C

# Módulos propios
from lcd_chars import load_custom_chars, convert_text, get_lives_display, wrap_text
from config import (
    is_wifi_configured, get_wifi_config, load_stats, get_stats_summary,
    clear_wifi_config
)
from wifi_portal import run_wifi_portal, connect_saved_wifi
from gemini_api import get_oracle
from game_modes import GameSession, InitialsInput, MODE_CLASSIC, MODE_SURVIVAL
from audio import init_audio, play as play_sound

# Sistema OTA
try:
    from ota_update import ota_manager, reboot as ota_reboot
    OTA_AVAILABLE = True
except ImportError:
    OTA_AVAILABLE = False
    print("[MAIN] OTA no disponible")

# Hardware
from i2c_lcd import I2cLcd

# ============================================================================
# CONFIGURACIÓN HARDWARE
# ============================================================================

PIN_BTN_UP = 4
PIN_BTN_SELECT = 5
PIN_BTN_DOWN = 6
PIN_LED_UP = 7
PIN_LED_SELECT = 15
PIN_LED_DOWN = 16
PIN_LED_NOTIFY = 17
PIN_SPEAKER = 9
PIN_I2C_SDA = 1
PIN_I2C_SCL = 2

# Timing
FRAME_DELAY = 0.08
DEBOUNCE_MS = 280

# ============================================================================
# ESTADOS DEL JUEGO
# ============================================================================

class State:
    BOOT = 0
    FIRST_TIME_WELCOME = 1
    WIFI_CHECK = 2
    WIFI_PORTAL = 3
    INTRO = 4
    MENU = 5
    MODE_SELECT = 6
    PLAYER_SELECT = 7
    QUOTA_SELECT = 8
    STORY_INTRO = 9
    PASS_DEVICE = 10
    FETCHING = 11
    MESSAGE_ANIM = 12
    READING = 13
    CHOOSING = 14
    FEEDBACK = 15
    CHAPTER_COMPLETE = 16
    INITIALS_INPUT = 17
    GAME_OVER = 18
    STATS = 19
    HOW_TO_PLAY = 20
    WIFI_SETTINGS = 21
    CREDITS = 22
    PAUSE = 23
    ERROR = 24
    # OTA Updates
    OTA_CHECK = 25
    OTA_INFO = 26
    OTA_UPDATING = 27
    OTA_RESULT = 28
    OTA_POPUP = 29  # Popup automático de actualización disponible
    OTA_AUTO_CHECK = 30  # Verificación automática al inicio

# ============================================================================
# CLASE PRINCIPAL
# ============================================================================

class PsicOTronic:
    """Motor principal del juego PSIC-O-TRONIC"""

    def __init__(self):
        # Cargar versión desde version.json
        self.version = self._load_version()

        print("\n" + "="*40)
        print(f"  PSIC-O-TRONIC v{self.version}")
        print("="*40)

        # Inicializar hardware
        self._init_gpio()
        self._init_lcd()
        self._init_audio()

        # Estado
        self.state = State.BOOT
        self.prev_state = -1
        self.frame = 0
        
        # Menús
        self.menu_idx = 0
        self.mode_idx = 0
        self.player_count = 1
        self.quota_idx = 2  # Default: 5 casos
        self.quota_options = [3, 5, 7, 10, 15, 999]
        self.help_page = 0
        
        # Sesión de juego
        self.session = None
        self.oracle = get_oracle()
        
        # Para scroll de texto
        self.opt_scroll = 0

        # Para mostrar respuesta correcta al fallar
        self.correct_answer_text = ""
        self.feedback_scroll_idx = 0
        self.feedback_lines = []

        # Input de iniciales
        self.initials_input = None
        
        # LED blinking
        self.blink_counter = 0
        self.blink_state = False
        
        # Estado antes de pausa
        self.pre_pause_state = None
        
        # Manejo de errores
        self.error_msg = ""
        self.error_detail = ""
        self.error_scroll = 0
        self.error_menu_idx = 0

        # OTA automático al inicio
        self._ota_checked_on_boot = False
        self._ota_popup_dismissed = False  # Si el usuario ya rechazó en esta sesión
        
        # Buffer LCD para evitar flickering
        self.lcd_buffer = [[' ' for _ in range(20)] for _ in range(4)]
        self.lcd_shadow = [[' ' for _ in range(20)] for _ in range(4)]

    def _load_version(self):
        """Carga la versión desde version.json"""
        try:
            with open('/version.json', 'r') as f:
                data = ujson.load(f)
                return data.get('version', '1.0')
        except:
            return '1.0'  # Fallback si no se puede leer

    def _init_gpio(self):
        """Inicializa pines GPIO"""
        print("[INIT] GPIO...")
        
        self.btn_up = Pin(PIN_BTN_UP, Pin.IN, Pin.PULL_UP)
        self.btn_select = Pin(PIN_BTN_SELECT, Pin.IN, Pin.PULL_UP)
        self.btn_down = Pin(PIN_BTN_DOWN, Pin.IN, Pin.PULL_UP)
        
        self.led_up = Pin(PIN_LED_UP, Pin.OUT)
        self.led_select = Pin(PIN_LED_SELECT, Pin.OUT)
        self.led_down = Pin(PIN_LED_DOWN, Pin.OUT)
        self.led_notify = Pin(PIN_LED_NOTIFY, Pin.OUT)
        
        self._leds_off()
        print("[INIT] GPIO OK")
    
    def _init_audio(self):
        """Inicializa sistema de audio"""
        print("[INIT] Audio...")
        self.audio = init_audio(PIN_SPEAKER)
        print("[INIT] Audio OK")
    
    def _init_lcd(self):
        """Inicializa LCD"""
        print("[INIT] LCD...")
        
        i2c = I2C(1, sda=Pin(PIN_I2C_SDA), scl=Pin(PIN_I2C_SCL), freq=400000)
        devs = i2c.scan()
        
        if not devs:
            print("[ERROR] No LCD found!")
            while True:
                self.led_notify.value(1)
                time.sleep(0.1)
                self.led_notify.value(0)
                time.sleep(0.1)
        
        self.lcd = I2cLcd(i2c, devs[0], 4, 20)
        load_custom_chars(self.lcd)
        self.lcd.clear()
        print(f"[INIT] LCD OK @ {hex(devs[0])}")
    
    def _leds_off(self):
        """Apaga todos los LEDs"""
        self.led_up.value(0)
        self.led_select.value(0)
        self.led_down.value(0)
        self.led_notify.value(0)
    
    def _leds_menu(self):
        """LEDs para navegación de menú"""
        self.led_up.value(1)
        self.led_down.value(1)
        self.led_select.value(self.blink_state)
    
    def _leds_select_only(self):
        """Solo LED select parpadeando"""
        self.led_up.value(0)
        self.led_down.value(0)
        self.led_select.value(self.blink_state)
    
    def _leds_scroll(self, can_up, can_down):
        """LEDs para scroll"""
        self.led_up.value(1 if can_up else 0)
        self.led_down.value(1 if can_down else 0)
        self.led_select.value(self.blink_state)
    
    def _update_blink(self):
        """Actualiza estado de parpadeo"""
        self.blink_counter += 1
        if self.blink_counter >= 6:
            self.blink_counter = 0
            self.blink_state = not self.blink_state
    
    # === INPUT ===
    
    _last_btn_time = 0
    
    def _get_input(self):
        """Lee input de botones con debounce, incluyendo combo UP+DOWN para BACK"""
        now = time.ticks_ms()
        if time.ticks_diff(now, self._last_btn_time) < DEBOUNCE_MS:
            return None

        up_pressed = self.btn_up.value() == 0
        down_pressed = self.btn_down.value() == 0
        select_pressed = self.btn_select.value() == 0

        if not up_pressed and not down_pressed and not select_pressed:
            return None

        # Si UP o DOWN presionado, esperar para detectar combo
        if up_pressed or down_pressed:
            time.sleep(0.05)
            up_pressed = self.btn_up.value() == 0
            down_pressed = self.btn_down.value() == 0

            if up_pressed and down_pressed:
                self._last_btn_time = now
                return 'BACK'

        cmd = None
        if select_pressed:
            cmd = 'SELECT'
        elif up_pressed:
            cmd = 'UP'
        elif down_pressed:
            cmd = 'DOWN'

        if cmd:
            self._last_btn_time = now
        return cmd
    
    # === LCD HELPERS (CON BUFFER PARA EVITAR FLICKERING) ===
    
    def _lcd_clear_buffer(self):
        """Limpia el buffer (no la pantalla física)"""
        for y in range(4):
            for x in range(20):
                self.lcd_buffer[y][x] = ' '
    
    def _lcd_clear(self):
        """Limpia el buffer - alias para compatibilidad"""
        self._lcd_clear_buffer()
    
    def _lcd_put(self, x, y, text):
        """Escribe texto en el buffer"""
        if y < 0 or y >= 4:
            return
        safe = convert_text(text)
        for i, char in enumerate(safe):
            if 0 <= x + i < 20:
                self.lcd_buffer[y][x + i] = char
    
    def _lcd_centered(self, y, text):
        """Escribe texto centrado en el buffer"""
        safe = convert_text(text)
        x = max(0, (20 - len(safe)) // 2)
        self._lcd_put(x, y, safe)
    
    def _lcd_render(self):
        """Vuelca buffer a LCD físico, solo escribe lo que cambió"""
        for y in range(4):
            for x in range(20):
                if self.lcd_buffer[y][x] != self.lcd_shadow[y][x]:
                    self.lcd.move_to(x, y)
                    self.lcd.putchar(self.lcd_buffer[y][x])
                    self.lcd_shadow[y][x] = self.lcd_buffer[y][x]

    def _lcd_force_clear(self):
        """Limpia LCD físico completamente y sincroniza buffers"""
        self.lcd.clear()
        for y in range(4):
            for x in range(20):
                self.lcd_shadow[y][x] = ' '
                self.lcd_buffer[y][x] = ' '

    def _lcd_lines(self, lines):
        """Escribe múltiples líneas centradas"""
        self._lcd_clear_buffer()
        for i, line in enumerate(lines[:4]):
            self._lcd_centered(i, line)
        self._lcd_render()
    
    def _wrap_text(self, text, width=20):
        """Divide texto en lineas (delegado a lcd_chars.wrap_text)"""
        return wrap_text(text, width)
    
    # === EFECTOS ===
    
    def _effect_crt_intro(self):
        """Intro simple sin parpadeos"""
        self._lcd_clear()
        self._lcd_centered(0, "====================")
        self._lcd_centered(1, "  PSIC-O-TRONIC")
        self._lcd_centered(2, f"     ver {self.version}")
        self._lcd_centered(3, "====================")
    
    def _effect_message_alert(self):
        """Alerta de mensaje sin parpadeo"""
        self._lcd_clear()
        self._lcd_centered(0, "+------------------+")
        self._lcd_centered(1, "* MENSAJE ENTRANTE *")
        self._lcd_centered(2, "")
        self._lcd_centered(3, "+------------------+")
        self._lcd_render()
        self.led_notify.value(1)
        time.sleep(0.8)
        self.led_notify.value(0)
    
    # === ESTADOS DEL JUEGO ===
    
    def _update_boot(self, key):
        """Estado: Boot"""
        self._effect_crt_intro()
        time.sleep(1)

        # Verificar si necesita wipe por actualización
        from config import check_and_wipe_if_needed, file_exists
        wiped = check_and_wipe_if_needed()

        if wiped:
            # Si se hizo wipe, mostrar mensaje
            self._lcd_clear()
            self._lcd_centered(0, "ACTUALIZACION 2.3")
            self._lcd_centered(1, "Datos reseteados")
            self._lcd_centered(2, "Config limpia")
            time.sleep(3)

        # Detectar si es primera vez (no existe config.json)
        if not file_exists("/config.json"):
            self.state = State.FIRST_TIME_WELCOME
        else:
            self.state = State.WIFI_CHECK
    
    def _update_first_time_welcome(self, key):
        """Estado: Bienvenida primera vez"""
        # Inicializar página si no existe
        if not hasattr(self, '_welcome_page'):
            self._welcome_page = 0

        self._lcd_clear()

        # Mostrar pantalla según página actual
        if self._welcome_page == 0:
            # Pantalla 1: Bienvenida
            self._lcd_centered(0, "BIENVENIDO A")
            self._lcd_centered(1, "PSIC-O-TRONIC!")
            self._lcd_put(0, 3, "   [OK] Continuar")
        elif self._welcome_page == 1:
            # Pantalla 2: Instrucciones
            self._lcd_put(0, 0, "Primero debes")
            self._lcd_put(0, 1, "configurar:")
            self._lcd_put(0, 2, "1. Red WiFi")
            self._lcd_put(0, 3, "2. API de Gemini")
        elif self._welcome_page == 2:
            # Pantalla 3: Abrir portal
            self._lcd_put(0, 0, "Se abrira el Portal")
            self._lcd_put(0, 1, "Web de")
            self._lcd_put(0, 2, "configuracion.")
            self._lcd_put(0, 3, "   [OK] Abrir")

        self._leds_select_only()

        # Avanzar página al presionar SELECT
        if key == 'SELECT':
            self._welcome_page += 1
            if self._welcome_page > 2:
                # Ir al portal WiFi
                self.state = State.WIFI_PORTAL
                self._welcome_page = 0

    def _update_wifi_check(self, key):
        """Estado: Verificar WiFi"""
        self._lcd_lines([
            "Verificando",
            "conexión WiFi...",
            "",
            ""
        ])
        
        if is_wifi_configured():
            self._lcd_lines([
                "Conectando a",
                "red guardada...",
                "",
                ""
            ])
            
            success, result = connect_saved_wifi(timeout=10)
            
            if success:
                self._lcd_lines([
                    "WiFi conectado!",
                    f"IP: {result}",
                    "",
                    ""
                ])
                time.sleep(1)
                self.state = State.INTRO
            else:
                self._lcd_lines([
                    "Error conexión",
                    "Abriendo portal",
                    "de configuracion",
                    ""
                ])
                time.sleep(2)
                self.state = State.WIFI_PORTAL
        else:
            self.state = State.WIFI_PORTAL
    
    def _update_wifi_portal(self, key):
        """Estado: Portal cautivo WiFi"""
        def lcd_callback(lines):
            self._lcd_lines(lines)
        
        def check_cancel():
            return self.btn_select.value() == 0 and self.btn_up.value() == 0
        
        result = run_wifi_portal(lcd_callback=lcd_callback, check_button=check_cancel)
        
        if result and result.get("connected"):
            self._lcd_lines([
                "Configuración",
                "guardada!",
                "",
                "Reiniciando..."
            ])
            time.sleep(2)
            import machine
            machine.reset()
        else:
            self.state = State.INTRO
    
    def _update_intro(self, key):
        """Estado: Intro animada"""
        step = self.frame // 5

        if step < 8:
            self._lcd_clear()
            self._lcd_centered(0, "====================")
            self._lcd_centered(1, "  PSIC-O-TRONIC")
            self._lcd_centered(2, f"     ver {self.version}")

            # Barra de carga
            progress = min(20, step * 3)
            bar = chr(0) * progress + "." * (20 - progress)
            self._lcd_put(0, 3, bar)

            # LEDs secuenciales
            step_led = self.frame % 16
            self.led_up.value(1 if step_led < 4 else 0)
            self.led_select.value(1 if 4 <= step_led < 8 else 0)
            self.led_down.value(1 if 8 <= step_led < 12 else 0)
            self.led_notify.value(1 if step_led >= 12 else 0)
        else:
            self._leds_off()
            play_sound('boot')

            # Verificar actualizaciones si OTA está disponible y no se ha checkeado
            if OTA_AVAILABLE and not self._ota_checked_on_boot:
                self.state = State.OTA_AUTO_CHECK
            else:
                self.state = State.MENU
            self.menu_idx = 0
    
    def _update_menu(self, key):
        """Estado: Menú principal"""
        options = ["Jugar", "Estadisticas", "Como Jugar", "Abrir Portal Web"]

        # Añadir opción OTA si está disponible
        if OTA_AVAILABLE:
            if ota_manager.has_update():
                options.append("Actualizar [!]")
            else:
                options.append("Actualizar")

        options.append("Creditos")

        self._lcd_clear()
        self._lcd_centered(0, "== MENU ==")

        # Mostrar 3 opciones visibles
        start = max(0, min(self.menu_idx - 1, len(options) - 3))
        for i in range(3):
            idx = start + i
            if idx < len(options):
                prefix = ">" if idx == self.menu_idx else " "
                label = options[idx]
                if idx != self.menu_idx and len(label) > 18:
                    label = label[:17] + "~"
                else:
                    label = label[:18]
                self._lcd_put(1, i + 1, prefix + label)

        # Indicadores de scroll con LEDs
        can_up = self.menu_idx > 0
        can_down = self.menu_idx < len(options) - 1
        self._leds_scroll(can_up, can_down)
        
        if key == 'UP':
            self.menu_idx = (self.menu_idx - 1) % len(options)
            play_sound('click')
        elif key == 'DOWN':
            self.menu_idx = (self.menu_idx + 1) % len(options)
            play_sound('click')
        elif key == 'BACK':
            self.state = State.INTRO
            self.frame = 0
        elif key == 'SELECT':
            play_sound('beep')
            selected = options[self.menu_idx]
            if selected == "Jugar":
                self.state = State.MODE_SELECT
                self.mode_idx = 0
            elif selected == "Estadisticas":
                self.state = State.STATS
            elif selected == "Como Jugar":
                self.state = State.HOW_TO_PLAY
                self.help_page = 0
            elif selected == "Abrir Portal Web":
                self.state = State.WIFI_SETTINGS
            elif selected.startswith("Actualizar"):
                self.state = State.OTA_CHECK
                self.frame = 0
            elif selected == "Creditos":
                self.state = State.CREDITS
    
    def _update_mode_select(self, key):
        """Estado: Selección de modo"""
        modes = ["Clasico", "Survival", "Mi Consulta", "Volver"]

        self._lcd_clear()
        self._lcd_centered(0, "MODO DE JUEGO")

        # Mostrar 3 opciones visibles (líneas 1-3)
        # Calcular ventana de scroll
        if self.mode_idx < 2:
            start = 0
        elif self.mode_idx >= len(modes) - 1:
            start = max(0, len(modes) - 3)
        else:
            start = self.mode_idx - 1

        for row, i in enumerate(range(start, min(start + 3, len(modes)))):
            prefix = ">" if i == self.mode_idx else " "
            self._lcd_put(1, row + 1, f"{prefix}{modes[i]}")

        # Indicadores de scroll con LEDs
        can_up = self.mode_idx > 0
        can_down = self.mode_idx < len(modes) - 1
        self._leds_scroll(can_up, can_down)

        if key == 'UP' and can_up:
            self.mode_idx -= 1
        elif key == 'DOWN' and can_down:
            self.mode_idx += 1
        elif key == 'BACK':
            self.state = State.MENU
            self.menu_idx = 0
        elif key == 'SELECT':
            if self.mode_idx == 2:  # Mi Consulta
                self._launch_career_mode()
            elif self.mode_idx == 3:  # Volver al Menu
                self.state = State.MENU
                self.menu_idx = 0
            else:
                self.state = State.PLAYER_SELECT
    
    def _launch_career_mode(self):
        """Lanza el modo Mi Consulta"""
        from career_mode import run_career_mode
        run_career_mode(
            self.lcd,
            self.btn_up,
            self.btn_select,
            self.btn_down,
            self.led_up,
            self.led_select,
            self.led_down,
            self.led_notify
        )
        # Volver al menu principal - limpiar memoria
        self.state = State.MENU
        self.menu_idx = 0
        self.mode_idx = 0
        self.frame = 0
        self._lcd_force_clear()
        gc.collect()  # Liberar memoria del career mode
    
    def _update_player_select(self, key):
        """Estado: Selección de jugadores"""
        self._lcd_clear()
        self._lcd_centered(0, "JUGADORES")
        self._lcd_centered(1, f"<< {self.player_count} >>")
        self._lcd_put(0, 3, " [^v]Cambiar [OK]>")
        
        self._leds_menu()
        
        if key == 'UP' and self.player_count < 4:
            self.player_count += 1
        elif key == 'DOWN' and self.player_count > 1:
            self.player_count -= 1
        elif key == 'BACK':
            self.state = State.MODE_SELECT
        elif key == 'SELECT':
            mode = MODE_SURVIVAL if self.mode_idx == 1 else MODE_CLASSIC
            if mode == MODE_SURVIVAL:
                self._start_game(mode)
            else:
                self.state = State.QUOTA_SELECT
    
    def _update_quota_select(self, key):
        """Estado: Selección de cuota"""
        val = self.quota_options[self.quota_idx]
        val_str = "INFINITO" if val == 999 else str(val)
        
        self._lcd_clear()
        self._lcd_centered(0, "CASOS A RESOLVER")
        self._lcd_centered(1, f"<< {val_str} >>")
        self._lcd_put(0, 3, " [^v]Cambiar [OK]>")
        
        self._leds_menu()
        
        if key == 'UP':
            self.quota_idx = min(len(self.quota_options) - 1, self.quota_idx + 1)
        elif key == 'DOWN':
            self.quota_idx = max(0, self.quota_idx - 1)
        elif key == 'BACK':
            self.state = State.PLAYER_SELECT
        elif key == 'SELECT':
            self._start_game(MODE_CLASSIC)
    
    def _start_game(self, mode):
        """Inicia una nueva partida"""
        quota = self.quota_options[self.quota_idx] if mode == MODE_CLASSIC else 999
        self.session = GameSession(mode, self.player_count, quota)
        self.session.start()
        self.state = State.PASS_DEVICE
    
    def _update_story_intro(self, key):
        """Estado: Intro de capítulo (historia)

        NOTA: Este estado es parte del modo historia que está en desarrollo.
        Los métodos necesarios aún no están implementados en GameSession.
        """
        # TODO: Implementar get_chapter_intro() en GameSession
        # intro = self.session.get_chapter_intro()

        # Fallback temporal: mostrar mensaje genérico
        self._lcd_clear()
        self._lcd_centered(0, "MODO HISTORIA")
        self._lcd_centered(1, "En desarrollo")
        self._lcd_centered(2, "")
        self._lcd_centered(3, "[OK] Continuar")

        self._leds_select_only()

        if key == 'SELECT':
            self.state = State.PASS_DEVICE
    
    def _update_pass_device(self, key):
        """Estado: Pasar dispositivo"""
        player = self.session.get_current_player()
        
        self._lcd_clear()
        self._lcd_put(0, 0, self.session.get_status_line())
        self._lcd_centered(1, "TURNO DE")
        self._lcd_centered(2, f"JUGADOR {player['id']}")
        self._lcd_centered(3, "[OK] Conectar")
        
        self._leds_select_only()
        
        if key == 'SELECT':
            self.state = State.FETCHING
            self.frame = 0
    
    def _update_fetching(self, key):
        """Estado: Obteniendo caso"""
        # Mostrar animación
        antenna = ["^", "|", "/", "-", "\\", "|"][(self.frame // 4) % 6]
        dots = "." * ((self.frame // 6) % 4)
        
        self._lcd_clear()
        self._lcd_centered(0, "+------------------+")
        self._lcd_centered(1, f"  CONECTANDO  {antenna}")
        self._lcd_put(0, 2, f" Línea psiquiátrica{dots}"[:20])
        self._lcd_centered(3, "+------------------+")
        
        self.led_notify.value(self.blink_state)
        
        # Primera frame: hacer la petición
        if self.frame == 1:
            gc.collect()
            modifier = self.session.get_prompt_modifier()
            self.session.scenario = self.oracle.get_scenario(
                mode=self.session.mode,
                story_modifier=modifier
            )
            
            # Comprobar error
            if self.session.scenario is None:
                self.state = State.ERROR
                self.error_msg = self.oracle.last_error or "Error desconocido"
                self.error_detail = ""
                self.led_notify.value(0)
                return
            
            # Preparar texto con nuevo formato
            sender = self.session.scenario.get('remitente', 'Anónimo')
            msg = self.session.scenario.get('mensaje', 'Error')
            msg = msg.lstrip('!?¡¿ ')  # Quitar signos al inicio
            
            # Formato: DE: nombre + salto + MSG: texto
            header = f"DE: {sender}"
            body = f"MSG: {msg}"
            
            # Wrap del cuerpo del mensaje
            body_lines = self._wrap_text(body)
            self.session.scroll_lines = [header] + body_lines
            self.session.scroll_idx = 0
            
            self.state = State.MESSAGE_ANIM
            self.frame = 0
    
    def _update_message_anim(self, key):
        """Estado: Animación de mensaje simple"""
        step = self.frame // 4
        
        # Sonido al inicio
        if self.frame == 1:
            play_sound('mensaje')
        
        if step < 4:
            # Mostrar mensaje entrante
            self._lcd_clear()
            self._lcd_centered(0, "+------------------+")
            self._lcd_centered(1, "* MENSAJE ENTRANTE *")
            self._lcd_centered(3, "+------------------+")
            self.led_notify.value((self.frame // 3) % 2)
        else:
            self.led_notify.value(0)
            self.state = State.READING
            self.session.scroll_idx = 0
    
    def _update_reading(self, key):
        """Estado: Leyendo mensaje (4 líneas completas)"""
        # Detectar pausa (UP + DOWN a la vez)
        if self.btn_up.value() == 0 and self.btn_down.value() == 0:
            self.pre_pause_state = State.READING
            self.state = State.PAUSE
            return
        
        self._lcd_clear()
        
        # Mostrar 4 líneas visibles (aprovechando toda la pantalla)
        lines = self.session.scroll_lines
        idx = self.session.scroll_idx
        
        for i in range(4):
            if idx + i < len(lines):
                self._lcd_put(0, i, lines[idx + i])
        
        # Solo LEDs para indicar scroll (sin iconos en pantalla)
        can_up = idx > 0
        can_down = (idx + 4) < len(lines)
        
        self._leds_scroll(can_up, can_down)
        
        if key == 'UP' and can_up:
            self.session.scroll_idx -= 1
        elif key == 'DOWN' and can_down:
            self.session.scroll_idx += 1
        elif key == 'SELECT':
            self.state = State.CHOOSING
            self.session.selected_option = 0
            self.opt_scroll = 0
    
    def _update_choosing(self, key):
        """Estado: Eligiendo respuesta (4 opciones)"""
        # Detectar pausa (UP + DOWN a la vez)
        if self.btn_up.value() == 0 and self.btn_down.value() == 0:
            self.pre_pause_state = State.CHOOSING
            self.state = State.PAUSE
            return
        
        self._lcd_clear()
        
        opts = self.session.scenario.get('opciones', [])
        
        # Mostrar 4 opciones (una por línea)
        for i in range(min(4, len(opts))):
            text = convert_text(opts[i])
            prefix = ">" if i == self.session.selected_option else " "
            
            # Scroll horizontal para opcion larga (19 chars con prefijo)
            max_visible = 19
            if i == self.session.selected_option and len(text) > max_visible:
                wait_frames = 8
                scroll_speed = 3
                max_offset = len(text) - max_visible

                if self.opt_scroll < wait_frames:
                    offset = 0
                else:
                    offset = ((self.opt_scroll - wait_frames) // scroll_speed) % (max_offset + wait_frames)
                    if offset > max_offset:
                        offset = 0

                text = text[offset:offset + max_visible]
            else:
                if len(text) > max_visible:
                    text = text[:max_visible - 1] + "~"
                else:
                    text = text[:max_visible]

            self._lcd_put(0, i, "%s%s" % (prefix, text))
        
        can_up = self.session.selected_option > 0
        can_down = self.session.selected_option < len(opts) - 1
        self._leds_scroll(can_up, can_down)
        
        if key == 'UP' and can_up:
            self.session.selected_option -= 1
            self.opt_scroll = 0
        elif key == 'DOWN' and can_down:
            self.session.selected_option += 1
            self.opt_scroll = 0
        elif key == 'SELECT':
            # Manejo especial para error 403 (API key bloqueada)
            if self.session.scenario.get('tema_corto') == 'error_403':
                selected = self.session.selected_option
                if selected == 0:  # Abrir Portal Web
                    self.state = State.WIFI_SETTINGS
                elif selected == 1:  # Reintentar
                    self.state = State.FETCHING
                    self.frame = 0
                else:  # Volver al Menu
                    self.state = State.MENU
                    self.menu_idx = 0
            else:
                # Flujo normal del juego
                # Guardar respuesta correcta antes de procesar
                correct_idx = self.session.scenario.get('correcta', 0)
                opts = self.session.scenario.get('opciones', [])
                if 0 <= correct_idx < len(opts):
                    self.correct_answer_text = opts[correct_idx]
                else:
                    self.correct_answer_text = ""

                self.session.process_answer(self.session.selected_option)
                self.feedback_scroll_idx = 0
                self.state = State.FEEDBACK
                self.frame = 0
    
    def _update_feedback(self, key):
        """Estado: Mostrando feedback con scroll para textos largos"""
        blink = (self.frame // 4) % 2 == 0

        # Sonido al inicio
        if self.frame == 1:
            if self.session.last_result_ok:
                play_sound('correcto')
            else:
                play_sound('incorrecto')

        # Preparar líneas de contenido en primera frame
        if self.frame <= 1:
            self.feedback_lines = []
            self.feedback_scroll_idx = 0

            if self.session.last_result_ok:
                # ACIERTO: Título + feedback_win
                self.feedback_lines.append("== CORRECTO ==")
                self.feedback_lines.append("")
                fb_lines = self._wrap_text(self.session.last_feedback)
                self.feedback_lines.extend(fb_lines)
            else:
                # ERROR: Título + respuesta correcta + feedback_lose
                self.feedback_lines.append("== INCORRECTO ==")
                self.feedback_lines.append("")
                self.feedback_lines.append("Correcta era:")
                correct_lines = self._wrap_text(self.correct_answer_text)
                self.feedback_lines.extend(correct_lines)
                self.feedback_lines.append("")
                self.feedback_lines.append("Resultado:")
                fb_lines = self._wrap_text(self.session.last_feedback)
                self.feedback_lines.extend(fb_lines)

        self._lcd_clear()

        # LED de error parpadea
        if not self.session.last_result_ok:
            self.led_notify.value(blink)

        # Mostrar con scroll (3 líneas de contenido + 1 de controles)
        idx = self.feedback_scroll_idx
        for i in range(3):
            if idx + i < len(self.feedback_lines):
                self._lcd_centered(i, self.feedback_lines[idx + i])

        # Indicadores de scroll y continuar
        can_up = idx > 0
        can_down = (idx + 3) < len(self.feedback_lines)

        if can_up or can_down:
            arrows = ""
            if can_up:
                arrows += "[^]"
            if can_down:
                arrows += "[v]"
            self._lcd_put(0, 3, arrows)
            self._lcd_put(14, 3, "[OK]>")
            self._leds_scroll(can_up, can_down)
        else:
            self._lcd_centered(3, "[OK] Continuar")
            self._leds_select_only()

        # Manejar scroll
        if key == 'UP' and can_up:
            self.feedback_scroll_idx -= 1
            return
        elif key == 'DOWN' and can_down:
            self.feedback_scroll_idx += 1
            return
        
        if key == 'SELECT':
            self.led_notify.value(0)
            
            game_state = self.session.check_game_state()
            
            if game_state == "win":
                self.state = State.GAME_OVER
            # NOTA: chapter_complete está comentado porque el modo historia no está implementado
            # elif game_state == "chapter_complete":
            #     self.state = State.CHAPTER_COMPLETE
            elif game_state == "game_over":
                # Comprobar si es récord
                if self.session.mode == MODE_SURVIVAL:
                    stats = load_stats()
                    if self.session.total_score > stats.get("survival_record", 0):
                        self.initials_input = InitialsInput()
                        self.state = State.INITIALS_INPUT
                        return
                self.state = State.GAME_OVER
            else:
                if self.session.next_turn():
                    self.state = State.PASS_DEVICE
                else:
                    self.state = State.GAME_OVER
    
    def _update_chapter_complete(self, key):
        """Estado: Capítulo completado (historia)

        NOTA: Este estado es parte del modo historia que está en desarrollo.
        Los métodos necesarios aún no están implementados en GameSession.
        """
        # TODO: Implementar get_chapter_outro() y advance_chapter() en GameSession
        # outro = self.session.get_chapter_outro(won=True)

        # Fallback temporal: mostrar mensaje genérico
        self._lcd_clear()
        self._lcd_centered(0, "CAPITULO COMPLETO")
        self._lcd_centered(1, "Modo historia")
        self._lcd_centered(2, "en desarrollo")
        self._lcd_centered(3, "[OK] Continuar")

        self._leds_select_only()

        if key == 'SELECT':
            # TODO: Implementar advance_chapter()
            # self.session.advance_chapter()
            # self.state = State.STORY_INTRO
            # Por ahora volver al menú
            self.state = State.MENU
    
    def _update_initials_input(self, key):
        """Estado: Input de iniciales para récord"""
        self._lcd_clear()
        self._lcd_centered(0, "NUEVO RÉCORD!")
        self._lcd_centered(1, "Tus iniciales:")
        self._lcd_centered(2, self.initials_input.get_display())
        self._lcd_centered(3, "[^v]Letra [OK]Sig")
        
        self._leds_menu()
        
        if key == 'UP':
            self.initials_input.up()
        elif key == 'DOWN':
            self.initials_input.down()
        elif key == 'SELECT':
            if self.initials_input.next():
                # Guardar récord
                initials = self.initials_input.get_initials()
                self.session.initials = initials
                
                from config import check_survival_record, check_streak_record
                if self.session.mode == MODE_SURVIVAL:
                    check_survival_record(self.session.total_score, initials)
                check_streak_record(self.session.current_streak, initials)
                
                self.state = State.GAME_OVER
    
    def _cleanup_session(self):
        """Limpia sesión y libera memoria"""
        self.session = None
        self.initials_input = None
        self.opt_scroll = 0
        gc.collect()

    def _update_game_over(self, key):
        """Estado: Game Over"""
        # Sonido al inicio
        if self.frame == 1:
            if self.session and self.session.game_won:
                play_sound('victoria')
            else:
                play_sound('game_over')

        self._lcd_clear()

        if self.session and self.session.game_won:
            self._lcd_centered(0, "** VICTORIA **")
            self._lcd_centered(1, "OBJETIVO CUMPLIDO!")
        else:
            self._lcd_centered(0, "** GAME OVER **")
            self._lcd_centered(1, "TODOS DESPEDIDOS")

        mvp = self.session.get_mvp() if self.session else None
        if mvp:
            self._lcd_centered(2, f"MVP: P{mvp['id']} ({mvp['score']}pts)")

        self._lcd_centered(3, "[OK] Menú")
        self._leds_select_only()

        if key == 'SELECT':
            self._cleanup_session()
            self.state = State.MENU
            self.menu_idx = 0
    
    def _update_stats(self, key):
        """Estado: Estadísticas"""
        summary = get_stats_summary()
        
        self._lcd_clear()
        self._lcd_centered(0, "= ESTADISTICAS =")
        self._lcd_put(0, 1, f"Partidas: {summary['games']}")
        self._lcd_put(0, 2, f"Casos: {summary['cases']}")
        self._lcd_put(0, 3, f"Racha: {summary['streak']}")
        
        self._leds_select_only()

        if key == 'SELECT' or key == 'BACK':
            self.state = State.MENU

    def _update_how_to_play(self, key):
        """Estado: Cómo jugar"""
        pages = [
            # Página 1: Intro
            ["CÓMO JUGAR",
             "Eres un psicólogo",
             "poco ético. Pacientes",
             "te escriben."],
            # Página 2: Objetivo
            ["OBJETIVO",
             "Elige la respuesta",
             "MÁS PSICÓTICA para",
             "resolver el caso."],
            # Página 3: Vidas
            ["VIDAS",
             "Tienes 3 vidas:" + chr(0) + chr(0) + chr(0),
             "Si fallas, pierdes 1",
             "0 vidas = GAME OVER"],
            # Página 4: Controles
            ["CONTROLES",
             "[^] Arriba/Scroll",
             "[v] Abajo/Scroll",
             "[OK] Seleccionar"],
            # Página 5: Pausa
            ["PAUSA",
             "Pulsa [^]+[v] a la",
             "vez para pausar",
             "en la partida."],
            # Página 6: Modos
            ["MODOS",
             "Clásico: Cuota",
             "Survival: Infinito",
             "Historia: Campaña"],
            # Página 7: Modo Clásico
            ["CLÁSICO",
             "Elige cuántos casos",
             "resolver: 3,5,7...",
             "Cumple el objetivo!"],
            # Página 8: Modo Survival
            ["SURVIVAL",
             "Aguanta lo máximo",
             "posible sin fallar.",
             "Guarda tu récord!"],
            # Página 9: Modo Historia
            ["HISTORIA",
             "Campaña: El Interno",
             "Sube de rango en",
             "clínica corrupta."],
            # Página 10: WiFi 1
            ["CONEXIÓN",
             "El juego necesita",
             "internet para los",
             "casos con IA."],
            # Página 11: WiFi 2
            ["CONFIG WIFI",
             "Sin WiFi guardada",
             "se abre el portal",
             "de configuración."],
            # Página 12: WiFi 3
            ["PORTAL 1/4",
             "Busca en tu móvil",
             "la red WiFi:",
             "PSIC-O-TRONIC"],
            # Página 13: WiFi 4
            ["PORTAL 2/4",
             "Conéctate a esa",
             "red sin clave",
             "desde tu móvil."],
            # Página 14: WiFi 5
            ["PORTAL 3/4",
             "Se abre una web",
             "automáticamente",
             "(o 192.168.4.1)"],
            # Página 15: WiFi 6
            ["PORTAL 4/4",
             "Elige tu WiFi,",
             "pon la clave",
             "y pulsa CONECTAR"],
            # Página 16: WiFi 7
            ["LISTO",
             "El aparato guarda",
             "la config y luego",
             "conecta solo."],
            # Página 17: Info
            ["INFO",
             "PSIC-O-TRONIC v1.0",
             "Casos generados",
             "con Gemini AI"],
        ]
        
        self._lcd_clear()
        
        # Primera línea: título + paginación
        title = pages[self.help_page][0]
        page_num = f"{self.help_page + 1}/{len(pages)}"
        spaces = 20 - len(title) - len(page_num)
        self._lcd_put(0, 0, title + " " * spaces + page_num)
        
        # Resto de líneas
        for i in range(1, 4):
            self._lcd_put(0, i, pages[self.help_page][i])
        
        can_up = self.help_page > 0
        can_down = self.help_page < len(pages) - 1
        self._leds_scroll(can_up, can_down)
        
        if key == 'UP' and can_up:
            self.help_page -= 1
        elif key == 'DOWN' and can_down:
            self.help_page += 1
        elif key == 'BACK':
            self.help_page = 0
            self.state = State.MENU
        elif key == 'SELECT':
            self.help_page = 0
            self.state = State.MENU

    def _update_wifi_settings(self, key):
        """Estado: Configuración WiFi"""
        ssid, _ = get_wifi_config()
        
        self._lcd_clear()
        self._lcd_centered(0, "CONFIG WiFi/API")
        if ssid:
            self._lcd_put(0, 1, f"Red: {ssid[:14]}")
        else:
            self._lcd_put(0, 1, "Red: Sin config")
        self._lcd_put(0, 2, "[OK] Abrir portal")
        self._lcd_centered(3, "[^] Volver")
        
        self._leds_menu()
        
        if key == 'UP' or key == 'BACK':
            self.state = State.MENU
        elif key == 'SELECT':
            # No borrar config, solo abrir portal
            self.state = State.WIFI_PORTAL
    
    def _update_credits(self, key):
        """Estado: Créditos con scroll"""
        # Reset página al entrar
        if self.frame == 0:
            self.help_page = 0

        pages = [
            # Página 1: Título
            ["====================",
             "   PSIC-O-TRONIC",
             f"    version {self.version}",
             "===================="],
            # Página 2: Autor
            ["--------------------",
             "Creado y desarrollado",
             "por Miguel Canadas",
             "--------------------"],
            # Página 3: Concepto
            ["-- CONCEPTO --",
             "Juego de humor negro",
             "psicologico con casos",
             "generados por IA"],
            # Página 4: Hardware
            ["-- HARDWARE --",
             "ESP32-S3 + MicroPython",
             "LCD 20x4 I2C",
             "3 botones + 4 LEDs"],
            # Página 5: IA
            ["-- TECNOLOGIA --",
             "Casos generados con",
             "Google Gemini AI",
             "en tiempo real"],
            # Página 6: Funciones
            ["-- CARACTERISTICAS --",
             "WiFi + OTA Updates",
             "3 modos de juego",
             "Sistema de logros"],
            # Página 7: Fecha
            ["-- INFO --",
             "Proyecto 2025",
             "Hecho en Espana",
             ""],
            # Página 8: Final
            ["",
             "Gracias por jugar!",
             "",
             "[OK] Volver al menu"],
        ]

        self._lcd_clear()
        for i, line in enumerate(pages[self.help_page]):
            self._lcd_centered(i, line)

        # Indicador de página
        page_indicator = f"{self.help_page + 1}/{len(pages)}"
        self._lcd_put(16, 0, page_indicator)

        can_up = self.help_page > 0
        can_down = self.help_page < len(pages) - 1
        self._leds_scroll(can_up, can_down)

        if key == 'UP' and can_up:
            self.help_page -= 1
        elif key == 'DOWN' and can_down:
            self.help_page += 1
        elif key == 'BACK':
            self.help_page = 0
            self.state = State.MENU
        elif key == 'SELECT':
            self.help_page = 0
            self.state = State.MENU

    def _update_pause(self, key):
        """Estado: Menú de pausa"""
        # Validar que existe sesión (prevenir crash)
        if not self.session:
            self.state = State.MENU
            self.menu_idx = 0
            return

        self._lcd_clear()
        self._lcd_centered(0, "== PAUSA ==")

        pause_options = ["Continuar", "Reiniciar", "Salir al menú"]

        for i, opt in enumerate(pause_options):
            prefix = ">" if i == self.menu_idx else " "
            self._lcd_put(1, i + 1, f"{prefix}{opt}")

        self._leds_menu()

        if key == 'UP':
            self.menu_idx = (self.menu_idx - 1) % 3
        elif key == 'DOWN':
            self.menu_idx = (self.menu_idx + 1) % 3
        elif key == 'SELECT':
            if self.menu_idx == 0:  # Continuar
                # Volver al estado anterior
                self.state = self.pre_pause_state if self.pre_pause_state else State.CHOOSING
            elif self.menu_idx == 1:  # Reiniciar
                self._start_game(self.session.mode)
            elif self.menu_idx == 2:  # Salir
                self._cleanup_session()
                self.state = State.MENU
            self.menu_idx = 0
    
    def _update_error(self, key):
        """Estado: Pantalla de error con opciones"""
        # Reset variables al entrar (frame 0)
        if self.frame == 0:
            self.error_scroll = 0
            self.error_menu_idx = 0

        # Preparar líneas de error
        error_lines = ["ERROR"]
        
        # Añadir detalles del error (wrapeado)
        if self.error_msg:
            error_lines.extend(self._wrap_text(self.error_msg))
        
        # Añadir soluciones
        error_lines.extend([
            "",
            "Soluciones:",
            "- Verifica WiFi",
            "- Cambia API Key",
            "- Espera 1 minuto",
        ])
        
        self._lcd_clear()
        
        # Mostrar contenido con scroll (3 líneas)
        idx = self.error_scroll
        for i in range(3):
            if idx + i < len(error_lines):
                line = error_lines[idx + i][:20]
                self._lcd_put(0, i, line)
        
        # Línea 4: opciones fijas
        if self.error_menu_idx == 0:
            self._lcd_put(0, 3, ">Reintentar   Menú")
        else:
            self._lcd_put(0, 3, " Reintentar  >Menú")
        
        # LEDs para scroll
        can_up = idx > 0
        can_down = (idx + 3) < len(error_lines)
        self._leds_scroll(can_up, can_down)
        
        # Controles - UP/DOWN hacen scroll primero, luego cambian opción
        if key == 'UP':
            if can_up:
                self.error_scroll -= 1
            else:
                self.error_menu_idx = 0
        elif key == 'DOWN':
            if can_down:
                self.error_scroll += 1
            else:
                self.error_menu_idx = 1
        elif key == 'SELECT':
            if self.error_menu_idx == 0:  # Reintentar
                self.state = State.FETCHING
            else:  # Menú
                self._cleanup_session()
                self.state = State.MENU
    
    # === OTA UPDATES ===

    def _update_ota_auto_check(self, key):
        """Estado: Verificación automática de actualizaciones al inicio"""
        self._lcd_clear()

        # Animación de verificación
        dots = "." * ((self.frame // 4) % 4)
        spinner = ["|", "/", "-", "\\"][self.frame % 4]

        self._lcd_centered(0, f"  Verificando {spinner}")
        self._lcd_centered(1, "actualizaciones" + dots)
        self._lcd_centered(2, "")
        self._lcd_centered(3, "Espera un momento...")

        # LEDs de carga
        self.led_notify.value((self.frame // 3) % 2)

        # Ejecutar check en frame 1
        if self.frame == 1:
            self._ota_checked_on_boot = True
            try:
                ota_manager.check_async(None)
                print("[MAIN] OTA auto-check completado")
            except Exception as e:
                print(f"[MAIN] Error OTA auto-check: {e}")

        # Esperar unos frames para que se vea la animación y luego decidir
        if self.frame > 15:
            self.led_notify.value(0)
            self._leds_off()

            if ota_manager.has_update() and not self._ota_popup_dismissed:
                # Hay actualización - mostrar popup
                self.state = State.OTA_POPUP
            else:
                # No hay actualización o ya se rechazó - ir al menú
                self.state = State.MENU
            self.menu_idx = 0

    def _update_ota_popup(self, key):
        """Estado: Popup automático de actualización disponible"""
        self._lcd_clear()

        info = ota_manager.get_update_info() if OTA_AVAILABLE else None
        is_mandatory = info.get("mandatory", False) if info else False

        # Animación de alerta
        if is_mandatory:
            # Actualización obligatoria - más urgente
            alerts = ["!!! IMPORTANTE !!!", "*** IMPORTANTE ***", "### IMPORTANTE ###"]
            self._lcd_centered(0, alerts[(self.frame // 5) % 3])
        else:
            if (self.frame // 6) % 2 == 0:
                self._lcd_centered(0, "!! ACTUALIZACION !!")
            else:
                self._lcd_centered(0, "** ACTUALIZACION **")

        # Info de la actualización
        if info:
            new_ver = info.get("new_version", "?")
            current_ver = ota_manager.get_current_version()
            changelog = info.get("changelog", "")[:18]

            self._lcd_put(0, 1, f"v{current_ver} -> v{new_ver}")
            if changelog:
                self._lcd_centered(2, changelog)
        else:
            self._lcd_centered(1, "Nueva version")

        # Controles según si es obligatoria
        if is_mandatory:
            self._lcd_centered(3, "[OK] Actualizar")
            self.led_up.value(0)
            self.led_down.value(0)
        else:
            self._lcd_put(0, 3, "[OK]Si  [^]No")
            self.led_up.value(1)
            self.led_down.value(0)

        # LEDs: parpadeo en notify
        self.led_notify.value((self.frame // 4) % 2)
        self.led_select.value(1)

        if key == 'SELECT':
            # Aceptar actualización
            self.led_notify.value(0)
            self.state = State.OTA_UPDATING
            self.frame = 0
        elif not is_mandatory and (key == 'UP' or key == 'DOWN' or key == 'BACK'):
            # Rechazar - ir al menú (solo si no es obligatoria)
            self._ota_popup_dismissed = True
            self.led_notify.value(0)
            self.state = State.MENU
            self.menu_idx = 0

    def _update_ota_check(self, key):
        """Verificar actualizaciones"""
        self._lcd_clear()
        
        if not OTA_AVAILABLE:
            self._lcd_centered(0, "OTA")
            self._lcd_centered(1, "No disponible")
            self._lcd_centered(3, "[OK] Volver")
            self._leds_select_only()
            if key == 'SELECT':
                self.state = State.MENU
            return
        
        # Animación
        dots = "." * ((self.frame // 5) % 4)
        self._lcd_centered(0, "ACTUALIZACIONES")
        self._lcd_centered(1, "Verificando" + dots)
        self._lcd_centered(2, "Conectando...")
        
        self._leds_off()
        
        # Verificar en frame 1
        if self.frame == 1:
            def status_cb(msg):
                pass
            ota_manager.check_async(status_cb)
        
        # Mostrar resultado después
        if self.frame > 20:
            self.state = State.OTA_INFO
    
    def _update_ota_info(self, key):
        """Info de actualización"""
        self._lcd_clear()
        
        if not OTA_AVAILABLE:
            self.state = State.MENU
            return
        
        current_ver = ota_manager.get_current_version()
        
        if ota_manager.has_update():
            info = ota_manager.get_update_info()
            new_ver = info.get("new_version", "?")
            num_files = len(info.get("files", []))
            
            self._lcd_centered(0, "UPDATE DISPONIBLE!")
            self._lcd_put(0, 1, "v" + current_ver + " -> v" + new_ver)
            self._lcd_put(0, 2, str(num_files) + " archivos")
            self._lcd_put(0, 3, "[OK]Instalar [^]No")
            
            self._leds_scroll(True, False)
            
            if key == 'SELECT':
                self.state = State.OTA_UPDATING
                self.frame = 0
            elif key == 'UP':
                self.state = State.MENU
        else:
            self._lcd_centered(0, "SIN ACTUALIZACIONES")
            self._lcd_centered(1, "Version actual:")
            self._lcd_centered(2, "v" + current_ver)
            self._lcd_centered(3, "[OK] Volver")
            
            self._leds_select_only()
            
            if key == 'SELECT':
                self.state = State.MENU
    
    def _update_ota_updating(self, key):
        """Proceso de actualización con progreso visual"""
        self._lcd_clear()

        # Frame 1: Iniciar actualización
        if self.frame == 1:
            total, new_ver = ota_manager.start_update_steps()
            self._ota_total_files = total
            self._ota_new_version = new_ver
            self._ota_current_file = ""
            self._ota_downloading = False

            if total == 0:
                self._ota_success = False
                self._ota_result_msg = "Sin archivos"
                self.state = State.OTA_RESULT
                return

        # Animación spinner
        spinner = ["|", "/", "-", "\\"][self.frame % 4]

        # Obtener progreso
        current, total, percent = ota_manager.get_update_progress()

        # Línea 0: Título con spinner
        self._lcd_centered(0, f"ACTUALIZANDO {spinner}")

        # Línea 1: Barra de progreso visual
        bar_width = 16
        filled = int((percent / 100) * bar_width)
        bar = "[" + chr(0) * filled + "." * (bar_width - filled) + "]"
        self._lcd_put(2, 1, bar)

        # Línea 2: Porcentaje y contador
        progress_text = f"{percent}% ({current}/{total})"
        self._lcd_centered(2, progress_text)

        # Línea 3: Archivo actual o mensaje
        if self._ota_current_file:
            self._lcd_put(0, 3, self._ota_current_file[:20])
        else:
            self._lcd_centered(3, "No desconectar!")

        # LEDs: progreso visual
        self.led_notify.value((self.frame // 3) % 2)
        # Encender LEDs según progreso
        if percent >= 33:
            self.led_up.value(1)
        else:
            self.led_up.value(0)
        if percent >= 66:
            self.led_select.value(1)
        else:
            self.led_select.value(0)
        if percent >= 90:
            self.led_down.value(1)
        else:
            self.led_down.value(0)

        # Descargar siguiente archivo (un archivo por frame, después del frame inicial)
        if self.frame >= 3 and not getattr(self, '_ota_downloading', False):
            self._ota_downloading = True

            done, idx, total, filename, success = ota_manager.update_next_file()
            self._ota_current_file = filename

            if done:
                # Finalizar actualización
                self._leds_off()
                self.led_notify.value(0)
                result, msg = ota_manager.finish_update_steps()
                self._ota_success = result
                self._ota_result_msg = msg
                self.state = State.OTA_RESULT
                self.frame = 0
            else:
                # Permitir siguiente descarga en próximo ciclo
                self._ota_downloading = False
    
    def _update_ota_result(self, key):
        """Resultado de actualización"""
        self._lcd_clear()
        
        success = getattr(self, '_ota_success', False)
        msg = getattr(self, '_ota_result_msg', "")
        
        if success:
            self._lcd_centered(0, "ACTUALIZADO!")
            self._lcd_centered(1, msg[:20])
            self._lcd_centered(2, "Reiniciar ahora?")
            self._lcd_put(0, 3, "[OK]Si  [^]Despues")
            
            self._leds_scroll(True, False)
            
            if key == 'SELECT':
                self._lcd_clear()
                self._lcd_centered(1, "Reiniciando...")
                self._lcd_render()
                time.sleep(1)
                ota_reboot()
            elif key == 'UP':
                self.state = State.MENU
        else:
            self._lcd_centered(0, "ERROR UPDATE")
            self._lcd_centered(1, msg[:20])
            self._lcd_centered(3, "[OK] Volver")
            
            self._leds_select_only()
            
            if key == 'SELECT':
                self.state = State.MENU
    
    # === LOOP PRINCIPAL ===
    
    def run(self):
        """Bucle principal del juego"""
        print("[GAME] Starting main loop...")
        
        state_handlers = {
            State.BOOT: self._update_boot,
            State.FIRST_TIME_WELCOME: self._update_first_time_welcome,
            State.WIFI_CHECK: self._update_wifi_check,
            State.WIFI_PORTAL: self._update_wifi_portal,
            State.INTRO: self._update_intro,
            State.MENU: self._update_menu,
            State.MODE_SELECT: self._update_mode_select,
            State.PLAYER_SELECT: self._update_player_select,
            State.QUOTA_SELECT: self._update_quota_select,
            State.STORY_INTRO: self._update_story_intro,
            State.PASS_DEVICE: self._update_pass_device,
            State.FETCHING: self._update_fetching,
            State.MESSAGE_ANIM: self._update_message_anim,
            State.READING: self._update_reading,
            State.CHOOSING: self._update_choosing,
            State.FEEDBACK: self._update_feedback,
            State.CHAPTER_COMPLETE: self._update_chapter_complete,
            State.INITIALS_INPUT: self._update_initials_input,
            State.GAME_OVER: self._update_game_over,
            State.STATS: self._update_stats,
            State.HOW_TO_PLAY: self._update_how_to_play,
            State.WIFI_SETTINGS: self._update_wifi_settings,
            State.CREDITS: self._update_credits,
            State.PAUSE: self._update_pause,
            State.ERROR: self._update_error,
            State.OTA_AUTO_CHECK: self._update_ota_auto_check,
            State.OTA_CHECK: self._update_ota_check,
            State.OTA_INFO: self._update_ota_info,
            State.OTA_UPDATING: self._update_ota_updating,
            State.OTA_RESULT: self._update_ota_result,
            State.OTA_POPUP: self._update_ota_popup,
        }
        
        while True:
            time.sleep(FRAME_DELAY)
            self.frame += 1
            self.opt_scroll += 1
            self._update_blink()
            
            # Log cambio de estado
            if self.state != self.prev_state:
                print(f"[STATE] {self.prev_state} -> {self.state}")
                self.prev_state = self.state
                self.frame = 0
                # Limpiar shadow para forzar redibujado completo
                self.lcd.clear()
                for y in range(4):
                    for x in range(20):
                        self.lcd_shadow[y][x] = ' '
            
            # Input
            key = self._get_input()
            
            # Handler del estado actual
            handler = state_handlers.get(self.state)
            if handler:
                try:
                    handler(key)
                    # Renderizar buffer al LCD
                    self._lcd_render()
                except Exception as e:
                    print(f"[ERROR] State {self.state}: {e}")
                    import sys
                    sys.print_exception(e)


# ============================================================================
# ENTRY POINT
# ============================================================================

def main():
    try:
        game = PsicOTronic()
        game.run()
    except KeyboardInterrupt:
        print("\n[EXIT] Interrupted by user")
    except Exception as e:
        print(f"\n[FATAL] {e}")
        import sys
        sys.print_exception(e)

if __name__ == "__main__":
    main()