// Boomermania - Estado del Juego

let gameState = null;

function initGameState(personaje = null) {
    // Obtener personaje seleccionado o usar default
    const char = personaje || getPersonajeSeleccionado() || { id: 'manolo', nombre: 'Manolo', dineroInicial: 500000 };

    gameState = {
        // Info del jugador
        playerName: char.nombre || 'Manolo',
        personajeId: char.id || 'manolo',
        birthYear: 1955,

        // Sistema temporal expandido
        decadaIndex: 0,
        añoIndex: 0,           // 0-2 dentro de cada década
        accionesAño: 0,        // Acciones en el año actual
        maxAccionesPorAño: ESTRUCTURA_TEMPORAL.accionesPorAño,

        // Recursos personales del jugador (expandido con economía)
        playerResources: {
            // Economía
            dinero: char.dineroInicial || 500000,    // Pesetas (1975)
            sueldo: 0,                               // Ingresos mensuales
            ahorros: 0,                              // En el banco
            deuda: 0,                                // Hipotecas, préstamos

            // Recursos existentes
            vivienda: 0,      // Número de pisos
            empleo: 0,        // Nivel de empleo (0-4)
            pension: 0,       // % de hucha personal (0-100)
            ambiente: 100,    // Cuánto has contribuido a mantener (100 = nada, 0 = mucho daño)
            educacion: 0      // Nivel de coste educativo que votaste (0 = gratis, 4 = prohibitivo)
        },

        // Propiedades detalladas (para mantenimiento)
        propiedades: [],  // Array de { tipo, valor, añoCompra, estado }

        // Recursos globales (lo que queda para generaciones futuras)
        recursosGlobales: {
            viviendaDisponible: 100,
            empleoEstable: 100,
            huchaPensiones: 100,
            saludPlaneta: 100,
            educacionAccesible: 100
        },

        // Mejoras/acciones ya usadas
        mejorasUsadas: [],

        // Eventos vistos en esta partida
        eventosVistos: [],
        eventosAño: [],       // Eventos del año actual

        // Puntuación
        puntuacionBienestar: 0,
        puntuacionMiseria: 0,
        puntuacionTotal: 0,

        // Estado del juego
        juegoTerminado: false,
        juegoIniciado: false,
        runStartedAt: Date.now(),

        // Estadísticas expandidas
        stats: {
            pisosComprados: 0,
            empleoMaximo: 0,
            pensionMaxima: 0,
            accionesTotales: 0,
            eventosResueltos: 0,
            dineroMaximo: char.dineroInicial || 500000,
            dineroGastado: 0,
            mantenimientoPagado: 0,
            mantenimientoIgnorado: 0,
            añosJugados: 0,
            decadasCompletadas: 0
        }
    };

    // Aplicar bonus del personaje si existe
    if (char.bonus) {
        aplicarBonusPersonaje(char.bonus);
    }

    return gameState;
}

// Helper para aplicar bonus de personaje
function aplicarBonusPersonaje(bonus) {
    if (!bonus || !gameState) return;

    if (bonus.empleo) {
        gameState.playerResources.empleo = Math.min(4, bonus.empleo);
    }
    if (bonus.pension) {
        gameState.playerResources.pension += bonus.pension;
    }
    if (bonus.dinero) {
        gameState.playerResources.dinero += bonus.dinero;
    }
}

// Obtener década actual
function getDecadaActual() {
    if (!gameState || gameState.decadaIndex >= DECADAS.length) return null;
    return DECADAS[gameState.decadaIndex];
}

// Obtener periodo de año actual dentro de la década
function getPeriodoAñoActual() {
    const decada = getDecadaActual();
    if (!decada || !decada.años) return null;
    const añoIndex = gameState.añoIndex || 0;
    return decada.años[Math.min(añoIndex, decada.años.length - 1)];
}

// Obtener año actual (inicio del periodo)
function getAnoActual() {
    const periodo = getPeriodoAñoActual();
    return periodo ? periodo.inicio : (getDecadaActual()?.year || 2025);
}

// Obtener rango de años actual como string
function getRangoAñosActual() {
    const periodo = getPeriodoAñoActual();
    if (!periodo) return '2025';
    return `${periodo.inicio}-${periodo.fin}`;
}

// Obtener nombre del periodo actual
function getNombrePeriodoActual() {
    const periodo = getPeriodoAñoActual();
    return periodo ? periodo.nombre : '';
}

// Obtener edad del jugador (más precisa con años)
function getEdadJugador() {
    const decada = getDecadaActual();
    if (!decada) return 70;

    const edadBase = decada.playerAge;
    const añosExtra = (gameState.añoIndex || 0) * 3; // ~3 años por periodo
    return edadBase + añosExtra;
}

// Verificar si el juego ha terminado
function isJuegoTerminado() {
    return gameState && gameState.juegoTerminado;
}

// Calcular puntuación actual
function calcularPuntuacion() {
    if (!gameState) return 0;

    const bienestar = calcularBienestar(gameState.playerResources);
    const miseria = calcularMiseriaGeneracional(gameState.recursosGlobales);

    gameState.puntuacionBienestar = bienestar;
    gameState.puntuacionMiseria = miseria;

    // Fórmula con trade-off: mantiene la mecánica satírica pero penaliza extremos
    // - Factor miseria: multiplica bienestar por la miseria generada
    // - Penalización extrema: miseria >80% tiene coste adicional
    // - Bonus equilibrio: miseria entre 40-70% da bonus (cinismo calculado)
    const factorMiseria = 1 + (miseria / 100);
    const penalizacionExtrema = miseria > 80 ? (miseria - 80) * 2 : 0;
    const bonusEquilibrio = (miseria >= 40 && miseria <= 70) ? 100 : 0;
    gameState.puntuacionTotal = Math.floor((bienestar * factorMiseria) - penalizacionExtrema + bonusEquilibrio);

    return gameState.puntuacionTotal;
}

// Aplicar efectos de una acción
function aplicarEfectos(efectos) {
    if (!efectos || !gameState) return;

    // Aplicar cambios a recursos del jugador
    if (efectos.playerResources) {
        for (const [recurso, cambio] of Object.entries(efectos.playerResources)) {
            if (gameState.playerResources[recurso] !== undefined) {
                gameState.playerResources[recurso] += cambio;

                // Limitar valores
                if (recurso === 'pension') {
                    gameState.playerResources[recurso] = Math.min(100, Math.max(0, gameState.playerResources[recurso]));
                }
                if (recurso === 'empleo') {
                    gameState.playerResources[recurso] = Math.min(4, Math.max(0, gameState.playerResources[recurso]));
                }
                if (recurso === 'educacion') {
                    gameState.playerResources[recurso] = Math.min(4, Math.max(0, gameState.playerResources[recurso]));
                }
                if (recurso === 'vivienda') {
                    gameState.stats.pisosComprados += cambio;
                }
            }
        }

        // Actualizar stats
        if (gameState.playerResources.empleo > gameState.stats.empleoMaximo) {
            gameState.stats.empleoMaximo = gameState.playerResources.empleo;
        }
        if (gameState.playerResources.pension > gameState.stats.pensionMaxima) {
            gameState.stats.pensionMaxima = gameState.playerResources.pension;
        }
    }

    // Aplicar cambios a recursos globales
    if (efectos.recursosGlobales) {
        for (const [recurso, cambio] of Object.entries(efectos.recursosGlobales)) {
            if (gameState.recursosGlobales[recurso] !== undefined) {
                gameState.recursosGlobales[recurso] += cambio;
                // Limitar entre 0 y 100
                gameState.recursosGlobales[recurso] = Math.min(100, Math.max(0, gameState.recursosGlobales[recurso]));
            }
        }
    }

    // Recalcular puntuación
    calcularPuntuacion();
}

// Realizar una acción/mejora
function realizarMejora(mejoraId) {
    if (!gameState || gameState.juegoTerminado) return false;
    if (!quedanAcciones()) return false;

    const mejora = mejorasData[mejoraId];
    if (!mejora) return false;

    // Verificar si tiene dinero suficiente
    if (mejora.coste && mejora.coste.dinero) {
        const costeReal = calcularCosteMejora(mejoraId);
        if (gameState.playerResources.dinero < costeReal) {
            return false; // No tiene dinero
        }
        // Descontar dinero
        gameState.playerResources.dinero -= costeReal;
        gameState.stats.dineroGastado += costeReal;
    }

    // Aplicar efectos
    aplicarEfectos(mejora.efecto);

    // Registrar mejora
    if (!mejora.repeatable) {
        gameState.mejorasUsadas.push(mejoraId);
    }

    // Si es propiedad, añadirla a la lista
    if (mejora.categoria === 'vivienda' && mejora.efecto?.playerResources?.vivienda > 0) {
        gameState.propiedades.push({
            tipo: mejoraId,
            nombre: mejora.nombre,
            añoCompra: getAnoActual(),
            valor: mejora.coste?.dinero || 0,
            estado: 100,
            mantenimientosIgnorados: 0
        });
    }

    // Incrementar contadores (nuevo sistema de años)
    gameState.accionesAño++;
    gameState.stats.accionesTotales++;

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

    return true;
}

// Helper para calcular coste con inflación (placeholder - se completa en economia.js)
function calcularCosteConInflacion(costeBase) {
    // Se implementará completamente en economia.js
    if (typeof aplicarInflacion === 'function') {
        return aplicarInflacion(costeBase, 1975, getAnoActual());
    }
    return costeBase;
}

// Verificar si quedan acciones en el año actual
function quedanAcciones() {
    if (!gameState) return false;
    return gameState.accionesAño < gameState.maxAccionesPorAño;
}

// Obtener acciones restantes en el año
function getAccionesRestantes() {
    if (!gameState) return 0;
    return gameState.maxAccionesPorAño - gameState.accionesAño;
}

// Obtener total de acciones restantes en la década
function getAccionesRestantesDecada() {
    if (!gameState) return 0;
    const añosRestantes = ESTRUCTURA_TEMPORAL.añosPorDecada - gameState.añoIndex - 1;
    const accionesAñoActual = gameState.maxAccionesPorAño - gameState.accionesAño;
    return accionesAñoActual + (añosRestantes * gameState.maxAccionesPorAño);
}

// Resetear estado para nueva partida
function resetGameState() {
    initGameState();
}
