app.py

### IMPORTACIONES
import numpy as np
import pandas as pd
import random
import multiprocessing
import io
import math
import os
import gradio as gr
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import base64
import sys

# La concurrencia con multiprocessing puede ser problemática en algunos entornos de hosting
# como Hugging Face Spaces. Usaremos el método 'spawn' explícitamente si es necesario.
# Sin embargo, para simplificar y asegurar compatibilidad, priorizaremos la versión Serial Optimizado.
# Si el método 'Concurrente' falla, se recomienda eliminarlo o usar una alternativa más segura.
try:
    if sys.platform == "linux" and "multiprocessing" in sys.modules:
        multiprocessing.set_start_method('spawn', force=True)
except Exception as e:
    # print(f"Advertencia al configurar start_method: {e}")
    pass


### --- MODIFICACIÓN CLAVE 1: RUTA Y CARGA DE IMÁGENES ---
# Las imágenes se asumen en la raíz del repositorio.
IMAGEN_PORTADA_PATH = "ImagenPortada.jpg"
IMAGEN_ENCABEZADO_PATH = "ImagenEncabezado.jpg"

# El módulo 'base64' se sigue usando porque es la forma más compatible de incluir
# imágenes en el CSS personalizado de Gradio.

def cargar_imagen_base64(path):
    """Carga una imagen local y la convierte a string Base64."""
    try:
        # Intentamos cargar la imagen localmente desde el repositorio
        with open(path, "rb") as f:
            encoded_image = base64.b64encode(f.read()).decode("utf-8")
        # Devolvemos la cadena Base64 con el prefijo de imagen
        return f"data:image/jpeg;base64,{encoded_image}", ""
    except FileNotFoundError:
        # Si la imagen no se encuentra (posible en ciertos entornos de build),
        # usamos un fallback y devolvemos un mensaje de error.
        error_msg = f"ERROR: No se encontró el archivo en la ruta: {path}. Usando fallback."
        return "none", error_msg

IMAGEN_PORTADA, PORTADA_ERROR = cargar_imagen_base64(IMAGEN_PORTADA_PATH)
IMAGEN_ENCABEZADO, ENCABEZADO_ERROR = cargar_imagen_base64(IMAGEN_ENCABEZADO_PATH)

# print(PORTADA_ERROR) # Opcional: imprimir los errores si existen
# print(ENCABEZADO_ERROR)


### DATOS DE ENTRADA (Mantenemos la carga desde string para no depender de archivos externos)
data_str = """
Piloto,Ptos,Media,Desv. STD,Probab_DNF
Lando Norris,357,19.83333,5.613796,0.111111111
Oscar Piastri,356,18.73684,7.553729,0.052631579
Max Verstappen,321,16.89474,8.368358,0.052631579
George Russell,258,13.57895,6.546216,0.052631579
Carlos Leclerc,210,11.66667,5.290113,0.111111111
"""

df_parametros_calculados = pd.read_csv(io.StringIO(data_str))

pilotos_data_from_excel = {}
for index, row in df_parametros_calculados.iterrows():
    pilotos_data_from_excel[row['Piloto']] = {
        'mu': row['Media'],
        'sigma': row['Desv. STD'],
        'dnf_prob': row['Probab_DNF']
    }

pilotos_nombres_simulacion = list(pilotos_data_from_excel.keys())
num_carreras = 22 # Ajustar según el número de carreras en la temporada 2025


### FUNCIONES DE SIMULACIÓN (Se mantienen, pero se elimina la necesidad de 'multiprocessing' si causa problemas)

def simular_carrera(piloto_data):
    """Simula los puntos de un piloto en una carrera."""
    if random.random() < piloto_data['dnf_prob']:
        return 0 # DNF o no puntuó
    return max(0, round(np.random.normal(piloto_data['mu'], piloto_data['sigma'])))

# La función monte_carlo_serial_optimizado (usando NumPy) es la mejor opción para HF.
def monte_carlo_serial_optimizado(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
    """Simulación Monte Carlo optimizada con NumPy."""
    mus = np.array([pilotos_data[p]['mu'] for p in pilotos_nombres])
    sigmas = np.array([pilotos_data[p]['sigma'] for p in pilotos_nombres])
    dnf_probs = np.array([pilotos_data[p]['dnf_prob'] for p in pilotos_nombres])

    # Generar todas las bases de puntos y máscaras DNF a la vez
    base_points = np.random.normal(mus, sigmas, size=(num_simulaciones, num_carreras, len(pilotos_nombres)))
    dnf_mask = np.random.rand(num_simulaciones, num_carreras, len(pilotos_nombres)) < dnf_probs

    # Aplicar DNF y redondear
    final_points = np.where(dnf_mask, 0, np.maximum(0, np.round(base_points))).astype(int)

    # Sumar puntos por temporada
    temporada_scores = np.sum(final_points, axis=1)

    # Encontrar el índice del campeón en cada simulación
    campeones_indices = np.argmax(temporada_scores, axis=1)

    # Contar cuántas veces ganó el piloto objetivo
    target_driver_index = pilotos_nombres.index(target_driver)
    target_driver_campeon_count = np.sum(campeones_indices == target_driver_index)

    return target_driver_campeon_count

# La función monte_carlo_concurrente queda en desuso o se usa con precaución.
# Se recomienda usar solo 'Serial Optimizado' en entornos de hosting limitados.
# Mantenemos el código si el usuario desea probarlo y acepta el riesgo de error.
# ... (código de monte_carlo_serial y monte_carlo_concurrente sin cambios sustanciales en la lógica) ...

# Funciones worker y wrapper para concurrencia (se mantienen para que el código funcione
# si el usuario selecciona "Concurrente", pero con la advertencia de compatibilidad)
def simular_temporada_worker_concurrent(pilotos_data_param, pilotos_nombres_param,
                                        num_carreras_param, target_driver_name_param):
    # Asegurar seeds únicos por proceso
    np.random.seed(os.getpid() + random.randint(0, 10000))
    random.seed(os.getpid() + random.randint(0, 10000))

    puntos_temporada = {piloto: 0 for piloto in pilotos_nombres_param}

    for _ in range(num_carreras_param):
        for piloto in pilotos_nombres_param:
            if random.random() < pilotos_data_param[piloto]['dnf_prob']:
                puntos = 0
            else:
                puntos = max(0, round(np.random.normal(pilotos_data_param[piloto]['mu'], pilotos_data_param[piloto]['sigma'])))
            puntos_temporada[piloto] += puntos

    if not puntos_temporada or all(pts == 0 for pts in puntos_temporada.values()):
        campeon_actual = pilotos_nombres_param[0] if pilotos_nombres_param else None
    else:
        campeon_actual = max(puntos_temporada, key=puntos_temporada.get)

    return 1 if campeon_actual == target_driver_name_param else 0

def worker_function_concurrent_wrapper(args):
    num_sims_per_worker, pilotos_data_param, pilotos_nombres_param, num_carreras_param, target_driver_name_param = args
    local_target_driver_campeon_count = 0
    for _ in range(num_sims_per_worker):
        local_target_driver_campeon_count += simular_temporada_worker_concurrent(
            pilotos_data_param, pilotos_nombres_param, num_carreras_param, target_driver_name_param
        )
    return local_target_driver_campeon_count

def monte_carlo_concurrente(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
    num_processes = multiprocessing.cpu_count() if multiprocessing.cpu_count() else 2
    # print(f"Usando {num_processes} procesos para la simulación concurrente.") # Descomentar para debug en HF

    sims_per_process = [num_simulaciones // num_processes] * num_processes
    for i in range(num_simulaciones % num_processes):
        sims_per_process[i] += 1

    args_for_pool = [
        (sims, pilotos_data, pilotos_nombres, num_carreras, target_driver) for sims in sims_per_process
    ]

    # Usar 'with' asegura que el pool se cierre
    with multiprocessing.Pool(num_processes) as pool:
        results = pool.map(worker_function_concurrent_wrapper, args_for_pool)

    total_target_driver_campeon_count = sum(results)
    return total_target_driver_campeon_count

# Función auxiliar (serial, la versión simple)
def monte_carlo_serial(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
    target_driver_campeon_count = 0
    for _ in range(num_simulaciones):
        puntos_temporada = {piloto: 0 for piloto in pilotos_nombres}
        for _ in range(num_carreras):
            for piloto in pilotos_nombres:
                puntos_temporada[piloto] += simular_carrera(pilotos_data[piloto])

        # ... (Lógica para determinar el campeón y contar) ...
        if not puntos_temporada or all(pts == 0 for pts in puntos_temporada.values()):
            campeon_actual = pilotos_nombres[0] if pilotos_nombres else None
        else:
            campeon_actual = max(puntos_temporada, key=puntos_temporada.get)

        if campeon_actual == target_driver:
            target_driver_campeon_count += 1
    return target_driver_campeon_count

# ... (El resto de las funciones create_data_viz_tab y run_simulation se mantienen sin cambios) ...

def create_data_viz_tab():
    # 1. Raw Data Table
    data_table = gr.Dataframe(
        value=df_parametros_calculados,
        headers=list(df_parametros_calculados.columns),
        datatype=[
            "str", "number", "number", "number", "number"
        ],
        row_count=len(df_parametros_calculados),
        col_count=len(df_parametros_calculados.columns),
        label="Parámetros de Pilotos (Temporada 2025)",
        interactive=False,
        wrap=True
    )


    ### GRÁFICO DE PUNTOS ACUMULADOS
    fig_accumulated = go.Figure()

    simulated_season_points = {piloto: [0] for piloto in pilotos_nombres_simulacion}

    for race_num in range(num_carreras):
        for piloto in pilotos_nombres_simulacion:
            current_points = simular_carrera(pilotos_data_from_excel[piloto])
            simulated_season_points[piloto].append(simulated_season_points[piloto][-1] + current_points)

    for piloto, points_list in simulated_season_points.items():
        fig_accumulated.add_trace(go.Scatter(x=list(range(num_carreras + 1)),
                                             y=points_list, mode='lines+markers', name=piloto))

    fig_accumulated.update_layout(
        title="Puntaje Acumulado por Carrera (Simulación de Temporada 2025)",
        xaxis_title="Número de Carrera",
        yaxis_title="Puntos Acumulados",
        hovermode="x unified",
        xaxis=dict(range=[0, num_carreras]),
        shapes=[
            dict(
                type="line",
                xref="x", yref="paper",
                x0=0, y0=0, x1=0, y1=1,
                line=dict(
                    color="red",
                    width=2,
                    dash="dot",
                ),
            )
        ],
        annotations=[
            dict(
                x=0, y=1.05,
                xref="x", yref="paper",
                text="Inicio de la Simulación",
                showarrow=False,
                font=dict(
                    color="red",
                    size=10
                ),
                xanchor="left"
            )
        ]
    )

    plot_accumulated = gr.Plot(fig_accumulated, label="Puntos Acumulados por Piloto")

    return gr.Column(
        gr.Markdown("## Datos de Pilotos y Visualización de Puntos Acumulados"),
        data_table,
        plot_accumulated
    )

def run_simulation(target_driver, simulation_method, num_sims):
    # Validaciones básicas
    if not target_driver:
        return "Por favor, selecciona un piloto.", None
    if not simulation_method:
        return "Por favor, selecciona un método de simulación.", None
    if num_sims < 1:
        return "El número de simulaciones debe ser al menos 1.", None

    wins = 0
    if simulation_method == "Serial":
        wins = monte_carlo_serial(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
    elif simulation_method == "Serial Optimizado":
        # Usamos la versión optimizada con NumPy
        wins = monte_carlo_serial_optimizado(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
    elif simulation_method == "Concurrente":
        # Advertencia: La concurrencia puede fallar en algunos entornos de HF Spaces.
        try:
            wins = monte_carlo_concurrente(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
        except Exception as e:
            error_msg = f"ERROR: Falló el método Concurrente (multiprocessing). Prueba con 'Serial Optimizado'. Detalle: {e}"
            return error_msg, None
    else:
        return "Método de simulación no válido.", None

    prob = wins / num_sims

    labels = [target_driver + " Gana", "Otros Ganan"]
    values = [wins, num_sims - wins]

    fig_pie = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.3)])
    fig_pie.update_layout(
        title=f"Probabilidad de que {target_driver} sea Campeón",
        annotations=[dict(text=f'{prob:.2%}', x=0.5, y=0.5, font_size=20, showarrow=False)]
    )

    result_text = f"Resultados de la simulación para {target_driver} usando el método '{simulation_method}' con {num_sims} simulaciones:\n" \
                  f"Victorias de {target_driver}: {wins}\n" \
                  f"Probabilidad de ser campeón: {prob:.4f} ({prob:.2%})"

    return result_text, fig_pie


### DEFINIR LOS ESTILOS PARA LA TARJETA CON LA IMAGEN DE FONDO
# Usamos las variables IMAGEN_PORTADA e IMAGEN_ENCABEZADO que contienen el Base64
css_style = f"""
/* ESTILO PARA LA TARJETA DE PORTADA*/
.f1-background-card {{
    background-image: url('{IMAGEN_PORTADA}');
    background-size: cover;
    background-position: center;
    background-blend-mode: multiply;
    background-color: rgba(255, 255, 255, 0.2);
    border-radius: 15px;
    box-shadow:
        8px 8px 15px rgba(0, 0, 0, 0.7),
        -8px -8px 15px rgba(0, 0, 0, 0.3);
    padding: 30px;
    min-height: 500px;
}}

/* ESTILO PARA LA TARJETA DE ENCABEZADO*/
.f1-header-card {{
    background-image: url('{IMAGEN_ENCABEZADO}');
    background-size: cover;
    border-radius: 15px;
    box-shadow:
        8px 8px 15px rgba(0, 0, 0, 0.7),
        -8px -8px 15px rgba(0, 0, 0, 0.3);
    padding: 30px;
    height: 50px;
}}

/* ESTILO PARA EL TÍTULO PRINCIPAL */
.title * {{
    font-size: 60px !important;
    text-shadow: 2px 2px 6px rgba(0,0,0,1);
    line-height: 1.3;
    color: white !important;
}}

/* ESTILO PARA EL SUBTÍTULO */
.subtitle * {{
    font-size: 30px !important;
    font-weight: 400;
    margin-top: 10px;
    line-height: 1.3;
    text-shadow: 2px 2px 6px rgba(0,0,0,1);
    color: white !important;
}}
"""

### INTERFAZ GRADIO (Se mantiene la estructura Blocks)

with gr.Blocks(css=css_style) as demo:
    gr.Row(elem_classes=["f1-header-card"])

    with gr.Tab("Inicio"):
        with gr.Column(elem_classes=["f1-background-card"]):
            gr.Markdown("Análisis de Campeón de F1 2025<br>Simulación Monte Carlo",
                         elem_classes=["title"])
            gr.Markdown("<br><br><br><br>Esta aplicación simula el campeonato de F1 2025<br>"
                         "usando diferentes algoritmos de Monte Carlo<br>"
                         "para predecir la probabilidad de que un piloto sea campeón.",
                         elem_classes=["subtitle"])

    with gr.Tab("Datos y Visualización"):
        create_data_viz_tab()

    with gr.Tab("Simulación de Campeonato"):
        with gr.Row():
            with gr.Column(scale=1): # Left menu
                gr.Markdown("### Configuración de la Simulación")
                driver_dropdown = gr.Dropdown(
                    choices=pilotos_nombres_simulacion,
                    value="Lando Norris", # Cambiado a un valor inicial fijo
                    label="Seleccionar Piloto Objetivo"
                )
                method_dropdown = gr.Dropdown(
                    choices=["Serial", "Serial Optimizado", "Concurrente"],
                    value="Serial Optimizado",
                    label="Método de Simulación"
                )
                sims_slider = gr.Slider(
                    minimum=100000,
                    maximum=1000000,
                    step=100000,
                    value=500000,
                    label="Número de Simulaciones"
                )
                run_button = gr.Button("Ejecutar Simulación")

            with gr.Column(scale=2): # Right display area
                gr.Markdown("### Resultados de la Simulación")
                simulation_output_text = gr.Textbox(
                    label="Detalles de la Simulación",
                    interactive=False,
                    lines=5
                )
                simulation_output_plot = gr.Plot(label="Probabilidad de Campeonato")

        run_button.click(
            run_simulation,
            inputs=[driver_dropdown, method_dropdown, sims_slider],
            outputs=[simulation_output_text, simulation_output_plot]
        )

# --- MODIFICACIÓN CLAVE 2: ELIMINAR EL PARÁMETRO 'share=True' ---
# Hugging Face Spaces se encarga del hosting, no necesitamos el túnel de Gradio.
demo.launch()