// --- GAME LOOP Y INICIALIZACIÓN ---
let lastTime = Date.now();
let saveTimer = 0;
let correosBoostTimer = 0;
let correosCooldown = 0;
let gameLoopInterval = null; // Referencia al interval del game loop
let isWipingData = false; // Flag para evitar guardar durante borrado completo
let isGamePaused = false; // Estado de pausa
window.isGamePaused = false; // Exponer globalmente para bloquear clicks/compras

// Constantes Fase Gobierno
const GOVERNMENT_DURATION = 300000; // 5 minutos en ms
const GOVERNMENT_MIN_VOTOS = 40000000; // 40M mínimo para mantener gobierno
const GOVERNMENT_CASTA_BONUS = 0.5; // +50% Casta al completar

// Constantes de inmunidad y timing
const STARTUP_IMMUNITY_MS = 3000; // 3 segundos de inmunidad inicial

// --- FUNCIONES GLOBALES DE PAUSA Y GUARDADO ---
window.togglePause = function() {
    isGamePaused = !isGamePaused;
    window.isGamePaused = isGamePaused; // Sincronizar con variable global
    audioSystem.playClick();
    
    // Actualizar textos de botones
    const pauseBtns = document.querySelectorAll('.pause-btn-text');
    pauseBtns.forEach(btn => {
        btn.textContent = isGamePaused ? 'Reanudar' : 'Pausar';
    });
    
    const pauseIcons = document.querySelectorAll('.pause-btn-icon');
    pauseIcons.forEach(icon => {
        icon.textContent = isGamePaused ? '▶️' : '⏸️';
    });

    // Si reanudamos, reseteamos lastTime para evitar saltos
    if (!isGamePaused) {
        lastTime = Date.now();
    }
};

window.manualSave = function() {
    audioSystem.playBuy(); // Sonido de confirmación
    saveGame();
    // El indicador visual ya lo maneja saveGame() -> showSaveIndicator()
};

// Actualizar posición de botones fijos para no tapar el panel de región en móvil
function updateButtonPositions() {
    if (window.innerWidth > 480) return;

    const panel = document.getElementById('region-info-panel');
    const newGameBtn = document.getElementById('new-game-toggle');
    const kofiBtn = document.querySelector('.kofi-btn');

    if (!panel) return;

    // Esperar a que el DOM se actualice para obtener altura correcta
    requestAnimationFrame(() => {
        const panelHeight = panel.offsetHeight;
        const bottomPos = panelHeight + 10 + 'px';

        if (newGameBtn) newGameBtn.style.bottom = bottomPos;
        if (kofiBtn) kofiBtn.style.bottom = bottomPos;
    });
}

// Resetear posición de botones a la base
function resetButtonPositions() {
    if (window.innerWidth > 480) return;

    const newGameBtn = document.getElementById('new-game-toggle');
    const kofiBtn = document.querySelector('.kofi-btn');

    if (newGameBtn) newGameBtn.style.bottom = '10px';
    if (kofiBtn) kofiBtn.style.bottom = '10px';
}


function initGame() {
    // Inicializar sistema de escala de fuentes
    if (typeof fontScaleSystem !== 'undefined') {
        fontScaleSystem.init();
    }

    // Inicializar referencias DOM
    initDisplayRefs();
    initShopRefs();
    initRankingRefs();
    initCharacterRefs();

    // Inicializar estado
    initGameState();
    initLogros();
    initEventos();
    initEventosIncontrolables();

    // Cargar partida guardada
    const loaded = loadGame();
    if (loaded) {
        console.log('Partida cargada correctamente');

        // Actualizar emoji del botón principal según el partido guardado
        const mainButton = document.getElementById('main-button');
        if (mainButton && partidos[partidoElegido]) {
            mainButton.textContent = partidos[partidoElegido].emoji;
        }

        // Si estaba en fase gobierno, restaurar UI
        if (gameState.gamePhase === 'government' && gameState.governmentTimeLeft > 0) {
            showGovernmentUI();
        }

        // SANITY CHECK: Autocorrección de partidas corruptas (Bug de VPS infinito)
        // Si el jugador tiene poco tiempo de juego pero un VPS absurdo, recalcular.
        if (gameStats.tiempoJuegoMs < 60000 && partidos[partidoElegido].vps > 1000000) {
            console.warn('[SANITY CHECK] Detectado VPS anómalo. Recalculando...');
            // Forzar limpieza de multiplicadores basura si existen
            calculateVPS(); 
        }
    }

    // Renderizar UI inicial
    renderShop();
    calculateVPS();
    updateDisplay();
    renderLogros();
    updateDeficitBar();

    // Inicializar navegación móvil
    if (typeof initNavigation === 'function') {
        initNavigation();
    }

    // Configurar event listeners
    setupEventListeners();

    // Iniciar news ticker
    initNewsTicker();

    // Iniciar game loop (limpiar interval previo si existe para evitar múltiples loops)
    if (gameLoopInterval) {
        clearInterval(gameLoopInterval);
        console.warn('[GAME] Interval previo limpiado - posible recarga');
    }
    gameLoopInterval = setInterval(gameLoop, 100);

    // Inicializar sistema de Capacitor para persistencia en Android
    initCapacitorSystem();

    // Configurar pantalla de inicio
    initStartScreen();

    // Inicializar sistema de toast de donación
    if (typeof DonationToast !== 'undefined') {
        DonationToast.init();
    }
}

function initStartScreen() {
    const startScreen = document.getElementById('start-screen');
    const audioSelector = document.getElementById('audio-selector');
    const partySelector = document.getElementById('party-selector');
    const startBtnAudio = document.getElementById('start-btn-audio');
    const startBtnMute = document.getElementById('start-btn-mute');
    const selectPsoe = document.getElementById('select-psoe');
    const selectPp = document.getElementById('select-pp');
    const selectVox = document.getElementById('select-vox');
    const selectPodemos = document.getElementById('select-podemos');

    let withAudio = true;

    // Definir funciones helper primero
    const showPartySelector = () => {
        // Ocultar selector de audio, mostrar selector de partido
        audioSelector.style.display = 'none';
        partySelector.style.display = 'flex';
    };

    const startGameWithParty = (partyKey) => {
        // Configurar partido elegido
        partidoElegido = partyKey;
        console.log('[GAME] Partido elegido:', partidoElegido);

        // Reinicializar todos los datos para el partido elegido
        initPartidos(partidoElegido);
        initBuildingsData(partidoElegido);
        initUpgradesData(partidoElegido);
        initHeadlines(partidoElegido);
        initFrasesData(partidoElegido);
        initEventosData();
        initEventos();

        // Reinicializar gameState con los nuevos datos
        initGameState();

        // Actualizar emoji del botón principal
        const mainButton = document.getElementById('main-button');
        if (mainButton) {
            mainButton.textContent = partidos[partidoElegido].emoji;
        }

        // Actualizar icono del start screen según partido
        startScreen.classList.remove('pp-selected', 'vox-selected', 'podemos-selected');
        if (partyKey === 'pp') {
            startScreen.classList.add('pp-selected');
        } else if (partyKey === 'vox') {
            startScreen.classList.add('vox-selected');
        } else if (partyKey === 'podemos') {
            startScreen.classList.add('podemos-selected');
        }

        // Configurar audio
        if (withAudio) {
            console.log('[GAME] Starting with AUDIO...');
            audioSystem.muted = false;
            audioSystem.resume();
        } else {
            console.log('[GAME] Starting MUTED (Safe Mode)...');
            audioSystem.muted = true;
            const btn = document.getElementById('audio-toggle');
            if (btn) btn.textContent = '🔇';
        }

        // Re-renderizar UI con los datos del nuevo partido
        renderShop();
        calculateVPS();
        updateDisplay();

        // Ocultar pantalla
        startScreen.style.opacity = '0';
        setTimeout(() => {
            startScreen.style.display = 'none';
            if (withAudio) {
                audioSystem.playUnlock();
            }
        }, 500);

        // Guardar inmediatamente para preservar la elección
        saveGame();
    };

    // SIEMPRE configurar event listeners (necesarios para "Nueva Partida")
    if (startScreen && audioSelector) {
        // Paso 1: Audio
        if (startBtnAudio) {
            startBtnAudio.onclick = () => {
                withAudio = true;
                showPartySelector();
            };
        }
        if (startBtnMute) {
            startBtnMute.onclick = () => {
                withAudio = false;
                showPartySelector();
            };
        }

        // Paso 2: Partido
        if (selectPsoe) {
            selectPsoe.onclick = () => {
                if (window.isNewGameMode) {
                    startNewGameWithParty('psoe');
                } else {
                    startGameWithParty('psoe');
                }
            };
        }
        if (selectPp) {
            selectPp.onclick = () => {
                if (window.isNewGameMode) {
                    startNewGameWithParty('pp');
                } else {
                    startGameWithParty('pp');
                }
            };
        }
        if (selectVox) {
            selectVox.onclick = () => {
                if (window.isNewGameMode) {
                    startNewGameWithParty('vox');
                } else {
                    startGameWithParty('vox');
                }
            };
        }
        if (selectPodemos) {
            selectPodemos.onclick = () => {
                if (window.isNewGameMode) {
                    startNewGameWithParty('podemos');
                } else {
                    startGameWithParty('podemos');
                }
            };
        }
    }

    // DESPUÉS de configurar listeners, verificar si saltar la pantalla
    const savedData = localStorage.getItem(SAVE_KEY);
    if (savedData) {
        console.log('[GAME] Partida guardada encontrada, saltando selector');
        startScreen.style.display = 'none';
        return;
    }
}

// Mostrar selector de partidos para nueva partida
function showPartySelectorForNewGame() {
    const startScreen = document.getElementById('start-screen');
    const audioSelector = document.getElementById('audio-selector');
    const partySelector = document.getElementById('party-selector');

    window.isNewGameMode = true;
    audioSelector.style.display = 'none';
    partySelector.style.display = 'flex';
    startScreen.style.display = 'flex';
    startScreen.style.opacity = '1';
    startScreen.classList.remove('pp-selected', 'vox-selected', 'podemos-selected');
}

// Iniciar nueva partida con partido seleccionado (preservando ascensiones)
function startNewGameWithParty(partyKey) {
    window.isNewGameMode = false;

    // Preservar datos de ascensión
    const preservar = {
        castaAcumulada: gameState.castaAcumulada || 0,
        castaGastada: gameState.castaGastada || 0,
        ascensionCount: gameState.ascensionCount || 0,
        privilegiosComprados: gameState.privilegiosComprados ? [...gameState.privilegiosComprados] : []
    };

    // Cambiar partido y reinicializar datos
    partidoElegido = partyKey;
    initPartidos(partidoElegido);
    initBuildingsData(partidoElegido);
    initUpgradesData(partidoElegido);
    initHeadlines(partidoElegido);
    initFrasesData(partidoElegido);
    initEventosData();
    initEventos();
    initGameState();

    // Restaurar ascensiones
    gameState.castaAcumulada = preservar.castaAcumulada;
    gameState.castaGastada = preservar.castaGastada;
    gameState.ascensionCount = preservar.ascensionCount;
    gameState.privilegiosComprados = preservar.privilegiosComprados;

    // Actualizar emoji del botón principal
    const mainButton = document.getElementById('main-button');
    if (mainButton) {
        mainButton.textContent = partidos[partidoElegido].emoji;
    }

    // Actualizar icono del start screen según partido
    const startScreenEl = document.getElementById('start-screen');
    startScreenEl.classList.remove('pp-selected', 'vox-selected', 'podemos-selected');
    if (partyKey === 'pp') {
        startScreenEl.classList.add('pp-selected');
    } else if (partyKey === 'vox') {
        startScreenEl.classList.add('vox-selected');
    } else if (partyKey === 'podemos') {
        startScreenEl.classList.add('podemos-selected');
    }

    // Mostrar mensaje apropiado según si tiene ascensiones o no
    if (preservar.ascensionCount > 0) {
        const castaDisponible = preservar.castaAcumulada - preservar.castaGastada;
        document.getElementById('ego-display').innerText = `⚜️ Casta: ${castaDisponible} | Ascensiones: ${preservar.ascensionCount}`;
    } else {
        document.getElementById('ego-display').innerText = 'Ego Político: 0 (Bonus: +0%)';
    }

    // Re-renderizar UI con los datos del nuevo partido
    renderShop();
    calculateVPS();
    updateDisplay();
    renderLogros();
    if (typeof updateDeficitBar === 'function') updateDeficitBar();

    // Ocultar pantalla de inicio
    const startScreen = document.getElementById('start-screen');
    startScreen.style.opacity = '0';
    setTimeout(() => {
        startScreen.style.display = 'none';
    }, 500);

    // Guardar inmediatamente
    saveGame();
}

// Inicializar sistema de Capacitor (llamado después de initGame)
async function initCapacitorSystem() {
    if (typeof initCapacitorPersistence !== 'function') {
        console.log('[GAME] Sistema de Capacitor no disponible');
        return;
    }

    try {
        const initialized = await initCapacitorPersistence();
        if (initialized) {
            console.log('[GAME] Sistema de Capacitor inicializado');

            // Sincronizar con datos de Preferences si hay datos más recientes
            if (typeof syncFromCapacitorPreferences === 'function') {
                const synced = await syncFromCapacitorPreferences();
                if (synced) {
                    console.log('[GAME] Datos sincronizados desde Capacitor Preferences');
                    // Re-renderizar UI después de cargar datos actualizados
                    renderShop();
                    calculateVPS();
                    updateDisplay();
                }
            }
        }
    } catch (e) {
        console.error('[GAME] Error inicializando Capacitor:', e);
    }
}

function gameLoop() {
    if (gameState.gameOver) return;

    const now = Date.now();
    
    // Si está en pausa, solo actualizamos el tiempo para no acumular delta
    if (isGamePaused) {
        lastTime = now;
        return;
    }

    let deltaMs = now - lastTime;
    // Capear deltaMs a máximo 1 segundo para evitar bugs en móvil cuando la app pierde el foco
    if (deltaMs > 1000) {
        console.log('[GAME] deltaMs capeado:', deltaMs, '-> 1000');
        deltaMs = 1000;
    }
    lastTime = now;

    // Recalcular VPS para aplicar bonuses dinámicos (ej: Tertuliano a 10M)
    calculateVPS();

    // 0. Recuperación automática de déficit (aplica en TODAS las fases)
    const recoveryRate = DEFICIT_RECOVERY_RATE + (partidos[partidoElegido].vps * DEFICIT_RECOVERY_VPS_RATIO);
    gameState.deficit = Math.max(0, gameState.deficit - (recoveryRate / 10)); // /10 porque tick es 100ms
    updateDeficitBar();

    // --- FASE GOBIERNO ---
    if (gameState.gamePhase === 'government') {
        updateGovernmentPhase(deltaMs);
        return; // El gobierno tiene su propia lógica
    }

    // Actualizar estadísticas de tiempo (solo campaña, gobierno tiene las suyas)
    gameStats.tiempoJuegoMs += deltaMs;
    sessionStats.tiempoMs += deltaMs;

    // 1. Actualizar votos del jugador
    let gain = partidos[partidoElegido].vps / 10;
    // Bonus Indra (+5% votos automáticos)
    if (gameState.indraBonus > 0) {
        gain *= (1 + gameState.indraBonus);
    }
    partidos[partidoElegido].votos += gain;
    gameState.totalVotos += gain;
    gameStats.votosHistoricos += gain;
    updateMaxVotos();

    // 2. Actualizar IA de oponentes
    updateAI();

    // 2c. Verificar eventos clickeables
    if (typeof checkClickEvent === 'function') {
        checkClickEvent(deltaMs);
    }

    // 3. Efecto Corrupción Selectiva (5% prob de quitar votos a rivales)
    if (gameState.corrupcionActive && Math.random() < 0.05) {
        // Obtener rivales dinámicamente (todos los que no son el jugador)
        const rivals = Object.keys(partidos).filter(k => k !== partidoElegido);
        const target = rivals[Math.floor(Math.random() * rivals.length)];
        const quitar = 1 + Math.floor(Math.random() * 2); // 1-2 votos
        partidos[target].votos = Math.max(0, partidos[target].votos - quitar);
    }

    // 4. Gestionar boost de Correos
    if (gameState.correosActive) {
        correosCooldown += deltaMs;
        if (gameState.correosBoostActive) {
            correosBoostTimer += deltaMs;
            if (correosBoostTimer >= 60000) { // 60 segundos de boost
                gameState.correosBoostActive = false;
                correosBoostTimer = 0;
            }
        } else if (correosCooldown >= 300000) { // Cada 5 minutos
            gameState.correosBoostActive = true;
            correosCooldown = 0;
        }
    }

    // 5. Actualizar display
    updateDisplay();

    // 5a. Actualizar personaje animado
    updateCharacter();

    // 5b. Actualizar panel de stats si está visible
    if (document.getElementById('stats-panel').classList.contains('visible')) {
        renderStats();
    }

    // 6. Verificar victoria/derrota
    // Salvaguarda: Inmunidad inicial de 3 segundos.
    // Permite que la UI cargue y el jugador pueda reaccionar/resetear si hay un estado corrupto
    // que causaría una derrota instantánea en el frame 1.
    if (gameStats.tiempoJuegoMs > STARTUP_IMMUNITY_MS) {
        checkGameEnd();
    }

    // 7. Verificar eventos aleatorios
    checkEventoAleatorio(deltaMs);

    // 7b. Verificar eventos incontrolables
    checkEventoIncontrolable(deltaMs);

    // 8. Verificar logros
    checkLogros();

    // 9. Auto-save cada 5 segundos
    saveTimer += deltaMs;
    if (saveTimer >= 5000) {
        saveGame();
        saveTimer = 0;
    }

    // 10. Actualizar toast de donación
    if (typeof DonationToast !== 'undefined') {
        DonationToast.update(deltaMs);
    }
}

// Actualizar barra de déficit visual
function updateDeficitBar() {
    const deficitBar = document.getElementById('deficit-bar');
    const deficitText = document.getElementById('deficit-text');
    const bceBtn = document.getElementById('bce-btn');
    const container = document.getElementById('deficit-container');
    if (!deficitBar || !deficitText || !bceBtn || !container) return;

    const deficit = gameState.deficit;
    const deficitPct = (deficit / DEFICIT_MAX) * 100;
    deficitBar.style.width = deficitPct + '%';

    // Toggle clase crítica en el contenedor (>=50%)
    container.classList.toggle('deficit-critical', deficitPct >= 50);

    // Color según nivel de déficit (estilo UE)
    if (deficitPct < 50) {
        deficitBar.style.background = 'linear-gradient(90deg, #003399, #0055cc)';
    } else if (deficitPct < 80) {
        deficitBar.style.background = 'linear-gradient(90deg, #cc7700, #ff9900)';
    } else {
        deficitBar.style.background = 'linear-gradient(90deg, #cc0000, #ff3333)';
    }

    // Texto con porcentaje
    deficitText.textContent = `Déficit: ${Math.round(deficitPct)}%`;

    // Mostrar/ocultar botón BCE
    if (deficitPct >= 50) {
        bceBtn.style.display = 'block';
    } else {
        bceBtn.style.display = 'none';
    }

    // Si está al máximo, mostrar indicación de bloqueo
    if (deficit >= DEFICIT_MAX) {
        deficitText.textContent = `Déficit: 100% - ¡BLOQUEADO!`;
        deficitText.style.color = '#cc0000';
    } else {
        deficitText.style.color = '#003399';
    }
}

// Vender bonos al BCE
function venderBonosBCE() {
    if (gameState.deficit < DEFICIT_MAX * 0.5) return; // Solo si déficit >= 50%

    // Calcular escalado por ventas previas
    const escalado = Math.pow(1.1, gameState.bonosVendidos); // +10% por venta

    audioSystem.playBuy();

    // Aplicar efectos
    gameState.deficit = 0;
    gameState.deuda += DEUDA_POR_BONO * escalado;
    gameState.inflacion += INFLACION_POR_BONO * escalado;
    gameState.bonosVendidos++;

    // Actualizar UI
    updateDeficitBar();
    updateDisplay();
}

function setupEventListeners() {
    const mainButton = document.getElementById('main-button');
    const tooltip = document.getElementById('tooltip');

    // Prevenir zoom en móvil al clickear rápido
    mainButton.addEventListener('touchstart', (e) => {
        e.preventDefault();
        // Bloquear multi-touch: solo procesar si hay exactamente 1 dedo
        if (e.touches.length > 1) {
            return;
        }
        mainButton.click();
    }, { passive: false });

    // Main button click
    mainButton.onclick = (e) => {
        if (gameState.gameOver || isGamePaused) return;

        // Sistema de déficit: bloquear si está al máximo
        if (gameState.deficit >= DEFICIT_MAX) {
            audioSystem.playError();
            // Mostrar mensaje de bloqueo
            const blockText = document.createElement('div');
            blockText.className = 'click-text';
            blockText.innerText = '¡DÉFICIT!';
            blockText.style.color = '#cc0000';
            blockText.style.left = `${e.clientX}px`;
            blockText.style.top = `${e.clientY}px`;
            document.body.appendChild(blockText);
            setTimeout(() => blockText.remove(), 1000);
            return;
        }

        // Incrementar déficit (escalado con inflación - cosmético)
        const inflacionFactor = 1 + (gameState.inflacion / 100);
        gameState.deficit = Math.min(DEFICIT_MAX, gameState.deficit + (DEFICIT_POR_CLICK * inflacionFactor));

        // Obtener bonuses de privilegios
        const privBonuses = typeof calcularBonusesPrivilegios === 'function'
            ? calcularBonusesPrivilegios()
            : { clickBonus: 0, clickVpsRatioBonus: 0 };

        // Bonus por Ego capeado a +50% máximo
        const egoBonus = Math.min(gameState.egoPolitico * 0.1, 0.5);
        // Bonus por Reset Progresista (+10% VPS por uso)
        const resetBonus = 1 + (gameState.resetProgresistaCount * 0.1);
        // Bonus Teflón por corrupción (max +50%)
        const teflonMult = 1 + (gameState.teflonBonus || 0);

        // Nueva fórmula: click base + bonus del VPS
        let baseClick = gameState.clickValue * (1 + egoBonus) * resetBonus * teflonMult;
        // Ratio de VPS por click (base + bonuses de upgrades y privilegios)
        const totalClickVpsRatio = gameState.clickVpsRatio + (privBonuses.clickVpsRatioBonus || 0);
        let vpsBonus = partidos[partidoElegido].vps * totalClickVpsRatio;
        let val = baseClick + vpsBonus;

        // Bonus de Correos (+100 votos/click durante boost)
        if (gameState.correosBoostActive) {
            val += 100;
        }
        // Bonus de privilegios (Contacto en Hacienda)
        val += privBonuses.clickBonus || 0;

        // Click crítico (×5 votos)
        let isCritical = false;
        if (gameState.clickCritChance > 0 && Math.random() < gameState.clickCritChance) {
            val *= 5;
            isCritical = true;
        }

        audioSystem.playClick();

        partidos[partidoElegido].votos += val;
        gameState.totalVotos += val;
        gameState.votosDesdeClicks += val;  // Tracking para logros de click
        gameState.totalClicks++;            // Contador de clicks para logros
        gameStats.totalClicks++;
        sessionStats.clicks++;
        gameStats.votosHistoricos += val;
        updateMaxVotos();

        // Incrementar deuda por click (parte de la economía)
        gameState.deuda += val * 0.1; // 10% del click va a deuda

        // Animación de número (con efecto especial para críticos)
        const clickText = document.createElement('div');
        clickText.className = 'click-text';
        if (isCritical) {
            clickText.innerText = `¡CRÍTICO! +${val.toFixed(0)}`;
            clickText.style.color = '#FFD700';
            clickText.style.fontSize = '1.5em';
            clickText.style.textShadow = '0 0 10px #FFD700';
        } else {
            clickText.innerText = `+${val.toFixed(0)}`;
        }
        clickText.style.left = `${e.clientX}px`;
        clickText.style.top = `${e.clientY}px`;
        document.body.appendChild(clickText);
        setTimeout(() => clickText.remove(), 1000);

        updateDisplay();
        updateDeficitBar();
    };

    // BCE button (vender bonos)
    document.getElementById('bce-btn').onclick = venderBonosBCE;

    // Prestige button
    document.getElementById('prestige-btn').onclick = () => {
        if (gameState.gameOver) return;
        audioSystem.playUnlock();
        // Umbral progresivo: 1M * 1.5^vecesPrestigiado
        const prestigeThreshold = 1000000 * Math.pow(1.5, gameStats.vecesPrestigiado || 0);
        if (gameState.totalVotos <= prestigeThreshold) return;

        const thresholdStr = prestigeThreshold >= 1000000
            ? (prestigeThreshold / 1000000).toFixed(1) + 'M'
            : Math.floor(prestigeThreshold).toLocaleString();
        if (confirm(`¿Estás seguro? Perderás todos tus votos y edificios, pero ganarás Ego Político para ser más poderoso en la próxima legislatura.\n\nUmbral actual: ${thresholdStr} votos`)) {
            const newEgo = Math.floor(Math.sqrt(gameState.totalVotos / 1000000));
            gameState.egoPolitico += newEgo;
            gameStats.vecesPrestigiado++;
            resetSessionStats();
            markVpsDirty();
            partidos[partidoElegido].votos = 0;
            gameState.totalVotos = 0;
            gameState.clickValue = 1;

            // Reset edificios con descuento basado en Ego Político
            // Descuento: 10% por nivel de ego, máximo 50% de descuento (mínimo 50% del costo base)
            const discountFactor = Math.max(0.5, Math.pow(0.9, gameState.egoPolitico));
            for (let key in gameState.buildings) {
                gameState.buildings[key].count = 0;
                // Resetear costo al baseCost con descuento aplicado
                const baseCost = buildingsData[key].baseCost;
                gameState.buildings[key].cost = baseCost * discountFactor;
            }
            // Reset upgrades (except strategic ones - campana removed to prevent exponential scaling)
            const strategicUpgrades = ['pacto', 'memoria'];
            for (let key in gameState.upgrades) {
                if (!strategicUpgrades.includes(key)) {
                    gameState.upgrades[key].bought = false;
                }
            }

            // Reset AI parties partially (25% reduction instead of 50% to keep AI competitive)
            for (let key in partidos) {
                if (!partidos[key].isPlayer) {
                    partidos[key].votos *= 0.75;
                }
            }

            const egoBonusDisplay = Math.min(gameState.egoPolitico * 10, 50);
            document.getElementById('ego-display').innerText = `Ego Político: ${gameState.egoPolitico} (Bonus: +${egoBonusDisplay}%)`;
            markVpsDirty();
            calculateVPS();
            renderShop();
            updateDisplay();
            saveGame(); // Guardar inmediatamente después del prestige
        }
    };

    // Region tooltips
    const regionInfoPanel = document.getElementById('region-info-panel');
    const regionInfoContent = document.getElementById('region-info-content');

    // Helper function to generate region info content
    function getRegionInfoHTML(regionId) {
        const regionData = regiones[regionId];
        if (!regionData) return '';

        const name = regionData.name;
        const controlador = regionData.controlador;
        const controladorInfo = controlador ? partidos[controlador] : null;

        let content = `<strong>${name}</strong><br>`;
        content += `Población: ${(regionData.poblacion / 1000000).toFixed(1)}M<br>`;

        if (controladorInfo) {
            content += `Control: ${controladorInfo.emoji} ${controladorInfo.name}<br>`;
        } else {
            content += `Control: Sin definir<br>`;
        }

        // Show votes per party
        if (Object.keys(regionData.votosPartidos).length > 0) {
            content += `<strong>Votos:</strong> `;
            const sorted = Object.entries(regionData.votosPartidos)
                .sort((a, b) => b[1] - a[1]);
            const voteStrings = sorted.map(([pid, votos]) => {
                const p = partidos[pid];
                const pct = regionData.poblacion > 0
                    ? ((votos / regionData.poblacion) * 100).toFixed(1)
                    : 0;
                return `${p.emoji} ${pct}%`;
            });
            content += voteStrings.join(' | ');
        }

        return content;
    }

    document.querySelectorAll('.region').forEach(region => {
        // Mouse events for desktop
        region.addEventListener('mousemove', (e) => {
            const regionId = region.id;
            const regionData = regiones[regionId];
            if (!regionData) return;

            const name = regionData.name;
            const controlador = regionData.controlador;
            const controladorInfo = controlador ? partidos[controlador] : null;

            let content = `<strong>${name}</strong><br>`;
            content += `Población: ${(regionData.poblacion / 1000000).toFixed(1)}M<br><br>`;

            if (controladorInfo) {
                content += `Control: ${controladorInfo.emoji} ${controladorInfo.name}<br><br>`;
            } else {
                content += `Control: Sin definir<br><br>`;
            }

            // Show votes per party
            if (Object.keys(regionData.votosPartidos).length > 0) {
                content += `<strong>Votos:</strong><br>`;
                const sorted = Object.entries(regionData.votosPartidos)
                    .sort((a, b) => b[1] - a[1]);
                for (const [pid, votos] of sorted) {
                    const p = partidos[pid];
                    const pct = regionData.poblacion > 0
                        ? ((votos / regionData.poblacion) * 100).toFixed(1)
                        : 0;
                    content += `${p.emoji} ${p.name}: ${pct}%<br>`;
                }
            }

            tooltip.style.display = 'block';
            tooltip.style.left = (e.pageX + 15) + 'px';
            tooltip.style.top = (e.pageY + 15) + 'px';
            tooltip.innerHTML = content;
        });
        region.addEventListener('mouseout', () => {
            tooltip.style.display = 'none';
        });

        // Touch events for mobile
        region.addEventListener('touchstart', (e) => {
            e.preventDefault(); // Evitar zoom/scroll
            const regionId = region.id;
            const content = getRegionInfoHTML(regionId);
            if (content) {
                regionInfoContent.innerHTML = content;
                regionInfoPanel.classList.add('active'); // Mostrar el panel
                updateButtonPositions();
            }
        }, { passive: false });
    });

    // Close region info panel when touching outside the map
    document.addEventListener('touchstart', (e) => {
        const isRegion = e.target.closest('.region');
        const isPanel = e.target.closest('.region-info-panel');
        if (!isRegion && !isPanel) {
            regionInfoContent.innerHTML = 'Toca una región para ver su información';
            regionInfoPanel.classList.remove('active'); // Ocultar el panel
            resetButtonPositions();
        }
    });

    // Guardar al cambiar de pestaña
    document.addEventListener('visibilitychange', () => {
        if (document.hidden) {
            saveGame();
        }
    });

    // Guardar al cerrar/recargar (pagehide es más confiable que beforeunload en móvil)
    window.addEventListener('pagehide', () => {
        if (!isWipingData) {
            saveGame();
        }
    });
}

// --- SISTEMA DE ASCENSIÓN ---

// Función principal de ascensión (solo al ganar)
function ascender() {
    // Permitir ascender si tiene 50M votos O si completó gobierno exitosamente
    if (partidos[partidoElegido].votos < ASCENSION_THRESHOLD && !gameState.governmentCompleted) {
        showAscensionError();
        return;
    }
    showAscensionConfirmModal();
}

function showAscensionError() {
    const body = document.getElementById('ascension-confirm-body');
    body.innerHTML = `
        <div style="text-align: center; padding: 20px;">
            <p style="margin-bottom: 20px;">⚠️ Necesitas ganar (50M votos) para ascender.</p>
            <button onclick="closeAscensionConfirmModal()" class="new-game-option">
                <span class="option-title">Entendido</span>
            </button>
        </div>
    `;
    document.getElementById('ascension-confirm-modal').classList.add('active');
}

function showAscensionConfirmModal() {
    const castaGanada = calcularCastaPreview();
    const body = document.getElementById('ascension-confirm-body');
    body.innerHTML = `
        <p style="text-align: center; margin-bottom: 15px;">
            Ganarás <strong>${castaGanada} ⚜️ Casta</strong><br>
            <small>Se reiniciará tu progreso pero mantendrás privilegios permanentes.</small>
        </p>
        <button onclick="confirmarAscension()" class="new-game-option">
            <span class="option-icon">🐙</span>
            <span class="option-title">Ascender</span>
            <span class="option-desc">Entrar al Estado Profundo</span>
        </button>
        <button onclick="closeAscensionConfirmModal()" class="new-game-option danger">
            <span class="option-icon">✕</span>
            <span class="option-title">Cancelar</span>
            <span class="option-desc">Seguir jugando</span>
        </button>
    `;
    document.getElementById('ascension-confirm-modal').classList.add('active');
}

function closeAscensionConfirmModal() {
    document.getElementById('ascension-confirm-modal').classList.remove('active');
}

function confirmarAscension() {
    closeAscensionConfirmModal();

    const castaGanada = calcularCastaPreview();
    gameState.castaAcumulada += castaGanada;
    gameState.ascensionCount++;

    // Estadísticas
    gameStats.vecesPrestigiado++;

    // Resetear estado de la partida pero mantener privilegios
    resetParaAscension();

    // Guardar inmediatamente
    saveGame();

    // Mostrar panel de ascensión
    toggleAscensionPanel();
}

// Reset para ascensión (mantiene privilegios y casta)
function resetParaAscension() {
    // Resetear toast de donación
    if (typeof DonationToast !== 'undefined') {
        DonationToast.reset();
    }

    // Obtener bonuses de privilegios ANTES del reset
    const privBonuses = typeof calcularBonusesPrivilegios === 'function'
        ? calcularBonusesPrivilegios()
        : { startingVotes: 0, startingBuildings: {} };

    // Reset game state (excepto campos de ascensión)
    gameState.totalVotos = 0;
    gameState.egoPolitico = 0;
    gameState.gameOver = false;
    gameState.clickValue = 1;
    gameState.tertulianoActive = false;
    gameState.correosActive = false;
    gameState.correosTimer = 0;
    gameState.correosBoostActive = false;
    gameState.indraBonus = 0;
    gameState.corrupcionActive = false;
    gameState.eventosCorrupcionSobrevividos = 0;
    gameState.decadenciaEventoActivo = false;
    gameState.deficit = 0;
    gameState.bonosVendidos = 0;
    gameState.deuda = 0;
    gameState.inflacion = 0;
    // Reset campos de clicks dinámicos (mantener ratio base)
    gameState.clickVpsRatio = BASE_CLICK_VPS_RATIO;
    gameState.clickCritChance = 0;
    gameState.votosDesdeClicks = 0;
    gameState.totalClicks = 0;
    gameState.viralEventsActivated = 0;
    gameState.regionesPerdidas = 0;
    gameState.deepfakeToolActive = false;
    gameState.prestigeLevel = 0;
    gameState.prestigeBonuses = { vpsMultiplier: 1.0, costReduction: 1.0 };
    gameState.resetProgresistaCount = 0;
    gameState.aiDifficultyReduction = 0;
    gameState.eliminatedRival = null;
    // Reset campos v8 - Fase Gobierno
    gameState.gamePhase = 'campaign';
    gameState.governmentTimeLeft = 0;
    gameState.governmentStartVotos = 0;
    gameState.governmentMinVotos = 0;
    gameState.governmentCompleted = false;

    // Obtener escalado de dificultad
    const dificultad = typeof calcularEscaladoDificultad === 'function'
        ? calcularEscaladoDificultad()
        : { aiGrowthBonus: 0, rivalStartBonus: 0, costMultiplier: 1 };

    // Reset buildings con escalado de coste
    for (let key in buildingsData) {
        const baseCost = buildingsData[key].baseCost;
        gameState.buildings[key] = {
            ...buildingsData[key],
            cost: Math.floor(baseCost * dificultad.costMultiplier),
            count: 0
        };
    }

    // Inicializar edificios de ascensión
    initAscensionBuildings();

    // Aplicar edificios de inicio (Red de Colegas)
    if (privBonuses.startingBuildings) {
        for (const [bldg, count] of Object.entries(privBonuses.startingBuildings)) {
            if (gameState.buildings[bldg]) {
                gameState.buildings[bldg].count = count;
                // Escalar coste
                for (let i = 0; i < count; i++) {
                    gameState.buildings[bldg].cost = Math.floor(gameState.buildings[bldg].cost * 1.15);
                }
            }
        }
    }

    // Reset upgrades
    for (let key in upgradesData) {
        gameState.upgrades[key] = { ...upgradesData[key], bought: false };
    }

    // Reinicializar partidos según partido elegido
    resetPartidos(partidoElegido);

    // Aplicar votos de inicio (Heredero del Régimen)
    partidos[partidoElegido].votos = privBonuses.startingVotes || 0;
    gameState.totalVotos = partidos[partidoElegido].votos;
    partidos[partidoElegido].vps = 0;

    // Reset regions
    for (let key in regiones) {
        regiones[key].controlador = null;
        regiones[key].votosPartidos = {};
    }

    // Reset eventos
    initEventos();
    if (typeof initEventosIncontrolables === 'function') initEventosIncontrolables();
    currentHeadlineIndex = 0;

    // Hide overlays
    document.getElementById('victory-overlay').style.display = 'none';
    document.getElementById('defeat-overlay').style.display = 'none';
    document.getElementById('prestige-container').style.display = 'none';

    // Mostrar botón de ascensión (ahora visible permanentemente)
    const ascensionBtn = document.getElementById('ascension-btn');
    if (ascensionBtn) {
        ascensionBtn.style.display = 'flex';
    }

    // Actualizar UI
    const egoDisplay = document.getElementById('ego-display');
    if (egoDisplay) {
        const castaDisp = getCastaDisponible();
        egoDisplay.innerText = `⚜️ Casta: ${castaDisp} | Ascensiones: ${gameState.ascensionCount}`;
    }

    renderShop();
    calculateVPS();
    updateDisplay();
    renderLogros();
    if (typeof updateDeficitBar === 'function') updateDeficitBar();
}

// Comprar privilegio
function comprarPrivilegio(privId) {
    const priv = privilegiosData[privId];
    if (!priv) return false;

    // Verificar si ya lo tiene
    if (gameState.privilegiosComprados.includes(privId)) {
        return false;
    }

    // Verificar si tiene suficiente Casta
    const castaDisponible = getCastaDisponible();
    if (castaDisponible < priv.cost) {
        return false;
    }

    // Comprar
    gameState.castaGastada += priv.cost;
    gameState.privilegiosComprados.push(privId);

    // Reinicializar edificios de ascensión si desbloqueamos uno nuevo
    if (priv.effect && priv.effect.unlockBuilding) {
        initAscensionBuildings();
        renderShop();
    }

    // Recalcular VPS
    markVpsDirty();
    calculateVPS();

    // Aplicar bonuses de inicio inmediatamente si compramos al inicio de partida
    if (priv.effect && (priv.effect.startingVotes || priv.effect.startingBuildings)) {
        const umbralInicio = 50000; // Consideramos "inicio" si < 50K votos
        if (partidos[partidoElegido].votos < umbralInicio) {
            if (priv.effect.startingVotes) {
                partidos[partidoElegido].votos += priv.effect.startingVotes;
                gameState.totalVotos = partidos[partidoElegido].votos;
            }
            if (priv.effect.startingBuildings) {
                for (const [bldg, count] of Object.entries(priv.effect.startingBuildings)) {
                    if (gameState.buildings[bldg]) {
                        gameState.buildings[bldg].count += count;
                        // Escalar coste por cada edificio añadido
                        for (let i = 0; i < count; i++) {
                            gameState.buildings[bldg].cost = Math.floor(gameState.buildings[bldg].cost * 1.15);
                        }
                    }
                }
                // Recalcular VPS con los nuevos edificios
                markVpsDirty();
                calculateVPS();
            }
            renderShop();
            updateDisplay();
        }
    }

    // Guardar
    saveGame();

    return true;
}

// Eliminar rival (para privilegio Golpe de Estado)
function eliminarRival(rivalKey) {
    if (!gameState.privilegiosComprados.includes('golpe_estado')) {
        return false;
    }
    if (gameState.eliminatedRival) {
        alert('Ya has eliminado un rival en este run.');
        return false;
    }
    if (!partidos[rivalKey] || partidos[rivalKey].isPlayer) {
        return false;
    }

    gameState.eliminatedRival = rivalKey;
    partidos[rivalKey].votos = 0;
    partidos[rivalKey].vps = 0;

    saveGame();
    return true;
}

// Obtener umbral de victoria (puede ser modificado por privilegios)
function getVictoryThreshold() {
    const privBonuses = typeof calcularBonusesPrivilegios === 'function'
        ? calcularBonusesPrivilegios()
        : { victoryThresholdIncrease: 0 };

    return VICTORIA_VOTOS + (privBonuses.victoryThresholdIncrease || 0);
}

// --- FASE 2: GOBIERNO ---

// Entrar en fase gobierno después de ganar
function enterGovernmentPhase() {
    // Cerrar overlay de victoria
    document.getElementById('victory-overlay').style.display = 'none';

    // Configurar estado de gobierno
    gameState.gamePhase = 'government';
    gameState.gameOver = false;
    gameState.governmentTimeLeft = GOVERNMENT_DURATION;
    gameState.governmentStartVotos = partidos[partidoElegido].votos;
    gameState.governmentMinVotos = GOVERNMENT_MIN_VOTOS;
    gameState.governmentCompleted = false;

    // Reiniciar eventos para que aparezcan más rápido
    initEventos();
    tiempoParaEvento = 30000 + Math.random() * 30000; // 30-60 segundos
    tiempoTranscurrido = 0;

    // Mostrar UI de gobierno
    showGovernmentUI();

    // Guardar
    saveGame();
}

// Actualizar fase gobierno
function updateGovernmentPhase(deltaMs) {
    // Decrementar tiempo
    gameState.governmentTimeLeft -= deltaMs;

    // Actualizar estadísticas de tiempo
    gameStats.tiempoJuegoMs += deltaMs;
    sessionStats.tiempoMs += deltaMs;

    // En gobierno, los votos BAJAN gradualmente (presión constante)
    const votosPerdidos = (partidos[partidoElegido].vps * 0.3) / 10; // 30% del VPS se pierde
    partidos[partidoElegido].votos = Math.max(0, partidos[partidoElegido].votos - votosPerdidos);

    // Los rivales siguen creciendo (más lento)
    updateAI();

    // Verificar eventos (más frecuentes en gobierno)
    checkEventoAleatorio(deltaMs * 2); // Doble velocidad de eventos

    // Actualizar display
    updateDisplay();
    updateGovernmentUI();

    // Verificar si un rival ha ganado durante el gobierno
    const victoryThreshold = typeof getVictoryThreshold === 'function' ? getVictoryThreshold() : VICTORIA_VOTOS;
    for (let key in partidos) {
        if (!partidos[key].isPlayer && partidos[key].votos >= victoryThreshold) {
            exitGovernmentPhase(false, key); // Derrota porque rival ganó
            return;
        }
    }

    // Verificar condiciones de fin
    if (partidos[partidoElegido].votos < gameState.governmentMinVotos) {
        // Voto de censura - perdió
        exitGovernmentPhase(false);
        return;
    }

    if (gameState.governmentTimeLeft <= 0) {
        // Completó el gobierno con éxito
        exitGovernmentPhase(true);
        return;
    }

    // Auto-save
    saveTimer += deltaMs;
    if (saveTimer >= 5000) {
        saveGame();
        saveTimer = 0;
    }
}

// Salir de fase gobierno
function exitGovernmentPhase(success, winningRival) {
    gameState.gamePhase = 'campaign';
    gameState.gameOver = true;

    if (success) {
        // Victoria - bonus de Casta
        gameState.governmentCompleted = true;
        showGovernmentVictory();
    } else {
        // Derrota - voto de censura o rival ganó
        showGovernmentDefeat(winningRival);
    }

    // Ocultar UI de gobierno
    hideGovernmentUI();
    saveGame();
}

// Mostrar UI de gobierno
function showGovernmentUI() {
    // Crear o mostrar panel de gobierno si no existe
    let govPanel = document.getElementById('government-panel');
    if (!govPanel) {
        govPanel = document.createElement('div');
        govPanel.id = 'government-panel';
        govPanel.className = 'government-panel';
        document.body.appendChild(govPanel);
    }
    govPanel.style.display = 'block';
    updateGovernmentUI();
}

// Actualizar UI de gobierno
function updateGovernmentUI() {
    const govPanel = document.getElementById('government-panel');
    if (!govPanel) return;

    const timeLeft = Math.max(0, gameState.governmentTimeLeft);
    const minutes = Math.floor(timeLeft / 60000);
    const seconds = Math.floor((timeLeft % 60000) / 1000);
    const votosActuales = partidos[partidoElegido].votos;
    const votosMinimos = gameState.governmentMinVotos;
    const pctVotos = Math.min(100, (votosActuales / votosMinimos) * 100);

    // Color según estado
    let statusColor = '#4CAF50'; // Verde
    if (pctVotos < 120) statusColor = '#ff9800'; // Naranja
    if (pctVotos < 105) statusColor = '#f44336'; // Rojo

    govPanel.innerHTML = `
        <div class="gov-header">🏛️ FASE GOBIERNO</div>
        <div class="gov-timer">${minutes}:${seconds.toString().padStart(2, '0')}</div>
        <div class="gov-votos" style="color: ${statusColor}">
            ${(votosActuales / 1000000).toFixed(1)}M / ${(votosMinimos / 1000000).toFixed(0)}M
        </div>
        <div class="gov-bar-container">
            <div class="gov-bar" style="width: ${Math.min(pctVotos, 100)}%; background: ${statusColor}"></div>
            <div class="gov-min-line"></div>
        </div>
        <div class="gov-hint">¡Mantén ${(votosMinimos / 1000000).toFixed(0)}M votos durante 5 minutos!</div>
    `;
}

// Ocultar UI de gobierno
function hideGovernmentUI() {
    const govPanel = document.getElementById('government-panel');
    if (govPanel) {
        govPanel.style.display = 'none';
    }
}

// Mostrar victoria de gobierno
function showGovernmentVictory() {
    // Calcular bonus de Casta
    const castaBase = typeof calcularCastaPreview === 'function' ? calcularCastaPreview() : 10;
    const castaBonus = Math.floor(castaBase * GOVERNMENT_CASTA_BONUS);
    const castaTotal = castaBase + castaBonus;

    const overlay = document.getElementById('victory-overlay');
    const stats = document.getElementById('victory-stats');
    stats.innerHTML = `
        🏛️ <strong>¡GOBIERNO COMPLETADO!</strong><br><br>
        Has mantenido el gobierno durante 5 minutos sin perder la mayoría.<br><br>
        <span style="color: #d4af37; font-size: 1.2em;">
            ⚜️ Casta base: ${castaBase}<br>
            ⚜️ Bonus gobierno (+50%): +${castaBonus}<br>
            <strong>⚜️ Total: ${castaTotal}</strong>
        </span><br><br>
        ¡La Casta premia tu gestión!
    `;

    // Aplicar Casta total (base + bonus gobierno)
    gameState.castaAcumulada += castaTotal;

    // Remover botón de gobernar y dejar solo ascender
    const governBtn = document.getElementById('govern-btn-victory');
    if (governBtn) governBtn.remove();

    overlay.style.display = 'flex';
}

// Mostrar derrota de gobierno (voto de censura o rival ganó)
function showGovernmentDefeat(winningRival) {
    const overlay = document.getElementById('defeat-overlay');
    const stats = document.getElementById('defeat-stats');

    if (winningRival && partidos[winningRival]) {
        // Derrota porque un rival llegó a 50M
        const rival = partidos[winningRival];
        stats.innerHTML = `
            ⚠️ <strong>¡${rival.emoji} ${rival.name.toUpperCase()} HA GANADO!</strong><br><br>
            Mientras gobernabas, ${rival.name} ha alcanzado los 50M de votos.<br>
            Tu gobierno ha sido derrotado en las urnas.<br><br>
            <span style="color: #ff6b6b;">
                No recibirás el bonus de Casta por gobierno.
            </span><br><br>
            Aún puedes ascender con la Casta base.
        `;
    } else {
        // Derrota por voto de censura (votos < 40M)
        stats.innerHTML = `
            ⚠️ <strong>¡VOTO DE CENSURA!</strong><br><br>
            Tus votos han caído por debajo de ${(GOVERNMENT_MIN_VOTOS / 1000000).toFixed(0)}M.<br>
            El Congreso ha aprobado una moción de censura.<br><br>
            <span style="color: #ff6b6b;">
                No recibirás el bonus de Casta por gobierno.
            </span><br><br>
            Aún puedes ascender con la Casta base.
        `;
    }

    // Añadir botón de ascender al overlay de derrota
    const buttonsContainer = overlay.querySelector('.overlay-buttons') ||
        overlay.querySelector('button').parentElement;

    if (buttonsContainer && !document.getElementById('ascend-btn-defeat')) {
        const ascendBtn = document.createElement('button');
        ascendBtn.id = 'ascend-btn-defeat';
        ascendBtn.className = 'ascend-btn';
        ascendBtn.innerHTML = '🐙 Ascender al Estado Profundo';
        ascendBtn.onclick = ascender;
        buttonsContainer.insertBefore(ascendBtn, buttonsContainer.firstChild);
    }

    overlay.style.display = 'flex';
}

// Iniciar cuando el DOM esté listo
document.addEventListener('DOMContentLoaded', () => {
    try {
        initGame();
    } catch (e) {
        console.error('[GAME CRASH]', e);
        alert('Error fatal iniciando el juego:\n' + e.message + '\n\nPor favor reporta este error.');
    }
});
