import streamlit as st
import time
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import matplotlib.pyplot as plt
import numpy as np
import lightgbm as lgb
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics import mean_absolute_error, mean_squared_error
from joblib import dump, load
from utils import recomienda_tf
import requests

# Page configuration
st.set_page_config(page_title="DeepInsightz", page_icon=":bar_chart:", layout="wide")

# Custom CSS for dynamic theme styling
# Streamlit detects light and dark mode automatically via the user's settings in Hugging Face Spaces
if st.get_option("theme.base") == "dark":
    background_color = "#282828"
    text_color = "white"
    metric_box_color = "#4f4f4f"
    sidebar_color = "#282828"
    plot_bgcolor = "rgba(0, 0, 0, 0)"
    primary_color = '#00FF00'  # for positive delta
    negative_color = '#FF0000'  # for negative delta
else:
    background_color = "#f4f4f4"
    text_color = "#black"
    metric_box_color = "#dee2e8"
    sidebar_color = "#dee2e8"
    plot_bgcolor = "#f4f4f4"
    primary_color = '#228B22'  # for positive delta in light mode
    negative_color = '#8B0000'  # for negative delta in light mode

st.markdown(f"""
    <style>
    body {{
        background-color: {background_color};
        color: {text_color};
    }}
    [data-testid="stMetric"] {{
        background-color: {metric_box_color};
        border-radius: 10px;
        text-align: center;
        padding: 15px 0;
        margin-bottom: 20px;
    }}
    [data-testid="stMetricLabel"] {{
        display: flex;
        justify-content: center;
        align-items: center;
        color: {text_color};
    }}
    [data-testid="stSidebar"] {{
        background-color: {sidebar_color};
    }}
    </style>
""", unsafe_allow_html=True)

# Load CSV files at the top
df = pd.read_csv("df_clean.csv")
nombres_proveedores = pd.read_csv("nombres_proveedores.csv", sep=';')
euros_proveedor = pd.read_csv("euros_proveedor.csv", sep=',')
ventas_clientes = pd.read_csv("ventas_clientes.csv", sep=',')
customer_clusters = pd.read_csv('predicts/customer_clusters.csv')  # Load the customer clusters here
df_agg_2024 = pd.read_csv('predicts/df_agg_2024.csv')
pca_data_5 = pd.read_csv('pca_data.csv')
historical_data = pd.read_csv('historical_data.csv')


with st.sidebar:
    st.image("logo/logo.png", use_column_width=True)
    page = st.sidebar.selectbox("Selecciona la herramienta que quieres utilizar...", ["📃 Resumen", "🕵️ Análisis de Cliente", "💡 Recomendación de Artículos"])

# Generamos la columna total_sales
ventas_clientes['total_sales'] = ventas_clientes[['VENTA_2021', 'VENTA_2022', 'VENTA_2023']].sum(axis=1)
ventas_clientes_3 = ventas_clientes
ventas_clientes_3['total_sales'] = ventas_clientes['total_sales'] / 3
# Ordenar los clientes de mayor a menor según sus ventas totales
ventas_top_100 = ventas_clientes.sort_values(by='total_sales', ascending=False).head(100)
ventas_top_100['total_sales'] = ventas_top_100['total_sales'] / 3


# Ensure customer codes are strings
df['CLIENTE'] = df['CLIENTE'].astype(str)
nombres_proveedores['codigo'] = nombres_proveedores['codigo'].astype(str)
euros_proveedor['CLIENTE'] = euros_proveedor['CLIENTE'].astype(str)
customer_clusters['cliente_id'] = customer_clusters['cliente_id'].astype(str)  # Ensure customer IDs are strings
fieles_df = pd.read_csv("clientes_relevantes.csv")
cestas = pd.read_csv("cestas.csv")
productos = pd.read_csv("productos.csv")
df_agg_2024['cliente_id'] = df_agg_2024['cliente_id'].astype(str)
marca_id_mapping = load('marca_id_mapping.joblib')

# Convert all columns except 'CLIENTE' to float in euros_proveedor
for col in euros_proveedor.columns:
    if col != 'CLIENTE':
        euros_proveedor[col] = pd.to_numeric(euros_proveedor[col], errors='coerce')

# Check for NaN values after conversion
if euros_proveedor.isna().any().any():
    st.warning("Some values in euros_proveedor couldn't be converted to numbers. Please review the input data.")

# Ignore the last two columns of df
df = df.iloc[:, :-2]

# Function to get supplier name
def get_supplier_name(code):
    code = str(code)  # Ensure code is a string
    name = nombres_proveedores[nombres_proveedores['codigo'] == code]['nombre'].values
    return name[0] if len(name) > 0 else code

def image_exists(url):
    """Verifica si la imagen existe en la URL proporcionada"""
    response = requests.head(url)
    return response.status_code == 200

def get_supplier_name_encoded(encoded_code):
    try:
        # Ensure the encoded code is an integer
        encoded_code = int(encoded_code)
        print(f"Encoded Code: {encoded_code}")

        # Use the label encoder to map the encoded code back to the original manufacturer code
        if encoded_code < len(marca_id_mapping.classes_):
            real_code = marca_id_mapping.inverse_transform([encoded_code])[0]
            print(f"Real Manufacturer Code: {real_code}")
        else:
            print(f"Encoded code not found in the label encoder: {encoded_code}")
            return f"Unknown code: {encoded_code}"  # Handle case where encoded code is not found

        # Now, use the real_code to find the manufacturer name in nombres_proveedores
        name = nombres_proveedores[nombres_proveedores['codigo'] == str(real_code)]['nombre'].values
        print(f"Manufacturer Name Found: {name}")  # Check what name is returned

        # Return the manufacturer name if found, otherwise return the real_code
        return name[0] if len(name) > 0 else real_code

    except Exception as e:
        print(f"Error encountered: {e}")
        return f"Error for code: {encoded_code}"

# Custom Donut Chart with Plotly for Inbound/Outbound Percentage
def create_donut_chart(values, labels, color_scheme, title):
    fig = px.pie(
        values=values, 
        names=labels, 
        hole=0.7,
        color_discrete_sequence=color_scheme
    )
    fig.update_traces(textinfo='percent+label', hoverinfo='label+percent', textposition='inside', showlegend=False)
    fig.update_layout(
        annotations=[dict(text=f"{int(values[1])}%", x=0.5, y=0.5, font_size=40, showarrow=False)],
        title=title,
        height=300,
        margin=dict(t=30, b=10, l=10, r=10),
        paper_bgcolor=plot_bgcolor,  # Use theme-dependent background color
        plot_bgcolor=plot_bgcolor
    )
    return fig

# Donut chart with color scheme based on theme
if st.get_option("theme.base") == "dark":
    donut_color_scheme = ['#155F7A', '#29b5e8']  # Dark mode colors
else:
    donut_color_scheme = ['#007BFF', '#66b5ff']  # Light mode colors

# Function to create radar chart with square root transformation
def radar_chart(categories, values, amounts, title):
    N = len(categories)
    angles = [n / float(N) * 2 * np.pi for n in range(N)]
    angles += angles[:1]
    
    fig, ax = plt.subplots(figsize=(12, 12), subplot_kw=dict(projection='polar'))
    
    # Apply square root transformation
    sqrt_values = np.sqrt(values)
    sqrt_amounts = np.sqrt(amounts)
    
    max_sqrt_value = max(sqrt_values)
    normalized_values = [v / max_sqrt_value for v in sqrt_values]
    
    # Adjust scaling for spend values
    max_sqrt_amount = max(sqrt_amounts)
    scaling_factor = 0.7  # Adjust this value to control how much the spend values are scaled up
    normalized_amounts = [min((a / max_sqrt_amount) * scaling_factor, 1.0) for a in sqrt_amounts]
    
    normalized_values += normalized_values[:1]
    ax.plot(angles, normalized_values, 'o-', linewidth=2, color='#FF69B4', label='% Units (sqrt)')
    ax.fill(angles, normalized_values, alpha=0.25, color='#FF69B4')
    
    normalized_amounts += normalized_amounts[:1]
    ax.plot(angles, normalized_amounts, 'o-', linewidth=2, color='#4B0082', label='% Spend (sqrt)')
    ax.fill(angles, normalized_amounts, alpha=0.25, color='#4B0082')
    
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(categories, size=8, wrap=True)
    ax.set_ylim(0, 1)
    
    circles = np.linspace(0, 1, 5)
    for circle in circles:
        ax.plot(angles, [circle]*len(angles), '--', color='gray', alpha=0.3, linewidth=0.5)
    
    ax.set_yticklabels([])
    ax.spines['polar'].set_visible(False)
    
    plt.title(title, size=16, y=1.1)
    plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
    
    return fig



if page == "📃 Resumen":
    st.title("Obten información valiosa para hacer crecer tu negocio")

    # Create layout with two columns
    col1, col2 = st.columns((2, 4), gap='medium')

    # Left Column: Display the image
    with col1:

        st.image("images/foto_1.png", use_column_width=True)

    # Right Column: Display the text
    with col2:
        st.markdown("""
        ### 🕵️ Análisis de Cliente
        Adelántate a las necesidades de tus clientes. 
        Obtén datos clave al instante y detecta con antelación sus necesidades para ofrecerles justo lo que necesitan.
        """)
        st.markdown("""
        ### 💡 Recomendación de Artículos
        Incrementa el valor de la cesta media mediante venta cruzada.
        Nuestro sistema de recomendaciones analiza las compras anteriores de tus clientes para identificar oportunidades perfectas de venta cruzada. 
        De esta manera facilitas la recomendación de productos a tus clientes que tienen sentido y que puede que hayan olvidado pedirlos.
""")

    # Create layout with three columns
    col1, col2, col3 = st.columns((1.5, 4, 2.5), gap='medium')

    # Left Column (Red): Metrics and Donut Charts
    with col1:
        st.markdown('#### Información General')
        st.metric(label="Rango de fechas", value="2021-2023")
        st.metric(label="Clientes analizados", value="3.000")
        st.metric(label="Productos únicos vendidos", value="10.702")
        st.metric(label="Líneas de venta totales", value="764.396")
        


    # Middle Column (White): 3D Cluster Model and Bar Chart
    with col2:
        st.markdown('#### Cluster de Clientes 3D')

        # Create 3D PCA plot using actual data from pca_data_5
        fig_cluster = px.scatter_3d(
            pca_data_5, 
            x='PC1', 
            y='PC2', 
            z='PC3', 
            color='cluster_id', 
            hover_name='CustomerID',
            color_continuous_scale='Turbo'
        )
        fig_cluster.update_layout(
            scene=dict(aspectratio=dict(x=1, y=1, z=0.8)),  # Adjusted aspect ratio for better balance
            margin=dict(t=10, b=10, l=10, r=10),  # Tighten margins further
            height=600,  # Slightly increased height for better visibility
        )
        st.plotly_chart(fig_cluster, use_container_width=True)
    
    # Right Column (Blue): Key Metrics Overview and Data Preparation Summary
    with col3:
        # Mostrar la tabla con los 100 mejores clientes
        st.markdown('#### Top 100 Clientes')

        # Configurar columnas para mostrar los clientes y las ventas totales
        st.dataframe(ventas_top_100[['codigo_cliente', 'total_sales']],
                    column_order=("codigo_cliente", "total_sales"),
                    hide_index=True,
                    width=350,  # Ajustar el ancho de la tabla
                    height=400,  # Ajustar la altura de la tabla
                    column_config={
                        "codigo_cliente": st.column_config.TextColumn(
                            "Código de Cliente",
                        ),
                        "total_sales": st.column_config.ProgressColumn(
                            "Venta Total (€)",
                            format="%d",
                            min_value=0,
                            max_value=ventas_top_100['total_sales'].max()
                        )}
                    )
        # Calculate sales insights
        sales_min = ventas_clientes[ventas_clientes['total_sales'] > 0]['total_sales'].min()
        sales_max = ventas_clientes['total_sales'].max()
        sales_median = ventas_clientes['total_sales'].median()
        sales_90th = ventas_clientes['total_sales'].quantile(0.9)
        sales_10th = ventas_clientes['total_sales'].quantile(0.1)

        # About Section with relevant data insights
        with st.expander('Clientes al detalle', expanded=True):
            st.write(f'''
                - **Venta Mediana**: €{sales_median:,.0f} .
                - **Percentil 90**: €{sales_90th:,.0f}.
                - **Percentil 10**: €{sales_10th:,.0f}.
            ''')
# Customer Analysis Page
elif page == "🕵️ Análisis de Cliente":
    st.markdown("""
    <h2 style='text-align: center; font-size: 2.5rem;'>Análisis de Cliente</h2>
    <p style='text-align: center; font-size: 1.2rem; color: gray;'> 
    Introduce el código del cliente para explorar información detallada del mismo, incluyendo ventas anteriores, predicciones para el año actual e información específica por fabricante.
    </p>
    """, unsafe_allow_html=True)

    # Combine text input and dropdown into a single searchable selectbox
    customer_code = st.selectbox(
        "Escribe o selecciona el código de tu cliente",
        df['CLIENTE'].unique(),  # All customer codes

        format_func=lambda x: str(x),  # Ensures the values are displayed as strings
        help="Start typing to search for a specific customer code"
    )

    # Fabricante dropdown (with 'Todos' option)
    fabricantes = ["Todos"] + list(nombres_proveedores['nombre'].unique())  # Agregar la opción 'Todos'
    fabricante_seleccionado = st.selectbox(
        "Selecciona el fabricante (o Todos)",
        fabricantes,
        help="Selecciona un fabricante específico o 'Todos' para ver todos los fabricantes"
    )

    if st.button("Calcular"):
        if customer_code:
            with st.spinner("Estamos identificando el grupo del cliente..."):
                # Find Customer's Cluster
                customer_match = customer_clusters[customer_clusters['cliente_id'] == customer_code]
                time.sleep(1)
                
                if not customer_match.empty:
                    cluster = customer_match['cluster_id'].values[0]
            
            if fabricante_seleccionado == "Todos":
                # Actuar como el comportamiento actual                
                with st.spinner(f"Seleccionando el modelo predictivo..."):
                    # Load the Corresponding Model
                    model_path = f'models/modelo_cluster_{cluster}.txt'
                    gbm = lgb.Booster(model_file=model_path)

                with st.spinner("Preparando los datos..."):
                    # Load predict data for that cluster
                    predict_data = pd.read_csv(f'predicts/predict_cluster_{cluster}.csv')
                    
                    # Convert cliente_id to string
                    predict_data['cliente_id'] = predict_data['cliente_id'].astype(str)

                with st.spinner("Filtrando data..."):
                    # Filter for the specific customer
                    customer_code_str = str(customer_code)
                    customer_data = predict_data[predict_data['cliente_id'] == customer_code_str]

                with st.spinner("Geneerando predicciones de venta..."):
                    if not customer_data.empty:
                        # Define features consistently with the training process
                        lag_features = [f'precio_total_lag_{lag}' for lag in range(1, 25)]
                        features = lag_features + ['mes', 'marca_id_encoded', 'año', 'cluster_id']
        
                        # Prepare data for prediction
                        X_predict = customer_data[features]

                        # Convert categorical features to 'category' dtype
                        categorical_features = ['mes', 'marca_id_encoded', 'cluster_id']
                        for feature in categorical_features:
                            X_predict[feature] = X_predict[feature].astype('category')
                        
                        # Make Prediction for the selected customer
                        y_pred = gbm.predict(X_predict, num_iteration=gbm.best_iteration)

                        # Reassemble the results
                        results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
                        results['ventas_predichas'] = y_pred

                        # Load actual data from df_agg_2024
                        actual_sales = df_agg_2024[df_agg_2024['cliente_id'] == customer_code_str]
                        
                        if not actual_sales.empty:
                            # Merge predictions with actual sales
                            results = results.merge(actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
                                                    on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], 
                                                    how='left')
                            results.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
                        else:
                            # If no actual sales data for 2024, fill 'ventas_reales' with 0
                            results['ventas_reales'] = 0

                        # Ensure any missing sales data is filled with 0
                        results['ventas_reales'].fillna(0, inplace=True)

                        # Define the cutoff date for the last 12 months
                        fecha_inicio = pd.to_datetime("2023-01-01")
                        fecha_corte = pd.to_datetime("2024-09-01")

                        # Convertir fecha_mes a datetime en el DataFrame historical_data
                        historical_data['fecha_mes'] = pd.to_datetime(historical_data['fecha_mes'], errors='coerce')

                        # Ensure cliente_id is of type string and strip any leading/trailing whitespace
                        historical_data['cliente_id'] = historical_data['cliente_id'].astype(str).str.strip()
                        customer_code_str = str(customer_code).strip()  # Ensure the customer code is also properly formatted

                        filtered_historical_data = historical_data[historical_data['cliente_id'] == customer_code_str]


                        # Filtrar los datos históricos por cliente y por el rango de fechas (2023)
                        fecha_inicio_2023 = pd.to_datetime("2023-01-01")
                        fecha_fin_2023 = pd.to_datetime("2023-12-31")

                        datos_historicos = historical_data[
                            (historical_data['cliente_id'] == customer_code_str) &
                            (historical_data['fecha_mes'] >= fecha_inicio_2023) &
                            (historical_data['fecha_mes'] <= fecha_fin_2023)
                        ].groupby('fecha_mes')['precio_total'].sum().reset_index()

                        # Renombrar la columna 'precio_total' a 'ventas_historicas' si no está vacía
                        if not datos_historicos.empty:
                            datos_historicos.rename(columns={'precio_total': 'ventas_historicas'}, inplace=True)
                        else:
                            # Si los datos históricos están vacíos, generar fechas de 2023 con ventas_historicas = 0
                            fechas_2023 = pd.date_range(start='2023-01-01', end='2023-12-31', freq='M')
                            datos_historicos = pd.DataFrame({'fecha_mes': fechas_2023, 'ventas_historicas': [0] * len(fechas_2023)})

                        # Filtrar los datos de predicciones y ventas reales para 2024
                        datos_cliente_total = results.groupby('fecha_mes').agg({
                            'ventas_reales': 'sum',
                            'ventas_predichas': 'sum'
                        }).reset_index()

                        # Asegurarnos de que fecha_mes en datos_cliente_total es datetime
                        datos_cliente_total['fecha_mes'] = pd.to_datetime(datos_cliente_total['fecha_mes'], errors='coerce')

                        # Generar un rango de fechas para 2024 si no hay predicciones
                        fechas_2024 = pd.date_range(start='2024-01-01', end='2024-12-31', freq='M')
                        fechas_df_2024 = pd.DataFrame({'fecha_mes': fechas_2024})

                        # Asegurarnos de que fecha_mes en fechas_df_2024 es datetime
                        fechas_df_2024['fecha_mes'] = pd.to_datetime(fechas_df_2024['fecha_mes'], errors='coerce')

                        # Combinar datos históricos con predicciones y ventas reales usando un merge
                        # Usamos how='outer' para asegurarnos de incluir todas las fechas de 2023 y 2024
                        datos_combinados = pd.merge(datos_historicos, datos_cliente_total, on='fecha_mes', how='outer').sort_values('fecha_mes')

                        # Rellenar los NaN: 0 en ventas_historicas donde faltan predicciones, y viceversa
                        datos_combinados['ventas_historicas'].fillna(0, inplace=True)
                        datos_combinados['ventas_predichas'].fillna(0, inplace=True)
                        datos_combinados['ventas_reales'].fillna(0, inplace=True)

                        # Crear la gráfica con Plotly
                        fig = go.Figure()

                        # Graficar ventas históricas
                        fig.add_trace(go.Scatter(
                            x=datos_combinados['fecha_mes'], 
                            y=datos_combinados['ventas_historicas'], 
                            mode='lines+markers', 
                            name='Ventas Históricas', 
                            line=dict(color='blue')
                        ))

                        # Graficar ventas predichas
                        fig.add_trace(go.Scatter(
                            x=datos_combinados['fecha_mes'], 
                            y=datos_combinados['ventas_predichas'], 
                            mode='lines+markers', 
                            name='Ventas Predichas', 
                            line=dict(color='orange')
                        ))

                        # Graficar ventas reales
                        fig.add_trace(go.Scatter(
                            x=datos_combinados['fecha_mes'], 
                            y=datos_combinados['ventas_reales'], 
                            mode='lines+markers', 
                            name='Ventas Reales', 
                            line=dict(color='green')
                        ))

                        # Personalizar el layout para enfocarse en 2023 y 2024
                        fig.update_layout(
                            title=f"Ventas Históricas, Predichas y Reales para Cliente {customer_code}",
                            xaxis_title="Fecha",
                            yaxis_title="Ventas (€)",
                            height=600,
                            xaxis_range=[fecha_inicio_2023, pd.to_datetime("2024-09-30")],  # Ajustar el rango del eje x a 2023-2024
                            legend_title="Tipo de Ventas",
                            hovermode="x unified"
                        )

                        # Mostrar la gráfica en Streamlit
                        st.plotly_chart(fig)

                        # Calculate metrics for 2024 data
                        datos_2024 = datos_combinados[datos_combinados['fecha_mes'].dt.year == 2024]
                        actual = datos_2024['ventas_reales']
                        predicted = datos_2024['ventas_predichas']

                        def calculate_mape(y_true, y_pred):
                            mask = y_true != 0
                            return np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100

                        mae = mean_absolute_error(actual, predicted)
                        mse = mean_squared_error(actual, predicted)
                        rmse = np.sqrt(mse)
                        mape = calculate_mape(actual, predicted)
                        smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100

                        # Display metrics
                        st.subheader("Métricas de Predicción (2024)")
                        col1, col2, col3, col4 = st.columns(4)
                        col1.metric("MAE", f"{mae:.2f} €",help="Promedio de la diferencia absoluta entre las predicciones y los valores reales.")
                        col2.metric("MAPE", f"{mape:.2f}%",help="Porcentaje promedio de error en las predicciones.")
                        col3.metric("RMSE", f"{rmse:.2f} €",help="Medida de la desviación estándar de los residuos de predicción.")
                        col4.metric("SMAPE", f"{smape:.2f}%",help="Alternativa al MAPE que maneja mejor los valores cercanos a cero.")


                        # Split space into two columns
                        col1, col2 = st.columns(2)

                        # Column 1: Radar chart for top manufacturers
                        with col1:
                            st.subheader("¡Esto tiene buena pinta!")
                            st.info("Su cliente ha superado las ventas predichas de las siguientes marcas:")

                            # Group results by manufacturer to calculate the total predicted and actual sales
                            grouped_results = results.groupby('marca_id_encoded').agg({
                                'ventas_reales': 'sum',
                                'ventas_predichas': 'sum'
                            }).reset_index()

                            # Identify manufacturers that exceeded predicted sales
                            overperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] > grouped_results['ventas_predichas']].copy()

                            if not overperforming_manufacturers.empty:
                                # Calculate the extra amount (difference between actual and predicted sales)
                                overperforming_manufacturers['extra_amount'] = overperforming_manufacturers['ventas_reales'] - overperforming_manufacturers['ventas_predichas']

                                # Sort by the highest extra amount
                                overperforming_manufacturers = overperforming_manufacturers.sort_values(by='extra_amount', ascending=False)

                                # Limit to top 10 overperforming manufacturers
                                top_overperformers = overperforming_manufacturers.head(10)

                                # Display two cards per row
                                for i in range(0, len(top_overperformers), 2):
                                    cols = st.columns(2)  # Create two columns for two cards in a row

                                    for j, col in enumerate(cols):
                                        if i + j < len(top_overperformers):
                                            row = top_overperformers.iloc[i + j]
                                            manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
                                            predicted = row['ventas_predichas']
                                            actual = row['ventas_reales']
                                            extra = row['extra_amount']

                                            # Use st.metric for compact display in each column
                                            with col:
                                                st.metric(
                                                    label=f"{manufacturer_name}",
                                                    value=f"{actual:.2f}€",
                                                    delta=f"Exceeded by {extra:.2f}€",
                                                    delta_color="normal"
                                                )


                            # Radar chart logic remains the same
                            customer_df = df[df["CLIENTE"] == str(customer_code)]
                            all_manufacturers = customer_df.iloc[:, 1:].T
                            all_manufacturers.index = all_manufacturers.index.astype(str)

                            customer_euros = euros_proveedor[euros_proveedor["CLIENTE"] == str(customer_code)]
                            sales_data = customer_euros.iloc[:, 1:].T
                            sales_data.index = sales_data.index.astype(str)

                            sales_data_filtered = sales_data.drop(index='CLIENTE', errors='ignore')
                            sales_data_filtered = sales_data_filtered.apply(pd.to_numeric, errors='coerce')
                            all_manufacturers = all_manufacturers.apply(pd.to_numeric, errors='coerce')

                            top_units = all_manufacturers.sort_values(by=all_manufacturers.columns[0], ascending=False).head(10)
                            top_sales = sales_data_filtered.sort_values(by=sales_data_filtered.columns[0], ascending=False).head(10)
                            combined_top = pd.concat([top_units, top_sales]).index.unique()[:20]

                            combined_top = [m for m in combined_top if m in all_manufacturers.index and m in sales_data_filtered.index]

                            if combined_top:
                                combined_data = pd.DataFrame({
                                    'units': all_manufacturers.loc[combined_top, all_manufacturers.columns[0]],
                                    'sales': sales_data_filtered.loc[combined_top, sales_data_filtered.columns[0]]
                                }).fillna(0)

                                combined_data_sorted = combined_data.sort_values(by=['units', 'sales'], ascending=False)
                                non_zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] > 0]
                                
                                if len(non_zero_manufacturers) < 3:
                                    zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] == 0].head(3 - len(non_zero_manufacturers))
                                    manufacturers_to_show = pd.concat([non_zero_manufacturers, zero_manufacturers])
                                else:
                                    manufacturers_to_show = non_zero_manufacturers

                                values = manufacturers_to_show['units'].tolist()
                                amounts = manufacturers_to_show['sales'].tolist()
                                manufacturers = [get_supplier_name(m) for m in manufacturers_to_show.index]

                                if manufacturers:
                                    fig = radar_chart(manufacturers, values, amounts, f'Gráfico de radar para los {len(manufacturers)} principales fabricantes del cliente {customer_code}')
                                    st.pyplot(fig)

                        # Column 2: Alerts and additional analysis
                        with col2:
                            st.subheader("¡Puede que tengas que revisar esto!")
                            st.warning("Se esperaba que tu cliente comprara más productos de las siguientes marcas:")

                            # Group results by manufacturer to calculate the total predicted and actual sales
                            grouped_results = results.groupby('marca_id_encoded').agg({
                                'ventas_reales': 'sum',
                                'ventas_predichas': 'sum'
                            }).reset_index()

                            # Identify manufacturers that didn't meet predicted sales
                            underperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] < grouped_results['ventas_predichas']].copy()

                            if not underperforming_manufacturers.empty:
                                # Calculate the missed amount
                                underperforming_manufacturers['missed_amount'] = underperforming_manufacturers['ventas_predichas'] - underperforming_manufacturers['ventas_reales']

                                # Sort by the highest missed amount
                                underperforming_manufacturers = underperforming_manufacturers.sort_values(by='missed_amount', ascending=False)

                                # Limit to top 10 missed amounts
                                top_misses = underperforming_manufacturers.head(10)

                                # Display two cards per row
                                for i in range(0, len(top_misses), 2):
                                    cols = st.columns(2)  # Create two columns for two cards in a row

                                    for j, col in enumerate(cols):
                                        if i + j < len(top_misses):
                                            row = top_misses.iloc[i + j]
                                            manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
                                            predicted = row['ventas_predichas']
                                            actual = row['ventas_reales']
                                            missed = row['missed_amount']

                                            # Use st.metric for compact display in each column
                                            with col:
                                                st.metric(
                                                    label=f"{manufacturer_name}",
                                                    value=f"{actual:.2f}€",
                                                    delta=f"Missed by {missed:.2f}€",
                                                    delta_color="inverse"
                                                )
                            else:
                                st.success("All manufacturers have met or exceeded predicted sales.")



                            # Gráfico de ventas anuales
                            ventas_clientes['codigo_cliente'] = ventas_clientes['codigo_cliente'].astype(str).str.strip()

                            sales_columns = ['VENTA_2021', 'VENTA_2022', 'VENTA_2023']
                            if all(col in ventas_clientes.columns for col in sales_columns):
                                customer_sales_data = ventas_clientes[ventas_clientes['codigo_cliente'] == customer_code]

                                if not customer_sales_data.empty:
                                    customer_sales = customer_sales_data[sales_columns].values[0]
                                    years = ['2021', '2022', '2023']

                                    # Convert 'fecha_mes' to datetime format if it's not already
                                    if not pd.api.types.is_datetime64_any_dtype(results['fecha_mes']):
                                        results['fecha_mes'] = pd.to_datetime(results['fecha_mes'], errors='coerce')

                                    # Add the 2024 actual and predicted data
                                    if 'ventas_predichas' in results.columns and 'ventas_reales' in results.columns:
                                        actual_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_reales'].sum()
                                        predicted_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_predichas'].sum()

                                        # Assuming only 9 months of actual data are available, annualize the sales
                                        months_available = 9
                                        actual_sales_2024_annual = (actual_sales_2024 / months_available) * 12

                                        # Prepare data for the bar chart
                                        sales_values = list(customer_sales) + [actual_sales_2024_annual]
                                        predicted_values = list(customer_sales) + [predicted_sales_2024]

                                        years.append('2024')

                                        # Create the bar chart for historical and 2024 data
                                        fig_sales_bar = go.Figure()
                                        fig_sales_bar.add_trace(go.Bar(
                                            x=years[:3],  
                                            y=sales_values[:3],
                                            name="Historical Sales",
                                            marker_color='blue'
                                        ))

                                        fig_sales_bar.add_trace(go.Bar(
                                            x=[years[3]],  
                                            y=[sales_values[3]],
                                            name="2024 Actual Sales (Annualized)",
                                            marker_color='green'
                                        ))

                                        fig_sales_bar.add_trace(go.Bar(
                                            x=[years[3]],  
                                            y=[predicted_values[3]],
                                            name="2024 Predicted Sales",
                                            marker_color='orange'
                                        ))

                                        # Customize layout
                                        fig_sales_bar.update_layout(
                                            title=f"Ventas anuales de tu cliente",
                                            xaxis_title="Year",
                                            yaxis_title="Sales (€)",
                                            barmode='group',
                                            height=600,
                                            legend_title_text="Sales Type",
                                            hovermode="x unified"
                                        )

                                        # Display the chart
                                        st.plotly_chart(fig_sales_bar, use_container_width=True)

                                    else:
                                        st.warning(f"No predicted or actual data found for customer {customer_code} for 2024.")

            else:
                with st.spinner(f"Seleccionando el modelo predictivo..."):
                    # Load the Corresponding Model
                    model_path = f'models/modelo_cluster_{cluster}.txt'
                    gbm = lgb.Booster(model_file=model_path)
                with st.spinner(f"Mostrando datos para el fabricante {fabricante_seleccionado}..."):
                    
                    # Mostrar el cliente y el fabricante seleccionados
                    st.write(f"**Cliente seleccionado:** {customer_code}")
                    st.write(f"**Fabricante seleccionado:** {fabricante_seleccionado}")
                    
                    # Obtener el código del fabricante seleccionado
                    codigo_fabricante_seleccionado = np.int64(nombres_proveedores[nombres_proveedores['nombre'] == fabricante_seleccionado]['codigo'].values[0])
                    st.write(f"**Código fabricante seleccionado:** {codigo_fabricante_seleccionado}")
                    
                    # Verificar si el código está presente en el LabelEncoder y obtener su encoded
                    if codigo_fabricante_seleccionado in marca_id_mapping.classes_:
                        codigo_fabricante_encoded = marca_id_mapping.transform([codigo_fabricante_seleccionado])[0]
                        st.write(f"**Código fabricante encoded (marca_id_encoded):** {codigo_fabricante_encoded}")
                        
                        # Filtrar datos solo para este fabricante
                        with st.spinner("Preparando los datos..."):
                            predict_data = pd.read_csv(f'predicts/predict_cluster_{cluster}.csv')
                            predict_data['cliente_id'] = predict_data['cliente_id'].astype(str)
                            customer_code_str = str(customer_code)
                            customer_data = predict_data[(predict_data['cliente_id'] == customer_code_str) & 
                                                        (predict_data['marca_id_encoded'] == codigo_fabricante_encoded)]

                        with st.spinner("Generando predicciones de venta..."):
                            if not customer_data.empty:
                                # Preparar las características
                                lag_features = [f'precio_total_lag_{lag}' for lag in range(1, 25)]
                                features = lag_features + ['mes', 'marca_id_encoded', 'año', 'cluster_id']
                                X_predict = customer_data[features]
                                
                                # Convertir las características categóricas a su dtype correspondiente
                                categorical_features = ['mes', 'marca_id_encoded', 'cluster_id']
                                for feature in categorical_features:
                                    X_predict[feature] = X_predict[feature].astype('category')
                                
                                # Realizar la predicción
                                y_pred = gbm.predict(X_predict, num_iteration=gbm.best_iteration)
                                results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
                                results['ventas_predichas'] = y_pred

                                # Cargar datos reales para 2024
                                actual_sales = df_agg_2024[(df_agg_2024['cliente_id'] == customer_code_str) & 
                                                        (df_agg_2024['marca_id_encoded'] == codigo_fabricante_encoded)]
                                
                                if not actual_sales.empty:
                                    results = results.merge(actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
                                                            on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], how='left')
                                    results.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
                                else:
                                    results['ventas_reales'] = 0
                                
                                results['ventas_reales'].fillna(0, inplace=True)

                                # Generar gráfica y métricas
                                results['fecha_mes'] = pd.to_datetime(results['fecha_mes'], errors='coerce')
                                if not pd.api.types.is_datetime64_any_dtype(df_agg_2024['fecha_mes']):
                                    df_agg_2024['fecha_mes'] = pd.to_datetime(df_agg_2024['fecha_mes'], errors='coerce')
                                
                                fecha_inicio_2023 = pd.to_datetime("2023-01-01")
                                fecha_fin_2023 = pd.to_datetime("2023-12-31")
                                datos_cliente_total = results.groupby('fecha_mes').agg({'ventas_reales': 'sum', 'ventas_predichas': 'sum'}).reset_index()

                                # Crear la gráfica
                                fig = go.Figure()
                                fig.add_trace(go.Scatter(x=datos_cliente_total['fecha_mes'], y=datos_cliente_total['ventas_predichas'],
                                                        mode='lines+markers', name='Ventas Predichas', line=dict(color='orange')))
                                fig.add_trace(go.Scatter(x=datos_cliente_total['fecha_mes'], y=datos_cliente_total['ventas_reales'],
                                                        mode='lines+markers', name='Ventas Reales', line=dict(color='green')))
                                fig.update_layout(title=f"Ventas Predichas y Reales para Cliente {customer_code} y Fabricante {fabricante_seleccionado}",
                                                xaxis_title="Fecha", yaxis_title="Ventas (€)", height=600)
                                st.plotly_chart(fig)

                                # Cálculo de métricas
                                datos_2024 = datos_cliente_total[datos_cliente_total['fecha_mes'].dt.year == 2024]
                                actual = datos_2024['ventas_reales']
                                predicted = datos_2024['ventas_predichas']
                                mae = mean_absolute_error(actual, predicted)
                                mse = mean_squared_error(actual, predicted)
                                rmse = np.sqrt(mse)
                                mape = np.mean(np.abs((actual - predicted) / actual)) * 100 if not actual.empty else 0
                                smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100 if not actual.empty else 0
                                
                                # Mostrar métricas
                                st.subheader("Métricas de Predicción (2024)")
                                col1, col2, col3, col4 = st.columns(4)
                                col1.metric("MAE", f"{mae:.2f} €")
                                col2.metric("MAPE", f"{mape:.2f}%")
                                col3.metric("RMSE", f"{rmse:.2f} €")
                                col4.metric("SMAPE", f"{smape:.2f}%")
                            else:
                                st.warning(f"No se encontraron datos para el cliente {customer_code} y el fabricante {fabricante_seleccionado}.")
                    else:
                        st.warning(f"El código de fabricante {codigo_fabricante_seleccionado} no se encuentra en el LabelEncoder.")

            # else:
            #     with st.spinner(f"Mostrando datos para el fabricante {fabricante_seleccionado}..."):
            #         # Mostrar el cliente y el fabricante seleccionados
            #         st.write(f"**Cliente seleccionado:** {customer_code}")
            #         st.write(f"**Fabricante seleccionado:** {fabricante_seleccionado}")
            #         codigo_fabricante_seleccionado = np.int64(nombres_proveedores[nombres_proveedores['nombre'] == fabricante_seleccionado]['codigo'].values[0])


            #         st.write(f"**Código fabricante seleccionado:** {codigo_fabricante_seleccionado}")
                    
            #         if codigo_fabricante_seleccionado in marca_id_mapping.classes_:
            #             # Si el código está en el LabelEncoder, hacer la transformación
            #             codigo_fabricante_encoded = marca_id_mapping.transform([codigo_fabricante_seleccionado])[0]
            #             st.write(f"**Código fabricante encoded (marca_id_encoded):** {codigo_fabricante_encoded}")
            #         else:
            #             # Si el código no se encuentra en el LabelEncoder, mostrar advertencia y los códigos disponibles
            #             st.warning(f"El código de fabricante {codigo_fabricante_seleccionado} no se encuentra en el LabelEncoder.")
            #             st.write("Lista de códigos de fabricantes disponibles en el LabelEncoder:")
                        
            #             # Imprimir los códigos disponibles y su tipo
            #             available_codes = marca_id_mapping.classes_
            #             st.write(f"**Códigos disponibles:** {available_codes}")
            #             st.write(f"**Tipo de los códigos disponibles:** {type(available_codes[0])}")

                    

# Customer Recommendations Page
elif page == "💡 Recomendación de Artículos":
    # Carga de CSV necesarios cestas y productos
    cestas = pd.read_csv('cestas.csv') 
    productos = pd.read_csv('productos.csv')
    
    # Estilo principal de la página
    st.markdown(
        "<h1 style='text-align: center;'>Recomendación de Artículos</h1>", 
        unsafe_allow_html=True
    )
    st.markdown("""<p style='text-align: center; color: #5D6D7E;'>Obtén recomendaciones personalizadas para tus clientes basadas en su cesta de compra.</p>""", unsafe_allow_html=True)

    st.write("### Selecciona los artículos y asigna las cantidades para la cesta:")

    # Añadir separador para mejorar la segmentación visual
    st.divider()

    # Mostrar lista de artículos disponibles (ahora se usa el código asociado a cada descripción)
    available_articles = productos[['ARTICULO', 'DESCRIPCION']].drop_duplicates()

    # Crear diccionario para asignar las descripciones a los códigos
    article_dict = dict(zip(available_articles['DESCRIPCION'], available_articles['ARTICULO']))

    # Permitir seleccionar las descripciones, pero trabajar con los códigos
    selected_descriptions = st.multiselect("Selecciona los artículos", available_articles['DESCRIPCION'].unique())
    
    quantities = {}

    if selected_descriptions:
        st.write("### Selecciona los artículos, las unidades, y visualiza la imagen:")

        for description in selected_descriptions:
            code = article_dict[description]  # Usar el código del artículo
            col1, col2, col3 = st.columns([1, 2, 2])  # Ajustar proporciones para que las imágenes y textos se alineen

            with col1:
                # Mostrar la imagen del artículo
                img_url = f"https://www.saneamiento-martinez.com/imagenes/articulos/{code}_1.JPG"
                st.image(img_url, width=100)

            with col2:
                # Mostrar la descripción del artículo
                st.write(f"**{description}**")
            
            with col3:
                # Caja de número para la cantidad, asociada al código
                quantities[code] = st.number_input(f"Cantidad {code}", min_value=0, step=1, key=code)

    # Añadir un botón estilizado "Calcular" con icono
    if st.button("🛒 Obtener Recomendaciones"):
        # Crear una lista de artículos basada en los códigos y cantidades
        new_basket = []
        for code in quantities:
            quantity = quantities[code]
            if quantity > 0:
                new_basket.extend([code] * quantity)  # Añadir el código tantas veces como 'quantity'
        
        if new_basket:
            # Procesar la lista para recomendar utilizando tu función 'recomienda_tf'
            recommendations_df = recomienda_tf(new_basket, cestas, productos)

            if not recommendations_df.empty:
                st.success("### Según tu cesta, te recomendamos que consideres añadir estos artículos:")

                # Mostrar los artículos recomendados con imágenes y relevancia
                for idx, row in recommendations_df.iterrows():
                    rec_code = row['ARTICULO']
                    rec_desc = row['DESCRIPCION']
                    rec_relevance = row['RELEVANCIA']  # Usar la relevancia calculada
                    rec_img_url = f"https://www.saneamiento-martinez.com/imagenes/articulos/{rec_code}_1.JPG"
                    
                    # Verificar si la imagen existe antes de mostrar el artículo
                    if image_exists(rec_img_url):
                        rec_col1, rec_col2, rec_col3 = st.columns([1, 3, 1])  # Añadir una columna para la relevancia
                        with rec_col1:
                            st.image(rec_img_url, width=100)
                        with rec_col2:
                            st.write(f"**{rec_desc}** (Código: {rec_code})")
                        with rec_col3:
                            st.metric(label="Relevancia",value =f"{rec_relevance * 100:.2f}%") # Mostrar la relevancia con 4 decimales
            else:
                st.warning("⚠️ No se encontraron recomendaciones para la cesta proporcionada.")
        else:
            st.warning("⚠️ Por favor selecciona al menos un artículo y define su cantidad.")



# elif page == "💡 Recomendación de Artículos":
#     # Carga de CSV necesarios cestas y productos
#     cestas = pd.read_csv('cestas.csv') 
#     productos = pd.read_csv('productos.csv')
#     # Estilo principal de la página
#     st.markdown(
#         "<h1 style='text-align: center;'>Recomendación de Artículos</h1>", 
#         unsafe_allow_html=True
#     )
#     st.markdown("""
#         <p style='text-align: center; color: #5D6D7E;'>Obtén recomendaciones personalizadas para tus clientes basadas en su cesta de compra.</p>
#     """, unsafe_allow_html=True)
#     st.write("### Selecciona los artículos y asigna las cantidades para la cesta:")
#     # Añadir separador para mejorar la segmentación visual
#     st.divider()
#     # Mostrar lista de artículos disponibles (ahora se usa el código asociado a cada descripción)
#     available_articles = productos[['ARTICULO', 'DESCRIPCION']].drop_duplicates()
    
#     # Crear diccionario para asignar las descripciones a los códigos
#     article_dict = dict(zip(available_articles['DESCRIPCION'], available_articles['ARTICULO']))
#     # Permitir seleccionar las descripciones, pero trabajar con los códigos
#     selected_descriptions = st.multiselect("Select Articles", available_articles['DESCRIPCION'].unique())
#     quantities = {}
    
#     if selected_descriptions:
#         st.write("### Selecciona los artículos y las unidades:")
#         for description in selected_descriptions:
#             code = article_dict[description]  # Usar el código del artículo
#             col1, col2 = st.columns([1, 3])  # Ajustar proporciones para que las cantidades vayan a la izquierda
#             with col1:
#                 # Caja de número para la cantidad, asociada al código
#                 quantities[code] = st.number_input(f"Quantity {code}", min_value=0, step=1, key=code)
#             with col2:
#                 # Mostrar la descripción del artículo
#                 st.write(description)
    
#     # Añadir un botón estilizado "Calcular" con icono
#     if st.button("🛒 Obtener Recomendaciones"):
#         # Crear una lista de artículos basada en los códigos y cantidades
#         new_basket = []
#         for code in quantities:
#             quantity = quantities[code]
#             if quantity > 0:
#                 new_basket.extend([code] * quantity)  # Añadir el código tantas veces como 'quantity'
#         if new_basket:
#             # Procesar la lista para recomendar
#             recommendations_df = recomienda_tf(new_basket, cestas, productos)
            
#             if not recommendations_df.empty:
#                 st.success("### Según tu cesta, te recomendamos que consideres añadir uno de estos artículos:")
#                 st.dataframe(recommendations_df, height=300, width=800)  # Ajustar el tamaño del DataFrame
#             else:
#                 st.warning("⚠️ No recommendations found for the provided basket.")
#         else:
#             st.warning("⚠️ Please select at least one article and set its quantity.")

                        # # Gráfico adicional: Comparar las ventas predichas y reales para los principales fabricantes
                        # st.markdown("### Predicted vs Actual Sales for Top Manufacturers")
                        # top_manufacturers = results.groupby('marca_id_encoded').agg({'ventas_reales': 'sum', 'ventas_predichas': 'sum'}).sort_values(by='ventas_reales', ascending=False).head(10)

                        # fig_comparison = go.Figure()
                        # fig_comparison.add_trace(go.Bar(x=top_manufacturers.index, y=top_manufacturers['ventas_reales'], name="Actual Sales", marker_color='blue'))
                        # fig_comparison.add_trace(go.Bar(x=top_manufacturers.index, y=top_manufacturers['ventas_predichas'], name="Predicted Sales", marker_color='orange'))

                        # fig_comparison.update_layout(
                        #     title="Actual vs Predicted Sales by Top Manufacturers",
                        #     xaxis_title="Manufacturer",
                        #     yaxis_title="Sales (€)",
                        #     barmode='group',
                        #     height=400,
                        #     hovermode="x unified"
                        # )

                        # st.plotly_chart(fig_comparison, use_container_width=True)