// --- SISTEMA DE EVENTOS CLICKEABLES ---
// Eventos que aparecen en pantalla y deben ser clickeados para obtener bonificaciones

// Configuración de tiempos
const CLICK_EVENT_MIN_INTERVAL = 45000;  // 45 segundos mínimo entre eventos
const CLICK_EVENT_MAX_INTERVAL = 90000;  // 90 segundos máximo entre eventos
const CLICK_EVENT_DURATION = 5000;       // 5 segundos para clickear antes de que desaparezca

// Estado del sistema
let clickEventTimer = 0;
let nextClickEventTime = 0;
let activeClickEvent = null;

// Tipos de eventos clickeables
const clickEventTypes = [
    {
        id: 'escandalo_rival',
        name: 'Escándalo Rival',
        emoji: '📰',
        desc: 'Roba 2% votos del rival líder',
        color: '#ff6b6b',
        effect: function() {
            // Encontrar rival con más votos
            let maxRival = null;
            let maxVotos = 0;
            for (let key in partidos) {
                if (key !== partidoElegido && partidos[key].votos > maxVotos) {
                    maxVotos = partidos[key].votos;
                    maxRival = key;
                }
            }
            if (maxRival) {
                const robo = partidos[maxRival].votos * 0.02;
                partidos[partidoElegido].votos += robo;
                partidos[maxRival].votos -= robo;
                return `¡Robaste ${Math.floor(robo).toLocaleString()} votos de ${partidos[maxRival].name}!`;
            }
            return '¡No hay rivales!';
        }
    },
    {
        id: 'momento_viral',
        name: 'Momento Viral',
        emoji: '🔥',
        desc: 'Gana 1 min de VPS',
        color: '#ff9800',
        effect: function() {
            // 60 segundos de producción (1 min)
            const seconds = 60;
            const currentVps = partidos[partidoElegido].vps;

            // Cálculo base: VPS * Segundos
            let bonus = currentVps * seconds;

            // BALANCE v11: Base mínima reducida
            const baseFloor = 100;

            // BALANCE v11: Topes de seguridad CORREGIDOS
            // 1. Tope Histórico: 8% de totalVotos (antes era 50% - demasiado alto)
            const capHistPct = typeof CLICK_EVENT_CAP_HISTORICO !== 'undefined' ? CLICK_EVENT_CAP_HISTORICO : 0.08;
            const capHistorico = Math.max(baseFloor, gameState.totalVotos * capHistPct);

            // 2. Tope Victoria: escala con progreso (0.1% → 0.5%)
            const capVictBase = typeof CLICK_EVENT_CAP_VICTORIA_BASE !== 'undefined' ? CLICK_EVENT_CAP_VICTORIA_BASE : 0.001;
            const capVictScale = typeof CLICK_EVENT_CAP_VICTORIA_SCALE !== 'undefined' ? CLICK_EVENT_CAP_VICTORIA_SCALE : 0.004;
            const progressPct = Math.min(1, partidos[partidoElegido].votos / VICTORIA_VOTOS);
            const capVictoriaPct = capVictBase + (progressPct * capVictScale);
            const capVictoria = VICTORIA_VOTOS * capVictoriaPct;

            // 3. Cap absoluto: 0.2% de meta (100K)
            const capAbsPct = typeof CLICK_EVENT_CAP_ABSOLUTO !== 'undefined' ? CLICK_EVENT_CAP_ABSOLUTO : 0.002;
            const capAbsoluto = VICTORIA_VOTOS * capAbsPct;

            // Aplicar límites
            bonus = Math.max(bonus, baseFloor);
            bonus = Math.min(bonus, capHistorico, capVictoria, capAbsoluto);

            partidos[partidoElegido].votos += bonus;
            // BALANCE v11: NO sumar a totalVotos (evita bucle de retroalimentación)
            gameState.viralEventsActivated++;
            return `¡+${Math.floor(bonus).toLocaleString()} votos virales!`;
        }
    },
    {
        id: 'voto_flotante',
        name: 'Voto Flotante',
        emoji: '🗳️',
        desc: 'Gana 2 min de VPS',
        color: '#4CAF50',
        effect: function() {
            // 120 segundos de producción (2 min)
            const seconds = 120;
            const currentVps = partidos[partidoElegido].vps;

            // Cálculo base: VPS * Segundos
            let bonus = currentVps * seconds;

            // BALANCE v11: Base mínima reducida
            const baseFloor = 100;

            // BALANCE v11: Topes de seguridad CORREGIDOS
            // 1. Tope Histórico: 8% de totalVotos
            const capHistPct = typeof CLICK_EVENT_CAP_HISTORICO !== 'undefined' ? CLICK_EVENT_CAP_HISTORICO : 0.08;
            const capHistorico = Math.max(baseFloor, gameState.totalVotos * capHistPct);

            // 2. Tope Victoria: escala con progreso (0.1% → 0.5%)
            const capVictBase = typeof CLICK_EVENT_CAP_VICTORIA_BASE !== 'undefined' ? CLICK_EVENT_CAP_VICTORIA_BASE : 0.001;
            const capVictScale = typeof CLICK_EVENT_CAP_VICTORIA_SCALE !== 'undefined' ? CLICK_EVENT_CAP_VICTORIA_SCALE : 0.004;
            const progressPct = Math.min(1, partidos[partidoElegido].votos / VICTORIA_VOTOS);
            const capVictoriaPct = capVictBase + (progressPct * capVictScale);
            const capVictoria = VICTORIA_VOTOS * capVictoriaPct;

            // 3. Cap absoluto: 0.2% de meta (100K)
            const capAbsPct = typeof CLICK_EVENT_CAP_ABSOLUTO !== 'undefined' ? CLICK_EVENT_CAP_ABSOLUTO : 0.002;
            const capAbsoluto = VICTORIA_VOTOS * capAbsPct;

            // Aplicar límites
            bonus = Math.max(bonus, baseFloor);
            bonus = Math.min(bonus, capHistorico, capVictoria, capAbsoluto);

            partidos[partidoElegido].votos += bonus;
            // BALANCE v11: NO sumar a totalVotos (evita bucle de retroalimentación)
            return `¡+${Math.floor(bonus).toLocaleString()} votos de indecisos!`;
        }
    },
    {
        id: 'donacion_anonima',
        name: 'Donación Anónima',
        emoji: '💰',
        desc: 'Votos proporcionales a tu deuda',
        color: '#d4af37',
        effect: function() {
            // Más deuda = más votos (la corrupción paga)
            // BALANCE v11: Aplicar cap absoluto también
            const capAbsPct = typeof CLICK_EVENT_CAP_ABSOLUTO !== 'undefined' ? CLICK_EVENT_CAP_ABSOLUTO : 0.002;
            const capAbsoluto = VICTORIA_VOTOS * capAbsPct;
            const bonus = Math.min(Math.max(1000, gameState.deuda * 0.1), capAbsoluto);
            partidos[partidoElegido].votos += bonus;
            // BALANCE v11: NO sumar a totalVotos
            return `¡+${Math.floor(bonus).toLocaleString()} votos de donantes anónimos!`;
        }
    }
];

// Inicializar sistema
function initClickEvents() {
    nextClickEventTime = CLICK_EVENT_MIN_INTERVAL + Math.random() * (CLICK_EVENT_MAX_INTERVAL - CLICK_EVENT_MIN_INTERVAL);
    clickEventTimer = 0;
    activeClickEvent = null;
}

// Verificar si es momento de mostrar un evento (llamado desde gameLoop)
function checkClickEvent(deltaMs) {
    if (gameState.gameOver || gameState.gamePhase === 'government') return;

    // Si hay un evento activo, no hacer nada (el evento se maneja solo)
    if (activeClickEvent) return;

    clickEventTimer += deltaMs;

    if (clickEventTimer >= nextClickEventTime) {
        spawnClickEvent();
        clickEventTimer = 0;
        nextClickEventTime = CLICK_EVENT_MIN_INTERVAL + Math.random() * (CLICK_EVENT_MAX_INTERVAL - CLICK_EVENT_MIN_INTERVAL);
    }
}

// Crear y mostrar un evento clickeable
function spawnClickEvent() {
    // Elegir tipo de evento aleatorio
    const eventType = clickEventTypes[Math.floor(Math.random() * clickEventTypes.length)];

    // Crear elemento visual
    const eventEl = document.createElement('div');
    eventEl.className = 'click-event';
    eventEl.id = 'active-click-event';

    // Posición aleatoria dentro del área visible
    const mapContainer = document.getElementById('map-container');
    if (!mapContainer) return;

    const rect = mapContainer.getBoundingClientRect();
    const x = rect.left + Math.random() * (rect.width - 100);
    const y = rect.top + Math.random() * (rect.height - 80);

    eventEl.style.left = x + 'px';
    eventEl.style.top = y + 'px';
    eventEl.style.borderColor = eventType.color;
    eventEl.style.boxShadow = `0 0 20px ${eventType.color}80`;

    eventEl.innerHTML = `
        <div class="click-event-emoji">${eventType.emoji}</div>
        <div class="click-event-name">${eventType.name}</div>
        <div class="click-event-timer"></div>
    `;

    // Manejar click
    eventEl.onclick = function(e) {
        e.stopPropagation();
        handleClickEventSuccess(eventType, eventEl);
    };

    // Prevenir que el touch en móvil haga scroll
    eventEl.ontouchstart = function(e) {
        e.preventDefault();
        e.stopPropagation();
        handleClickEventSuccess(eventType, eventEl);
    };

    document.body.appendChild(eventEl);
    activeClickEvent = eventEl;

    // Animar entrada
    setTimeout(() => eventEl.classList.add('visible'), 10);

    // Sonido de aparición
    if (typeof audioSystem !== 'undefined') {
        audioSystem.playUnlock();
    }

    // Temporizador para desaparecer
    let timeLeft = CLICK_EVENT_DURATION;
    const timerEl = eventEl.querySelector('.click-event-timer');

    const countdown = setInterval(() => {
        timeLeft -= 100;
        const pct = (timeLeft / CLICK_EVENT_DURATION) * 100;
        if (timerEl) {
            timerEl.style.width = pct + '%';
            timerEl.style.background = pct > 30 ? eventType.color : '#ff3333';
        }

        if (timeLeft <= 0) {
            clearInterval(countdown);
            removeClickEvent(eventEl, false);
        }
    }, 100);

    eventEl.dataset.countdownId = countdown;
}

// Manejar click exitoso en evento
function handleClickEventSuccess(eventType, eventEl) {
    // Evitar multi-clicks
    if (eventEl.dataset.clicked === "true") return;
    eventEl.dataset.clicked = "true";

    // Cancelar countdown
    const countdownId = parseInt(eventEl.dataset.countdownId);
    if (countdownId) clearInterval(countdownId);

    // Ejecutar efecto y obtener mensaje
    const message = eventType.effect();

    // Mostrar mensaje de éxito
    showClickEventResult(eventEl, message, eventType.color);

    // Sonido de éxito
    if (typeof audioSystem !== 'undefined') {
        audioSystem.playBuy();
    }

    // Actualizar display
    if (typeof updateDisplay === 'function') updateDisplay();

    // Remover evento
    removeClickEvent(eventEl, true);
}

// Mostrar resultado del evento
function showClickEventResult(eventEl, message, color) {
    const rect = eventEl.getBoundingClientRect();

    const resultEl = document.createElement('div');
    resultEl.className = 'click-event-result';
    resultEl.style.left = rect.left + 'px';
    resultEl.style.top = rect.top + 'px';
    resultEl.style.color = color;
    resultEl.innerText = message;

    document.body.appendChild(resultEl);

    setTimeout(() => {
        resultEl.classList.add('fade-out');
        setTimeout(() => resultEl.remove(), 500);
    }, 1500);
}

// Remover evento clickeable
function removeClickEvent(eventEl, success) {
    if (!eventEl) return;

    eventEl.classList.remove('visible');
    eventEl.classList.add(success ? 'success' : 'missed');

    setTimeout(() => {
        eventEl.remove();
        activeClickEvent = null;
    }, 300);
}

// Inicializar al cargar (se llamará desde initGame si existe)
if (typeof document !== 'undefined') {
    document.addEventListener('DOMContentLoaded', () => {
        initClickEvents();
    });
}
