// Boomermania - Sistema de Economía

// Obtener multiplicador de inflación para un año
function getInflacionAño(año) {
    // Encontrar la década correspondiente
    const decadas = Object.keys(INFLACION).map(Number).sort((a, b) => a - b);
    let inflacion = 1;

    for (const decada of decadas) {
        if (año >= decada) {
            inflacion = INFLACION[decada];
        }
    }

    return inflacion;
}

// Aplicar inflación a una cantidad
function aplicarInflacion(cantidad, añoOrigen, añoActual) {
    if (añoOrigen >= añoActual) return cantidad;

    const inflacionOrigen = getInflacionAño(añoOrigen);
    const inflacionActual = getInflacionAño(añoActual);

    return Math.round(cantidad * (inflacionActual / inflacionOrigen));
}

// Aplicar inflación con tipo de bien específico
function aplicarInflacionTipo(cantidad, añoOrigen, añoActual, tipo = 'general') {
    const base = aplicarInflacion(cantidad, añoOrigen, añoActual);
    const multiplicador = INFLACION_POR_TIPO[tipo] || 1;

    // El multiplicador adicional solo aplica a la diferencia de inflación
    const añosTranscurridos = Math.floor((añoActual - añoOrigen) / 10);
    return Math.round(base * Math.pow(multiplicador, añosTranscurridos * 0.1));
}

// Calcular sueldo actual según nivel de empleo
function calcularSueldo(nivelEmpleo, añoActual) {
    if (nivelEmpleo <= 0) return 0;

    const sueldoBase = SUELDOS_BASE[nivelEmpleo] || 0;
    const incremento = INCREMENTO_SUELDO_DECADA[nivelEmpleo] || 0;

    // Aplicar inflación base
    let sueldo = aplicarInflacion(sueldoBase, 1975, añoActual);

    // Aplicar incremento por décadas trabajadas
    const decadasTrabajadas = Math.floor((añoActual - 1975) / 10);
    const multiplicadorIncremento = 1 + (incremento * decadasTrabajadas / 100);
    sueldo = Math.round(sueldo * multiplicadorIncremento);

    return sueldo;
}

// Calcular ingresos anuales totales (sueldo + propiedades)
function calcularIngresosAnuales() {
    if (!gameState) return 0;

    const añoActual = getAnoActual();
    let ingresos = 0;

    // Sueldo mensual × 14 pagas
    const sueldoMensual = calcularSueldo(gameState.playerResources.empleo, añoActual);
    ingresos += sueldoMensual * 14;

    // Ingresos por propiedades
    for (const prop of gameState.propiedades) {
        const ingresoBase = INGRESOS_PROPIEDADES[prop.tipo];
        if (ingresoBase) {
            const ingresoActual = aplicarInflacion(ingresoBase, 1975, añoActual);
            // Reducir según estado de la propiedad
            const factorEstado = prop.estado / 100;
            ingresos += Math.round(ingresoActual * factorEstado);
        }
    }

    return ingresos;
}

// Procesar ingresos al final de cada año
function procesarIngresosAño() {
    if (!gameState) return;

    const ingresos = calcularIngresosAnuales();

    // Dividir entre los 3 periodos del año (simplificado)
    const periodosPorDecada = ESTRUCTURA_TEMPORAL.añosPorDecada;
    const ingresoPeriodo = Math.round(ingresos / periodosPorDecada);

    gameState.playerResources.dinero += ingresoPeriodo;

    // Actualizar sueldo mostrado
    gameState.playerResources.sueldo = calcularSueldo(gameState.playerResources.empleo, getAnoActual());

    // Actualizar stats
    if (gameState.playerResources.dinero > gameState.stats.dineroMaximo) {
        gameState.stats.dineroMaximo = gameState.playerResources.dinero;
    }
}

// Calcular coste de una mejora con inflación
function calcularCosteMejora(mejoraId) {
    const costeBase = COSTES_BASE[mejoraId];
    if (!costeBase) return 0;

    const añoActual = getAnoActual();
    const mejora = mejorasData[mejoraId];

    // Determinar tipo de inflación según categoría
    let tipo = 'general';
    if (mejora?.categoria === 'vivienda') tipo = 'vivienda';
    else if (mejora?.categoria === 'educacion') tipo = 'educacion';
    else if (mejora?.categoria === 'ambiente') tipo = 'vehiculos';

    return aplicarInflacionTipo(costeBase, 1975, añoActual, tipo);
}

// Verificar si el jugador puede permitirse una mejora
function puedePermitirse(mejoraId) {
    if (!gameState) return false;

    const coste = calcularCosteMejora(mejoraId);
    return gameState.playerResources.dinero >= coste;
}

// Procesar cambios económicos al cambiar de década
function procesarCambioDecada() {
    if (!gameState) return;

    // Revalorizar propiedades por inflación de vivienda
    const añoActual = getAnoActual();
    for (const prop of gameState.propiedades) {
        if (prop.valor > 0) {
            // Las propiedades suben más que la inflación
            prop.valor = aplicarInflacionTipo(prop.valor, prop.añoCompra, añoActual, 'vivienda');
        }
    }

    // Actualizar sueldo
    gameState.playerResources.sueldo = calcularSueldo(gameState.playerResources.empleo, añoActual);
}

// Formatear cantidad de dinero para mostrar
function formatearDinero(cantidad, incluirMoneda = true) {
    const añoActual = getAnoActual();
    const esEuro = añoActual >= 2002;

    let valor = cantidad;
    let moneda = 'pts';

    if (esEuro) {
        // Convertir a euros (1 euro = 166.386 pesetas)
        valor = Math.round(cantidad / 166.386);
        moneda = '€';
    }

    // Formatear con separadores de miles
    const valorFormateado = valor.toLocaleString('es-ES');

    if (incluirMoneda) {
        return esEuro ? `${valorFormateado}${moneda}` : `${valorFormateado} ${moneda}`;
    }
    return valorFormateado;
}

// Obtener texto descriptivo del estado económico
function getEstadoEconomico() {
    if (!gameState) return 'Sin datos';

    const dinero = gameState.playerResources.dinero;
    const deuda = gameState.playerResources.deuda;
    const patrimonio = calcularPatrimonio();

    if (patrimonio > 50000000) return 'Millonario';
    if (patrimonio > 10000000) return 'Muy acomodado';
    if (patrimonio > 5000000) return 'Acomodado';
    if (patrimonio > 1000000) return 'Clase media-alta';
    if (patrimonio > 0) return 'Clase media';
    if (dinero > 0) return 'Justo';
    return 'Endeudado';
}

// Calcular patrimonio total
function calcularPatrimonio() {
    if (!gameState) return 0;

    let patrimonio = gameState.playerResources.dinero;
    patrimonio += gameState.playerResources.ahorros;
    patrimonio -= gameState.playerResources.deuda;

    // Valor de propiedades
    for (const prop of gameState.propiedades) {
        patrimonio += prop.valor * (prop.estado / 100);
    }

    return patrimonio;
}

// Obtener resumen económico para UI
function getResumenEconomico() {
    if (!gameState) return {};

    const añoActual = getAnoActual();

    return {
        dinero: formatearDinero(gameState.playerResources.dinero),
        sueldo: formatearDinero(calcularSueldo(gameState.playerResources.empleo, añoActual)) + '/mes',
        patrimonio: formatearDinero(calcularPatrimonio()),
        deuda: formatearDinero(gameState.playerResources.deuda),
        ingresosAnuales: formatearDinero(calcularIngresosAnuales()) + '/año',
        estado: getEstadoEconomico()
    };
}
