// --- REFERENCIAS DOM ---
let buildingsList, upgradesList, multiplierBar;

// --- ESTADO DEL MULTIPLICADOR ---
let currentMultiplier = 1; // 1, 5, 10, 25, 100, 'max'

function initShopRefs() {
    buildingsList = document.getElementById('buildings-list');
    upgradesList = document.getElementById('upgrades-list');
    multiplierBar = document.getElementById('multiplier-bar');
    initMultiplierEvents();
}

// --- FUNCIONES DE CÁLCULO PARA COMPRA MASIVA ---

// BALANCE v11: Factor de escalado variable según tier del building
function getScaleFactor(baseCost) {
    const earlyFactor = typeof SCALE_FACTOR_EARLY !== 'undefined' ? SCALE_FACTOR_EARLY : 1.12;
    const midFactor = typeof SCALE_FACTOR_MID !== 'undefined' ? SCALE_FACTOR_MID : 1.15;
    const lateFactor = typeof SCALE_FACTOR_LATE !== 'undefined' ? SCALE_FACTOR_LATE : 1.10;

    if (baseCost < 5000) return earlyFactor;      // Early: más suave
    if (baseCost < 100000) return midFactor;      // Mid: estándar
    return lateFactor;                             // Late: más fácil de spamear
}

// Costo total para N unidades (suma geométrica) - BALANCE v11: factor variable
function calculateBulkCost(building, quantity) {
    const r = getScaleFactor(building.baseCost);
    if (quantity <= 0) return 0;
    return Math.floor(building.cost * (Math.pow(r, quantity) - 1) / (r - 1));
}

// Máximo comprable con votos disponibles - BALANCE v11: factor variable
function calculateMaxAffordable(building, votos) {
    if (votos < building.cost) return 0;
    const r = getScaleFactor(building.baseCost);
    const n = Math.floor(Math.log(votos * (r - 1) / building.cost + 1) / Math.log(r));
    return Math.max(0, n);
}

// Obtener cantidad efectiva según multiplicador
function getEffectiveQuantity(building) {
    if (currentMultiplier === 'max') {
        return calculateMaxAffordable(building, partidos[partidoElegido].votos);
    }
    return currentMultiplier;
}

// --- EVENTOS DE MULTIPLICADOR ---
function initMultiplierEvents() {
    if (!multiplierBar) return;

    multiplierBar.querySelectorAll('button').forEach(btn => {
        btn.addEventListener('click', () => {
            // Quitar clase active de todos
            multiplierBar.querySelectorAll('button').forEach(b => b.classList.remove('active'));
            // Añadir clase active al clickeado
            btn.classList.add('active');

            // Actualizar multiplicador
            const mult = btn.dataset.mult;
            currentMultiplier = mult === 'max' ? 'max' : parseInt(mult);

            // Re-renderizar tienda para actualizar precios
            renderShop();
            updateDisplay();
        });
    });
}

// --- RENDERIZADO DE TIENDA ---
function renderShop() {
    // Si la lista de edificios está vacía o ha cambiado el número de edificios, reconstruir
    const totalBuildings = Object.keys(gameState.buildings).length;
    const currentElements = buildingsList.children.length;
    
    // Reconstrucción completa solo si es necesario (inicialización o cambio estructural)
    if (currentElements !== totalBuildings) {
        buildingsList.innerHTML = '';
        for (let key in gameState.buildings) {
            const b = gameState.buildings[key];
            
            const div = document.createElement('div');
            div.className = 'shop-item disabled';
            div.id = `shop-building-${key}`;
            div.dataset.type = key;
            div.dataset.category = 'building';
            div.innerHTML = `
                <div class="item-icon">${b.emoji}</div>
                <div class="item-info">
                    <div class="item-name">${b.name} <span class="bulk-qty"></span></div>
                    <div class="item-cost">Precio: ...</div>
                    <div style="font-size:0.75rem; color:#555;">Producción: ${b.baseVps.toLocaleString()} VPS c/u</div>
                    <div style="font-size:0.7rem; font-style:italic;">${b.desc}</div>
                </div>
                <div class="item-count">${b.count}</div>
            `;
            div.onclick = () => buyBuilding(key);
            buildingsList.appendChild(div);
        }
    }

    // Reconstruir lista de upgrades (aquí sí eliminamos los comprados, así que cambia a menudo)
    // Para optimizar, podríamos ocultarlos en lugar de borrarlos, pero son pocos.
    // Lo simplificamos regenerando siempre que se llame a renderShop, 
    // pero updateShopPrices solo tocará clases.
    upgradesList.innerHTML = '';
    for (let key in gameState.upgrades) {
        const u = gameState.upgrades[key];
        if (u.bought) continue;
        const div = document.createElement('div');
        div.className = 'shop-item disabled';
        div.id = `shop-upgrade-${key}`;
        div.dataset.type = key;
        div.dataset.category = 'upgrade';
        const costStr = u.cost >= 1000000
            ? (u.cost / 1000000).toFixed(1) + 'M'
            : u.cost.toLocaleString();
            
        div.innerHTML = `
            <div class="item-icon">✨</div>
            <div class="item-info">
                <div class="item-name">${u.name}</div>
                <div class="item-cost">Precio: ${costStr} Votos</div>
                <div style="font-size:0.75rem">${u.desc}</div>
            </div>
        `;
        div.onclick = () => buyUpgrade(key);
        upgradesList.appendChild(div);
    }
    
    // Actualizar valores
    updateShopPrices();
}

// Actualizar precios y estados dinámicamente sin tocar el DOM estructural
function updateShopPrices() {
    // 1. Actualizar Edificios
    for (let key in gameState.buildings) {
        const b = gameState.buildings[key];
        const el = document.getElementById(`shop-building-${key}`);
        if (!el) continue;

        let quantity = getEffectiveQuantity(b);
        // Si es 0 (no alcanza para ninguno en modo MAX), mostramos precio de 1 para saber meta
        let displayQuantity = quantity > 0 ? quantity : 1;
        
        const bulkCost = calculateBulkCost(b, displayQuantity);
        
        // Calcular si se puede comprar (usando la cantidad real calculada por getEffectiveQuantity)
        // Si quantity es 0, canAfford será false porque getEffectiveQuantity devuelve 0
        const canAfford = quantity > 0 && partidos[partidoElegido].votos >= bulkCost;
        
        // Actualizar estado visual (disabled)
        // En modo MAX, si quantity es 0, está disabled.
        // En modo x1/x10, si no tienes dinero, está disabled.
        if (canAfford) el.classList.remove('disabled');
        else el.classList.add('disabled');

        // Formatear costo
        const costStr = bulkCost >= 1000000
            ? (bulkCost / 1000000).toFixed(1) + 'M'
            : Math.floor(bulkCost).toLocaleString();

        const costEl = el.querySelector('.item-cost');
        const bulkQtyEl = el.querySelector('.bulk-qty');
        const countEl = el.querySelector('.item-count');

        // Actualizar indicador de cantidad
        if (quantity > 1) {
            bulkQtyEl.textContent = `x${quantity}`;
            bulkQtyEl.style.display = 'inline-block';
        } else {
            bulkQtyEl.style.display = 'none';
        }

        // Siempre mostrar VPS (usa displayQuantity que es mínimo 1)
        const totalVps = b.baseVps * displayQuantity;
        costEl.textContent = `Precio: ${costStr} Votos (+${totalVps.toLocaleString()} VPS)`;
        
        // Actualizar contador
        countEl.textContent = b.count;
    }

    // 2. Actualizar Upgrades (solo estado)
    for (let key in gameState.upgrades) {
        const u = gameState.upgrades[key];
        if (u.bought) continue;
        
        const el = document.getElementById(`shop-upgrade-${key}`);
        if (!el) continue;

        const canAfford = partidos[partidoElegido].votos >= u.cost;
        if (canAfford) el.classList.remove('disabled');
        else el.classList.add('disabled');
    }
}

// --- ACCIONES DE COMPRA ---
function buyBuilding(key) {
    if (gameState.gameOver || window.isGamePaused) return;
    const b = gameState.buildings[key];

    // Calcular cantidad según multiplicador
    const quantity = getEffectiveQuantity(b);
    const totalCost = calculateBulkCost(b, quantity);

    if (quantity > 0 && partidos[partidoElegido].votos >= totalCost) {
        audioSystem.playBuy();

        // Incrementar deuda e inflación (proporcional a la compra)
        gameState.deuda += totalCost;
        gameState.inflacion += 0.1 * quantity;

        partidos[partidoElegido].votos -= totalCost;
        b.count += quantity;
        // BALANCE v11: Actualizar precio con factor de escalado variable
        const scaleFactor = getScaleFactor(b.baseCost);
        b.cost *= Math.pow(scaleFactor, quantity);

        gameStats.edificiosTotalesComprados += quantity;
        sessionStats.edificiosComprados += quantity;

        markVpsDirty();
        calculateVPS();
        renderShop();
        updateDisplay();
    } else {
        audioSystem.playError();
    }
}

function buyUpgrade(key) {
    if (gameState.gameOver || window.isGamePaused) return;
    const u = gameState.upgrades[key];
    if (partidos[partidoElegido].votos >= u.cost && !u.bought) {
        audioSystem.playUnlock();
        // Incrementar deuda e inflación (cosmético)
        gameState.deuda += u.cost;
        gameState.inflacion += 0.1;

        partidos[partidoElegido].votos -= u.cost;
        u.bought = true;
        u.effect();
        gameStats.upgradesDesbloqueados++;
        sessionStats.upgradesComprados++;
        markVpsDirty();
        calculateVPS();
        renderShop();
        updateDisplay();
    } else if (!u.bought) {
        audioSystem.playError();
    }
}
