// Boomermania - Sistema de Mantenimiento

// Calcular costes de mantenimiento para todas las propiedades
function calcularCostesMantenimiento() {
    if (!gameState || !gameState.propiedades) return [];

    const añoActual = getAnoActual();
    const costes = [];

    for (let i = 0; i < gameState.propiedades.length; i++) {
        const prop = gameState.propiedades[i];
        const costeBase = calcularCosteMantenimientoProp(prop);
        const costeActual = aplicarInflacion(costeBase, 1975, añoActual);

        costes.push({
            index: i,
            propiedad: prop,
            coste: costeActual,
            tipo: prop.tipo,
            nombre: prop.nombre || getNombrePropiedad(prop.tipo),
            estado: prop.estado
        });
    }

    // Añadir mantenimiento de coche si tiene
    if (gameState.mejorasUsadas.includes('comprarCocheDiesel') ||
        gameState.mejorasUsadas.includes('suv')) {
        const cocheTipo = gameState.mejorasUsadas.includes('suv') ? 'suv' : 'cocheDiesel';
        const costeBase = MANTENIMIENTO.coche * COSTES_BASE.comprarCocheDiesel;
        const costeActual = aplicarInflacion(costeBase, 1975, añoActual);

        costes.push({
            index: -1,
            tipo: cocheTipo,
            nombre: cocheTipo === 'suv' ? 'SUV' : 'Coche Diésel',
            coste: costeActual,
            esVehiculo: true
        });
    }

    // Aplicar descuento por volumen (economía de escala)
    if (costes.length > 1) {
        // 10% descuento por cada propiedad extra, máximo 40%
        const descuento = Math.min(0.4, (costes.length - 1) * 0.1);
        costes.forEach((c, i) => {
            if (i > 0) {
                c.coste = Math.round(c.coste * (1 - descuento));
            }
        });
    }

    // Aplicar tope máximo basado en ingresos (si hay función disponible)
    if (typeof calcularIngresosAnuales === 'function' && typeof MAX_MANTENIMIENTO_PORCENTAJE !== 'undefined') {
        const ingresosAnuales = calcularIngresosAnuales();
        if (ingresosAnuales > 0) {
            const topeMantenimiento = ingresosAnuales * MAX_MANTENIMIENTO_PORCENTAJE;
            const totalActual = costes.reduce((sum, c) => sum + c.coste, 0);

            if (totalActual > topeMantenimiento) {
                const factor = topeMantenimiento / totalActual;
                costes.forEach(c => {
                    c.coste = Math.round(c.coste * factor);
                });
            }
        }
    }

    return costes;
}

// Calcular coste de mantenimiento de una propiedad específica
function calcularCosteMantenimientoProp(prop) {
    let tasa = MANTENIMIENTO.piso || 0.02;

    if (prop.tipo === 'segundaResidencia') {
        tasa = MANTENIMIENTO.segundaResidencia || 0.03;
    } else if (prop.tipo === 'localComercial') {
        tasa = MANTENIMIENTO.localComercial || 0.025;
    }

    return Math.round(prop.valor * tasa);
}

// Obtener nombre descriptivo de propiedad
function getNombrePropiedad(tipo) {
    const nombres = {
        'comprarPiso': 'Piso',
        'segundaResidencia': 'Segunda Residencia',
        'alquilerTuristico': 'Piso Turístico',
        'localComercial': 'Local Comercial',
        'garaje': 'Garaje'
    };
    return nombres[tipo] || 'Propiedad';
}

// Procesar pago de mantenimiento
function pagarMantenimiento(costeItem) {
    if (!gameState) return false;

    if (gameState.playerResources.dinero < costeItem.coste) {
        return false; // No tiene dinero
    }

    gameState.playerResources.dinero -= costeItem.coste;
    gameState.stats.mantenimientoPagado += costeItem.coste;

    // Restaurar estado de la propiedad y resetear contador de ignorados
    if (costeItem.index >= 0 && gameState.propiedades[costeItem.index]) {
        gameState.propiedades[costeItem.index].estado = 100;
        // Reset contador de mantenimientos ignorados al pagar
        gameState.propiedades[costeItem.index].mantenimientosIgnorados = 0;
    }

    return true;
}

// Ignorar mantenimiento de una propiedad
// Sistema suavizado: -10% estado, penalización solo después de 3 ignorados consecutivos
function ignorarMantenimiento(costeItem) {
    if (!gameState) return;

    gameState.stats.mantenimientoIgnorado++;

    if (costeItem.index >= 0 && gameState.propiedades[costeItem.index]) {
        const prop = gameState.propiedades[costeItem.index];

        // Reducir estado más suavemente (10% en vez de 20%)
        prop.estado -= 10;

        // Incrementar contador de mantenimientos ignorados
        prop.mantenimientosIgnorados = (prop.mantenimientosIgnorados || 0) + 1;

        // Penalización de valor solo después de 3 ignorados consecutivos Y estado bajo
        if (prop.mantenimientosIgnorados >= 3 && prop.estado <= 30) {
            // -15% del valor (era -30%)
            prop.valor = Math.round(prop.valor * 0.85);
            prop.mantenimientosIgnorados = 0; // Reset contador
            prop.estado = 30; // No baja de 30%
        }

        // Asegurar que el estado no baje de 10%
        if (prop.estado < 10) {
            prop.estado = 10;
        }
    } else if (costeItem.esVehiculo) {
        // Vehículo sin mantenimiento: probabilidad de multa/avería
        if (Math.random() < 0.3) {
            // Multa
            const multa = aplicarInflacion(50000, 1975, getAnoActual());
            gameState.playerResources.dinero -= multa;
        }
    }
}

// Vender propiedad
function venderPropiedad(costeItem) {
    if (!gameState || costeItem.index < 0) return false;

    const prop = gameState.propiedades[costeItem.index];
    if (!prop) return false;

    // Obtener valor actual (considerando estado)
    const valorVenta = Math.round(prop.valor * (prop.estado / 100) * 0.9); // 90% del valor

    // Añadir dinero
    gameState.playerResources.dinero += valorVenta;

    // Eliminar propiedad
    gameState.propiedades.splice(costeItem.index, 1);

    // Actualizar contador de viviendas
    if (gameState.playerResources.vivienda > 0) {
        gameState.playerResources.vivienda--;
    }

    return true;
}

// Calcular total de costes de mantenimiento
function getTotalMantenimiento() {
    const costes = calcularCostesMantenimiento();
    return costes.reduce((total, item) => total + item.coste, 0);
}

// Verificar si hay propiedades que necesitan mantenimiento
function hayMantenimientoPendiente() {
    const costes = calcularCostesMantenimiento();
    return costes.length > 0;
}

// Procesar mantenimiento automático (opción para modo fácil)
function procesarMantenimientoAutomatico() {
    const costes = calcularCostesMantenimiento();

    for (const item of costes) {
        if (gameState.playerResources.dinero >= item.coste) {
            pagarMantenimiento(item);
        } else {
            ignorarMantenimiento(item);
        }
    }
}
