// --- OPTIMIZACIÓN P3: Cache de varianza aleatoria ---
let _aiRandomCache = {
    midGameVariance: 0.10,      // 0.80 + variance → 0.80-1.00
    lateGameVariance: 0.10,     // 0.95 + variance → 0.95-1.15
    baseVariance: 0.10,         // 0.90 + variance → 0.90-1.10 (±10%)
    lastUpdate: 0               // Timestamp última actualización
};
const AI_RANDOM_CACHE_DURATION = 1500; // Recalcular cada 1.5 segundos

// --- FUNCIONES HELPER ---

/**
 * Normaliza un valor a un rango de década (0-10 o rango personalizado).
 * Útil para escalar progresivamente valores basados en el progreso del juego.
 * @param {number} valor - Valor actual
 * @param {number} min - Valor mínimo del rango de entrada
 * @param {number} max - Valor máximo del rango de entrada
 * @param {number} decadaMin - Valor mínimo de salida (default: 0)
 * @param {number} decadaMax - Valor máximo de salida (default: 10)
 * @returns {number} Valor normalizado al rango [decadaMin, decadaMax]
 */
function normalizarADecada(valor, min, max, decadaMin = 0, decadaMax = 10) {
    if (valor <= min) return decadaMin;
    if (valor >= max) return decadaMax;
    const progress = (valor - min) / (max - min);
    return decadaMin + (progress * (decadaMax - decadaMin));
}

// Actualizar varianzas cacheadas
function updateAiRandomCache() {
    const now = Date.now();
    if (now - _aiRandomCache.lastUpdate < AI_RANDOM_CACHE_DURATION) {
        return; // No es hora de actualizar aún
    }
    _aiRandomCache.midGameVariance = Math.random() * 0.20;
    _aiRandomCache.lateGameVariance = Math.random() * 0.20;
    _aiRandomCache.baseVariance = Math.random() * 0.20;
    _aiRandomCache.lastUpdate = now;
}

// --- FUNCIONES DE IA ---
function updateAI() {
    if (gameState.gameOver) return;
    if (typeof gameStats === 'undefined' || !gameStats || gameStats.tiempoJuegoMs === undefined) return;

    const playerVotos = partidos[partidoElegido].votos;
    const playerVps = partidos[partidoElegido].vps;

    // Calcular contribución efectiva de clicks al ritmo del jugador
    const clickContribution = gameStats.tiempoJuegoMs > 0
        ? (gameState.totalVotos / (gameStats.tiempoJuegoMs / 1000)) * 0.3
        : 0;
    const effectivePlayerRate = playerVps + clickContribution;

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

    // Obtener bonuses de privilegios para reducción de growth rival
    const privBonuses = typeof calcularBonusesPrivilegios === 'function'
        ? calcularBonusesPrivilegios()
        : { rivalGrowthReduction: 0 };

    // OPTIMIZACIÓN P3: Actualizar varianzas cacheadas
    updateAiRandomCache();

    for (let key in partidos) {
        const partido = partidos[key];
        if (partido.isPlayer) continue;

        // Saltar rival eliminado por privilegio Golpe de Estado
        if (gameState.eliminatedRival === key) {
            partido.vps = 0;
            continue;
        }

        // Base growth ahora escala con la tasa efectiva del jugador (VPS + clicks)
        let baseGrowth = Math.max(0.5, effectivePlayerRate * partido.growthRate);

        // Aplicar bonus de dificultad por privilegios
        baseGrowth *= (1 + dificultad.aiGrowthBonus);

        // Aplicar reducción de growth por privilegio "Amigos en Bruselas"
        baseGrowth *= (1 - privBonuses.rivalGrowthReduction);

        // Bonus +20% durante eventos de decadencia
        if (gameState.decadenciaEventoActivo) {
            baseGrowth *= 1.2;
        }

        // Very early game: IA muy lenta pero presente (0-1M)
        if (playerVotos < 1000000) {
            // 0-1M: IA muy lenta (15-40% de growth)
            baseGrowth *= 0.15 + (playerVotos / 4000000);
        }
        // Early game: IA acelera gradualmente (1M-10M)
        else if (playerVotos < 10000000) {
            // 1M-10M: IA acelera (40-80% de growth)
            const progress = (playerVotos - 1000000) / 9000000;
            baseGrowth *= 0.40 + (progress * 0.40);
        }
        // Mid game: competitivo (10M-25M)
        else if (playerVotos < 25000000) {
            // 10M-25M: Competitivo (80-100%)
            baseGrowth *= 0.80 + _aiRandomCache.midGameVariance;
        }
        // Late game: agresivo pero controlado (25M+)
        else {
            // 25M+: Late game (95-115%)
            baseGrowth *= 0.95 + _aiRandomCache.lateGameVariance;
        }

        // Catch-up: si el jugador va muy adelante, los rivales aceleran (suavizado)
        const votosDiff = playerVotos - partido.votos;
        if (votosDiff > 10000000) {
            // Bonus de hasta +50% cuando la diferencia es enorme (antes +70%)
            const catchupBonus = Math.min(0.40, votosDiff / 150000000);
            baseGrowth *= 1.10 + catchupBonus;
        }

        // OPTIMIZACIÓN P3: Usar varianza cacheada (±10%)
        const variance = 0.90 + _aiRandomCache.baseVariance;
        const gain = (baseGrowth * variance) / 10; // Per 100ms tick

        partido.votos += Math.max(0, gain);
        partido.vps = baseGrowth; // Store for display
    }
}

// Inicializar rivales con ventaja basada en poder de privilegios
function initRivalesConVentaja() {
    const dificultad = typeof calcularEscaladoDificultad === 'function'
        ? calcularEscaladoDificultad()
        : { aiGrowthBonus: 0, rivalStartBonus: 0, costMultiplier: 1 };

    for (let key in partidos) {
        const partido = partidos[key];
        if (partido.isPlayer) continue;

        // Añadir votos de inicio basados en poder de privilegios
        partido.votos += dificultad.rivalStartBonus;
    }
}
