src/streamlit_app.py

import streamlit as st
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score, precision_score, recall_score, f1_score, \
    confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import io
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
from sklearn.inspection import permutation_importance  # Importa Permutation Importance

# Configuração da página do Streamlit
st.set_page_config(layout="wide", page_title="Previsão de Reclamações de Clientes")

st.markdown("""<div style='background-color: #f0f2f6; padding: 10px; border-radius: 8px; margin-bottom: 15px;'>
    <b>Autor:</b> Vinicius Salgueiro Costa &nbsp;&nbsp; <b>Matrícula:</b> 180028880</div>""", unsafe_allow_html=True)
st.title("📊 Previsão de Reclamações de Clientes com Modelos Supervisionados")
st.markdown(
    "Este dashboard tem como objetivo identificar clientes com maior probabilidade de terem feito uma reclamação nos últimos 2 anos, utilizando modelos de Machine Learning.")


# --- Carregamento e Pré-processamento dos Dados ---
@st.cache_data
def load_data():
    github_url = "https://raw.githubusercontent.com/Abdulraqib20/Customer-Personality-Analysis/refs/heads/main/marketing_campaign.csv"
    try:
        df = pd.read_csv(github_url, sep='\t')
    except Exception as e:
        st.error(f"Erro ao carregar o arquivo do GitHub: {e}")
        st.stop()
    return df


@st.cache_data
def preprocess_data(df):
    df_processed = df.copy()

    # Handle 'Dt_Customer' column
    df_processed['Dt_Customer'] = pd.to_datetime(df_processed['Dt_Customer'], format='%d-%m-%Y')
    reference_date = df_processed['Dt_Customer'].min()
    df_processed['Days_Since_Customer'] = (df_processed['Dt_Customer'] - reference_date).dt.days
    df_processed = df_processed.drop('Dt_Customer', axis=1)  # Remove coluna original de data

    # Coerção explícita para numérico para colunas que podem vir como 'object'
    cols_to_coerce_numeric = [
        'Kidhome', 'Teenhome', 'Recency', 'MntWines', 'MntFruits', 'MntMeatProducts',
        'MntFishProducts', 'MntSweetProducts', 'MntGoldProds', 'NumDealsPurchases',
        'NumWebPurchases', 'NumCatalogPurchases', 'NumStorePurchases',
        'NumWebVisitsMonth', 'AcceptedCmp1', 'AcceptedCmp2', 'AcceptedCmp3',
        'AcceptedCmp4', 'AcceptedCmp5', 'Response', 'Days_Since_Customer', 'Income'
    ]
    for col in cols_to_coerce_numeric:
        if col in df_processed.columns:
            df_processed[col] = pd.to_numeric(df_processed[col], errors='coerce')
            df_processed[col] = df_processed[col].fillna(0)  # Preenche NaN com 0 após coerção, se houver

    # Convertendo variáveis categóricas em numéricas (one-hot encoding)
    df_processed = pd.get_dummies(df_processed, columns=['Education', 'Marital_Status'], drop_first=True)

    # Excluir colunas irrelevantes e com variância zero
    cols_to_drop = ['ID', 'Z_CostContact', 'Z_Revenue']
    df_processed = df_processed.drop(columns=[col for col in cols_to_drop if col in df_processed.columns], axis=1,
                                     errors='ignore')

    # Remover colunas com variância zero (constantes) ou com muitos nulos após o pré-processamento
    df_processed = df_processed.loc[:, df_processed.nunique() > 1]  # Remove colunas com apenas 1 valor único
    df_processed = df_processed.dropna(axis=1, how='all')  # Remove colunas totalmente nulas

    return df_processed


# Função para treinar e avaliar modelos
@st.cache_data(show_spinner=False)
def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler, model_selected=None):
    models = {
        "K-Nearest Neighbors": KNeighborsClassifier(),
        "Support Vector Machine": SVC(probability=True, random_state=42),
        "Decision Tree": DecisionTreeClassifier(random_state=42),
        "Random Forest": RandomForestClassifier(random_state=42),
        "AdaBoosting": AdaBoostClassifier(random_state=42),
        "Gradient Boosting": GradientBoostingClassifier(random_state=42),
        "XGBoosting": XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42),
        "LightGBM": LGBMClassifier(random_state=42)
    }

    results = {}

    # Se for uma chamada inicial, apenas retorna as chaves sem tentar treinar
    if st.session_state.get('is_initial_call', False):
        return {name: {} for name in models.keys()}

    # Check if y_train has at least two classes before attempting to train (real training calls)
    if len(np.unique(y_train)) < 2:
        st.error(
            "Erro: O conjunto de treino contém apenas uma classe na variável alvo. Verifique o balanceamento ou a divisão dos dados.")
        return {}

    # Check if X_train_raw has enough samples (real training calls)
    if X_train_raw.shape[0] == 0:
        st.error("Erro: Dados de treino com 0 amostras. Não é possível treinar modelos.")
        return {}

    # Verificar se os dtypes são numéricos antes de treinar (real training calls)
    for col in X_train_raw.columns:
        if not pd.api.types.is_numeric_dtype(X_train_raw[col]):
            st.error(
                f"Erro: Coluna '{col}' no X_train_raw não é numérica. Tipo: {X_train_raw[col].dtype}. Verifique o pré-processamento.")
            return {}

    for col in X_test_raw.columns:
        if not pd.api.types.is_numeric_dtype(X_test_raw[col]):
            st.error(
                f"Erro: Coluna '{col}' no X_test_raw não é numérica. Tipo: {X_test_raw[col].dtype}. Verifique o pré-processamento.")
            return {}

    for name, model in models.items():
        if model_selected and name != model_selected:
            continue

        # Aplicar escalonamento apenas para os dados de treino e teste
        if name in ["K-Nearest Neighbors", "Support Vector Machine"]:
            X_train_processed = _scaler.fit_transform(X_train_raw)
            X_test_processed = _scaler.transform(X_test_raw)
        else:  # Para outros modelos, usamos os dados crus (não escalados)
            X_train_processed = X_train_raw
            X_test_processed = X_test_raw

        try:
            model.fit(X_train_processed, y_train)
            y_pred = model.predict(X_test_processed)

            # Correção para IndexError no predict_proba
            if hasattr(model, 'predict_proba'):
                probas = model.predict_proba(X_test_processed)
                if probas.shape[1] > 1:
                    y_prob = probas[:, 1]
                else:
                    y_prob = probas[:, 0]
            else:
                y_prob = y_pred  # fallback, não ideal para AUC

            # Calcular ROC AUC apenas se y_prob não for totalmente binário (0 ou 1)
            if len(np.unique(y_prob)) > 1:
                roc_auc = roc_auc_score(y_test, y_prob)
                fpr, tpr, _ = roc_curve(y_test, y_prob)
            else:
                roc_auc = 0.5
                fpr, tpr = [0, 1], [0, 1]

            conf_matrix = confusion_matrix(y_test, y_pred)

            results[name] = {
                "Model": model,
                "Accuracy": accuracy_score(y_test, y_pred),
                "Precision": precision_score(y_test, y_pred, zero_division=0),
                "Recall": recall_score(y_test, y_pred, zero_division=0),
                "F1-score": f1_score(y_test, y_pred, zero_division=0),
                "AUC": roc_auc,
                "Confusion Matrix": conf_matrix,
                "FPR": fpr,
                "TPR": tpr,
                "y_prob": y_prob
            }
        except Exception as e:
            results[name] = {
                "Model": None, "Accuracy": 0, "Precision": 0, "Recall": 0, "F1-score": 0,
                "AUC": 0.5, "Confusion Matrix": np.array([[0, 0], [0, 0]]), "FPR": [0, 1], "TPR": [0, 1],
                "y_prob": np.zeros(len(y_test)), "Error": str(e)
            }
            continue
    return results


# --- Carregar e Pré-processar os dados ---
df = load_data()
df_processed = preprocess_data(df)

X = df_processed.drop('Complain', axis=1)
y = df_processed['Complain']

# --- Sidebar para controle ---
st.sidebar.header("⚙️ Configurações do Modelo")

# Balanceamento da Base
st.sidebar.subheader("Balanceamento de Dados (SMOTE)")
balance_data = st.sidebar.checkbox("Aplicar SMOTE", value=True)
st.sidebar.info(
    "SMOTE cria amostras sintéticas da classe minoritária para balancear os dados, melhorando o desempenho em datasets desbalanceados.")

# Seleção de Variáveis
st.sidebar.subheader("Seleção de Variáveis")
use_rfe = st.sidebar.checkbox("Usar Seleção de Variáveis (RFE)", value=False)
if use_rfe:
    max_features_rfe = X.shape[1] if X.shape[1] > 5 else 5
    n_features_rfe = st.sidebar.slider("Número de Variáveis a Selecionar (RFE)", 5, max_features_rfe,
                                       min(10, max_features_rfe))
    st.sidebar.info(
        f"O RFE (Recursive Feature Elimination) seleciona as {n_features_rfe} melhores variáveis de forma iterativa.")
    estimator_rfe = LogisticRegression(max_iter=1000, random_state=42)

    if X.shape[0] > 0 and X.shape[1] >= n_features_rfe:
        try:
            selector_rfe = RFE(estimator_rfe, n_features_to_select=n_features_rfe, step=1)
            selector_rfe = selector_rfe.fit(X, y)
            rfe_selected_features_indices = selector_rfe.support_
            X = X.loc[:, rfe_selected_features_indices]
            st.sidebar.success(f"RFE aplicado. Selecionadas {X.shape[1]} features.")
        except Exception as e:
            st.sidebar.error(f"Erro ao aplicar RFE: {e}. RFE desabilitado.")
            use_rfe = False
    else:
        st.sidebar.warning(
            f"Não há dados suficientes ({X.shape[0]} amostras ou {X.shape[1]} colunas) para aplicar RFE com {n_features_rfe} features. RFE desabilitado.")
        use_rfe = False

# Escolha do Modelo
st.sidebar.subheader("Seleção de Modelo para Treinamento")

# === CORREÇÃO: Usar st.session_state para sinalizar a chamada inicial ===
st.session_state['is_initial_call'] = True
# Criar dados dummy com 1 linha de zeros e todas as colunas de X para ter o shape correto
dummy_X_for_keys = pd.DataFrame(np.zeros((2, X.shape[1])), columns=X.columns)
# y_dummy deve ter pelo menos 2 classes para a função não reclamar
dummy_y_for_keys = pd.Series([0, 1])
model_keys = train_and_evaluate_models(dummy_X_for_keys, dummy_X_for_keys, dummy_y_for_keys, dummy_y_for_keys,
                                       StandardScaler()).keys()
st.session_state['is_initial_call'] = False  # Reseta a flag após a chamada inicial

model_choice = st.sidebar.selectbox(
    "Escolha o Modelo Principal para Análise Detalhada:",
    list(model_keys)
)

st.sidebar.markdown("---")
st.sidebar.markdown("--")

# --- Abas do Dashboard ---
tab1, tab2, tab3, tab4, tab5 = st.tabs([
    "Visão Geral dos Dados",
    "Balanceamento de Dados",
    "Comparação de Modelos",
    "Análise do Melhor Modelo",
    "Aplicação Gerencial"
])

with tab1:
    st.header("1. Visão Geral dos Dados")
    st.subheader("Primeiras 5 Linhas do Dataset")
    st.dataframe(df.head())

    st.subheader("Estatísticas Descritivas")
    st.dataframe(df.describe())

    st.subheader("Informações sobre as Colunas")
    buffer = io.StringIO()
    df.info(buf=buffer)
    s = buffer.getvalue()
    st.text(s)

    # NOVO: Análise de valores ausentes
    st.subheader("Valores Ausentes por Coluna (Dataset Original)")
    missing = df.isnull().sum()
    missing = missing[missing > 0].sort_values(ascending=False)
    if not missing.empty:
        st.dataframe(missing.to_frame('Nulos'))
        st.info("Valores ausentes foram tratados durante o pré-processamento.")
    else:
        st.info("Não há valores ausentes no dataset original.")

    # NOVO: Distribuição de variáveis numéricas
    num_cols = df_processed.select_dtypes(include=np.number).columns.tolist()
    # Remover 'Complain' da lista de colunas numéricas para histograma, pois é o alvo
    if 'Complain' in num_cols:
        num_cols.remove('Complain')

    if num_cols:
        st.subheader("Distribuição de Variáveis Numéricas (Após Pré-processamento)")
        selected_num = st.selectbox("Escolha uma variável numérica para visualizar:", num_cols, key="num_hist")
        fig, ax = plt.subplots()
        sns.histplot(df_processed[selected_num], kde=True, ax=ax)
        ax.set_title(f"Distribuição de {selected_num}")
        ax.set_xlabel(selected_num)
        ax.set_ylabel("Frequência")
        st.pyplot(fig)

    # NOVO: Distribuição de variáveis categóricas (original para visualização)
    # Pegamos as colunas originais antes do get_dummies para visualização
    original_cat_cols = ['Education', 'Marital_Status']
    # Filtra as colunas que realmente existem no df original
    original_cat_cols = [col for col in original_cat_cols if col in df.columns]

    if original_cat_cols:
        st.subheader("Distribuição de Variáveis Categóricas (Dataset Original)")
        selected_cat = st.selectbox("Escolha uma variável categórica para visualizar:", original_cat_cols,
                                    key="cat_bar")
        fig, ax = plt.subplots()
        sns.countplot(x=df[selected_cat], ax=ax, palette='viridis')
        ax.set_title(f"Distribuição de {selected_cat}")
        ax.set_xlabel(selected_cat)
        ax.set_ylabel("Contagem")
        plt.xticks(rotation=45, ha='right')
        st.pyplot(fig)

    # NOVO: Mapa de calor de correlação
    st.subheader("Mapa de Calor das Correlações (Variáveis Numéricas Processadas)")
    if num_cols:  # Garante que ainda há colunas numéricas após remoção de 'Complain'
        fig, ax = plt.subplots(figsize=(12, 10))
        corr_matrix = df_processed[num_cols].corr()
        mask = np.triu(np.ones_like(corr_matrix, dtype=bool))  # Para não repetir a matriz
        sns.heatmap(corr_matrix, cmap='coolwarm', annot=False, fmt=".2f", linewidths=.5, ax=ax, mask=mask)
        ax.set_title('Mapa de Calor de Correlações')
        st.pyplot(fig)
    else:
        st.info("Não há colunas numéricas suficientes para gerar o mapa de calor de correlação.")

    st.subheader("Distribuição da Variável Alvo ('Complain') Original")
    fig, ax = plt.subplots(figsize=(6, 4))
    sns.countplot(x=y, ax=ax, palette='pastel')
    ax.set_title("Distribuição Original da Variável 'Complain'")
    ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
    ax.set_ylabel("Contagem")
    st.pyplot(fig)
    st.write(f"Distribuição da variável 'Complain' original: {Counter(y)}")
    st.warning("Observe o desbalanceamento da classe 'Complain' (poucas reclamações).")

    st.subheader("Comparação de Variáveis com a Variável Alvo (Complain)")
    if num_cols:
        selected_bi = st.selectbox("Escolha uma variável para comparar com 'Complain':", num_cols, key="bivariate_plot")
        fig, ax = plt.subplots(figsize=(8, 6))
        sns.boxplot(x=df_processed['Complain'], y=df_processed[selected_bi], ax=ax, palette='coolwarm')
        ax.set_title(f"Distribuição de {selected_bi} por Classe de Reclamação")
        ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
        ax.set_ylabel(selected_bi)
        st.pyplot(fig)
    else:
        st.info("Não há colunas numéricas para comparação bivariada.")

    st.subheader("Resumo Estatístico Customizado (Dataset Processado)")
    st.dataframe(df_processed.describe(percentiles=[.01, .05, .25, .5, .75, .95, .99]).T)

with tab2:
    st.header("2. Balanceamento de Dados com SMOTE")
    st.write(
        "A seguir, demonstramos o efeito do balanceamento da variável alvo 'Complain' utilizando a técnica **SMOTE**.")

    X_display = X.copy()
    y_display = y.copy()

    if balance_data:
        st.subheader("Resultados do SMOTE")
        smote = SMOTE(random_state=42)
        try:
            if len(np.unique(y_display)) < 2:
                st.error(
                    "SMOTE não pode ser aplicado: A variável alvo contém apenas uma classe. Isso geralmente ocorre em datasets muito pequenos ou após uma filtragem intensa.")
                X_res, y_res = X_display, y_display
            else:
                X_res, y_res = smote.fit_resample(X_display, y_display)
                st.success("Dados balanceados com sucesso!")
                st.write(f"**Distribuição da variável 'Complain' depois do balanceamento com SMOTE:** {Counter(y_res)}")

                fig, ax = plt.subplots(figsize=(6, 4))
                sns.countplot(x=y_res, ax=ax, palette='pastel')
                ax.set_title("Distribuição da Variável 'Complain' Após SMOTE")
                ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
                ax.set_ylabel("Contagem")
                st.pyplot(fig)
        except Exception as e:
            st.error(
                f"Erro ao aplicar SMOTE: {e}. Isso pode acontecer se houver poucas amostras na classe minoritária ou muitas features. Os dados não foram balanceados.")
            X_res, y_res = X_display, y_display
    else:
        st.info("SMOTE desabilitado. O balanceamento não será aplicado.")
        X_res, y_res = X_display, y_display

    if X_res.empty or y_res.empty:
        st.error("Erro: Os dados pós-balanceamento estão vazios. Verifique o dataset original e o pré-processamento.")
        X_train, X_test, y_train, y_test = pd.DataFrame(), pd.DataFrame(), pd.Series(), pd.Series()
    else:
        st.subheader("Divisão dos Dados (Treino/Teste)")
        test_size = st.slider("Tamanho do Conjunto de Teste", 0.1, 0.5, 0.3, 0.05)
        if len(np.unique(y_res)) > 1:
            X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42,
                                                                stratify=y_res)
        else:
            st.warning(
                "Não foi possível usar `stratify` no `train_test_split` pois o alvo tem apenas uma classe após o processamento. Dividindo sem estratificação.")
            X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42)

    st.markdown("---")
    st.subheader("Status dos Dados de Treino e Teste")
    st.write(f"**Shape dos dados de treino (X_train):** {X_train.shape}")
    st.write(f"**Shape dos dados de teste (X_test):** {X_test.shape}")
    st.write(f"**Shape dos rótulos de treino (y_train):** {y_train.shape}")
    st.write(f"**Shape dos rótulos de teste (y_test):** {y_test.shape}")
    st.write(f"**Shape do DataFrame completo (após pré-processamento e antes do split):** {df_processed.shape}")
    st.write(f"**Tipos de Dados das Colunas (após pré-processamento):**")
    st.dataframe(df_processed.dtypes.astype(str).reset_index().rename(columns={'index': 'Coluna', 0: 'Tipo de Dado'}))
    st.write(f"**Primeiras 5 linhas do DataFrame (após pré-processamento):**")
    st.dataframe(df_processed.head())
    st.write(f"**Classes únicas em y_train:** {np.unique(y_train)}")

    if X_train.empty or y_train.empty:
        st.error("Os dados de treino estão vazios! Verifique o carregamento ou pré-processamento dos dados.")
        st.stop()
    if X_test.empty or y_test.empty:
        st.error("Os dados de teste estão vazios! Verifique o carregamento ou pré-processamento dos dados.")
        st.stop()

    st.subheader("Escalonamento de Dados")
    st.write(
        "Para modelos sensíveis à escala (como KNN e SVM), os dados serão automaticamente escalonados (`StandardScaler`) antes do treinamento e da previsão.")

with tab3:
    st.header("3. Comparação de Modelos Supervisionados")
    st.write("Avalie o desempenho de diferentes grupos de modelos supervisionados utilizando métricas chave.")

    if st.button("Treinar e Comparar Todos os Modelos"):
        with st.spinner("Treinando e avaliando modelos..."):
            all_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler())

            valid_results = {k: v for k, v in all_results.items() if v['Model'] is not None}

            if not valid_results:
                st.warning("Nenhum modelo pôde ser treinado com sucesso. Verifique seus dados e configurações.")
            else:
                st.subheader("Métricas de Desempenho dos Modelos")
                metrics_df = pd.DataFrame({
                    "Modelo": list(valid_results.keys()),
                    "Accuracy": [res["Accuracy"] for res in valid_results.values()],
                    "Precision": [res["Precision"] for res in valid_results.values()],
                    "Recall": [res["Recall"] for res in valid_results.values()],
                    "F1-score": [res["F1-score"] for res in valid_results.values()],
                    "AUC": [res["AUC"] for res in valid_results.values()]
                })
                st.dataframe(metrics_df.set_index("Modelo").sort_values(by="AUC", ascending=False))

                st.subheader("Curvas ROC de Todos os Modelos")
                fig_roc_all, ax_roc_all = plt.subplots(figsize=(10, 8))
                for name, metrics in valid_results.items():
                    ax_roc_all.plot(metrics['FPR'], metrics['TPR'], label=f'{name} (AUC = {metrics["AUC"]:.2f})')
                ax_roc_all.plot([0, 1], [0, 1], 'k--', label='Aleatório (AUC = 0.50)')
                ax_roc_all.set_xlabel('Taxa de Falsos Positivos (FPR)')
                ax_roc_all.set_ylabel('Taxa de Verdadeiros Positivos (TPR)')
                ax_roc_all.set_title('Curva ROC para Diferentes Modelos')
                ax_roc_all.legend()
                ax_roc_all.grid(True)
                st.pyplot(fig_roc_all)

                st.subheader("Discussão sobre a Escolha do Melhor Modelo")
                st.markdown("""
                Para problemas de previsão de reclamações, o **Recall** é frequentemente crucial, pois minimiza Falsos Negativos (clientes que reclamam mas não são previstos). No entanto, um bom **AUC** (Área sob a Curva ROC) indica a capacidade geral do modelo de distinguir entre as classes, e o **F1-score** oferece um equilíbrio entre Precisão e Recall.
                """)
                st.success(
                    f"**Recomendação:** O modelo com o maior **AUC** é geralmente um bom ponto de partida, pois indica a melhor capacidade discriminatória geral. Para este exemplo, o modelo principal para análise detalhada será o selecionado na sidebar: **{model_choice}**.")

with tab4:
    st.header("4. Análise Detalhada do Modelo Selecionado")
    st.write(f"Foco na análise detalhada do modelo: **{model_choice}**.")

    if st.button(f"Analisar {model_choice}"):
        with st.spinner(f"Analisando {model_choice}..."):
            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(),
                                                               model_selected=model_choice)
            if model_choice not in selected_model_results or selected_model_results[model_choice]['Model'] is None:
                st.error(
                    f"Não foi possível analisar o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
            else:
                metrics = selected_model_results[model_choice]

                st.subheader(f"Métricas de Desempenho para {model_choice}")
                st.write(f"**Accuracy:** {metrics['Accuracy']:.4f}")
                st.write(f"**Precision:** {metrics['Precision']:.4f}")
                st.write(f"**Recall:** {metrics['Recall']:.4f}")
                st.write(f"**F1-score:** {metrics['F1-score']:.4f}")
                st.write(f"**AUC:** {metrics['AUC']:.4f}")

                st.subheader(f"Matriz de Confusão para {model_choice}")
                fig_cm, ax_cm = plt.subplots(figsize=(7, 6))
                disp = ConfusionMatrixDisplay(confusion_matrix=metrics['Confusion Matrix'],
                                              display_labels=['Não Reclamou (0)', 'Reclamou (1)'])
                disp.plot(cmap=plt.cm.Blues, ax=ax_cm)
                ax_cm.set_title(f'Matriz de Confusão para {model_choice}')
                st.pyplot(fig_cm)

                st.markdown("""
                **Interpretação da Matriz de Confusão:**
                - **Verdadeiros Negativos (TN):** Clientes que não reclamaram e foram previstos corretamente.
                - **Falsos Positivos (FP):** Clientes que não reclamaram, mas foram erroneamente previstos como reclamantes (custo de intervenção desnecessária).
                - **Falsos Negativos (FN):** Clientes que reclamaram, mas foram erroneamente previstos como não reclamantes (custo de perda de oportunidade de intervenção, insatisfação).
                - **Verdadeiros Positivos (TP):** Clientes que reclamaram e foram previstos corretamente.
                """)

                st.subheader(f"Curva ROC para {model_choice}")
                fig_roc_single, ax_roc_single = plt.subplots(figsize=(8, 6))
                ax_roc_single.plot(metrics['FPR'], metrics['TPR'], color='darkorange', lw=2,
                                   label=f'Curva ROC (AUC = {metrics["AUC"]:.2f})')
                ax_roc_single.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='Classificador Aleatório')
                ax_roc_single.set_xlabel('Taxa de Falsos Positivos (FPR)')
                ax_roc_single.set_ylabel('Taxa de Verdadeiros Positivos (TPR)')
                ax_roc_single.set_title(f'Curva ROC para {model_choice}')
                ax_roc_single.legend(loc='lower right')
                ax_roc_single.grid(True)
                st.pyplot(fig_roc_single)
                st.write(
                    f"O **AUC** de {metrics['AUC']:.2f} indica a capacidade discriminatória do modelo: quanto mais próximo de 1, melhor o modelo distingue entre as classes.")

                st.subheader("Sensibilidade aos Hiperparâmetros")
                if model_choice == "K-Nearest Neighbors":
                    st.markdown("""
                    O KNN é altamente sensível ao `n_neighbors` (número de vizinhos). Pequenos valores podem causar overfitting, enquanto valores grandes podem levar a underfitting. A métrica de distância e a escala dos dados também são cruciais.
                    """)
                elif model_choice == "Random Forest":
                    st.markdown("""
                    O Random Forest é impactado por `n_estimators` (número de árvores), `max_depth` (profundidade máxima) e `min_samples_leaf`. Mais árvores geralmente melhoram o desempenho, mas `max_depth` e `min_samples_leaf` controlam a complexidade e evitam o overfitting das árvores individuais.
                    """)
                elif model_choice == "Support Vector Machine":
                    st.markdown("""
                    O SVM é sensível ao `C` (parâmetro de regularização) e `kernel` (função de kernel). `C` controla a penalidade por erros de classificação, e o `kernel` define a forma do limite de decisão (linear, RBF, etc.). A escala dos dados é fundamental para o SVM.
                    """)
                elif model_choice == "XGBoosting" or model_choice == "LightGBM":
                    st.markdown("""
                    Modelos de Boosting como XGBoost e LightGBM são influenciados por `n_estimators` (número de estimadores), `learning_rate` (taxa de aprendizado) e `max_depth`. Uma `learning_rate` menor com mais estimadores pode melhorar o desempenho, mas requer mais tempo de treinamento. `Max_depth` controla a complexidade de cada árvore.
                    """)
                else:
                    st.markdown(
                        "Este modelo também possui hiperparâmetros que podem ser ajustados para otimizar o desempenho (ex: `max_depth` para Decision Tree, `n_estimators` para AdaBoosting/Gradient Boosting).")

with tab5:
    st.header("5. Tomada de Decisão e Aplicação Gerencial")
    st.write("Análise dos fatores que mais influenciam a ocorrência de reclamações e recomendações práticas.")

    if st.button("Gerar Análise Gerencial"):
        with st.spinner("Gerando insights gerenciais..."):
            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(),
                                                               model_selected=model_choice)

            if model_choice not in selected_model_results or selected_model_results[model_choice]['Model'] is None:
                st.error(
                    f"Não foi possível gerar a análise gerencial para o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
            else:
                model_instance = selected_model_results[model_choice]["Model"]

                st.subheader("Importância das Variáveis")
                st.markdown(
                    "A importância das variáveis indica o quanto cada atributo contribui para a capacidade preditiva do modelo. Entender esses fatores é crucial para a tomada de decisão estratégica.")

                # Tenta obter feature_importances (para modelos de árvore)
                if hasattr(model_instance, 'feature_importances_'):
                    feature_importances = model_instance.feature_importances_
                    feature_names = X.columns.tolist()
                    importance_df = pd.DataFrame(
                        {'Variável': feature_names, 'Importância Relativa': feature_importances})
                    importance_df = importance_df.sort_values(by='Importância Relativa', ascending=False)

                    st.markdown("**Importância por Ganho de Informação / Gini (para modelos em árvore):**")
                    st.dataframe(importance_df.head(10).set_index('Variável'))

                    fig_imp, ax_imp = plt.subplots(figsize=(10, 6))
                    sns.barplot(x='Importância Relativa', y='Variável', data=importance_df.head(10), ax=ax_imp,
                                palette='viridis')
                    ax_imp.set_title('Top 10 Variáveis Mais Importantes (Feature Importance)')
                    ax_imp.set_xlabel('Importância Relativa')
                    ax_imp.set_ylabel('Variável')
                    plt.tight_layout()
                    st.pyplot(fig_imp)

                # Tenta obter coeficientes (para modelos lineares)
                elif hasattr(model_instance, 'coef_'):
                    # Para SVM, se for linear, ou Logistic Regression (se adicionado)
                    # Certifique-se que X_train_raw é usado se o modelo não usa scaler
                    # ou use X_train_processed se o modelo usou scaler

                    # Para este dashboard, o X_train_raw tem as colunas originais (ou após RFE)
                    # e é o que deve ser usado para mapear coeficientes

                    # É crucial que o scaler usado aqui seja o mesmo que foi ajustado na função de treinamento
                    # Reajustar o scaler para obter os coeficientes no espaço original das features,
                    # se o modelo linear for treinado em dados escalados.

                    # Vamos assumir que para SVM (que usa coef_), ele foi treinado em X_train_processed (escalado)
                    # Para interpretar, seria ideal reverter o escalonamento ou entender os coeficientes no espaço escalado.
                    # Para simplicidade e foco na interpretabilidade gerencial, permutation importance é mais direto aqui.

                    st.markdown("**Coeficientes (para modelos lineares como SVM Linear):**")
                    # Para simplificar, mostraremos os coeficientes, mas a interpretação direta é mais complexa com features escaladas
                    if model_instance.coef_.ndim > 1:
                        coefs = model_instance.coef_[0]
                    else:
                        coefs = model_instance.coef_

                    coef_df = pd.DataFrame({'Variável': X_train.columns, 'Coeficiente': coefs})
                    coef_df = coef_df.sort_values(by='Coeficiente', ascending=False)
                    st.dataframe(coef_df)
                    st.info(
                        "Para coeficientes, o sinal indica a direção da relação (positiva/negativa) e a magnitude a força. Em modelos com dados escalados, a magnitude é relativa.")

                # Importância por Permutação (geralmente aplicável a qualquer modelo)
                # Esta é uma técnica robusta e interpretável.
                st.markdown("---")
                st.markdown("**Importância por Permutação (Mede o Impacto na Performance do Modelo):**")
                st.info(
                    "A importância por permutação embaralha uma variável e mede a queda no desempenho do modelo, indicando quão crucial ela é para as previsões. É robusta para diferentes tipos de modelos.")

                # Certifica-se de que o modelo foi treinado e X_test/y_test não estão vazios
                if model_instance and not X_test.empty and not y_test.empty:
                    # Ajusta X_test para o modelo (escalado ou não)
                    X_test_for_pi = StandardScaler().fit_transform(X_test) if model_choice in ["K-Nearest Neighbors",
                                                                                               "Support Vector Machine"] else X_test

                    try:
                        perm_importance = permutation_importance(model_instance, X_test_for_pi, y_test, n_repeats=10,
                                                                 random_state=42, n_jobs=-1)
                        perm_df = pd.DataFrame({
                            'Variável': X_test.columns[perm_importance.importances_mean.argsort()[::-1]],
                            # Ordena pelo mean
                            'Importância Média': perm_importance.importances_mean[
                                perm_importance.importances_mean.argsort()[::-1]],
                            'Desvio Padrão': perm_importance.importances_std[
                                perm_importance.importances_mean.argsort()[::-1]]
                        })
                        st.dataframe(perm_df.head(10).set_index('Variável'))

                        fig_pi, ax_pi = plt.subplots(figsize=(10, 6))
                        sns.barplot(x='Importância Média', y='Variável', data=perm_df.head(10), ax=ax_pi,
                                    palette='cividis')
                        ax_pi.set_title('Top 10 Variáveis Mais Importantes (Permutation Importance)')
                        ax_pi.set_xlabel('Importância Média (Queda na Performance)')
                        ax_pi.set_ylabel('Variável')
                        plt.tight_layout()
                        st.pyplot(fig_pi)

                    except Exception as e:
                        st.warning(
                            f"Não foi possível calcular a Importância por Permutação: {e}. Isso pode ocorrer com alguns modelos ou se os dados de teste forem muito pequenos.")
                else:
                    st.info(
                        "Dados de teste insuficientes ou modelo não treinado para calcular Importância por Permutação.")

                st.markdown("---")
                st.subheader("Análise Estratégica e Recomendações Gerenciais")
                st.markdown(f"""
                Como analista de dados, sua missão é transformar os insights do modelo de **Análise de Personalidade do Cliente** em ações concretas para a empresa varejista. A capacidade de prever reclamações nos permite adotar uma abordagem proativa, em vez de reativa, melhorando a experiência do consumidor, priorizando suporte personalizado e antecipando insatisfações.

                O modelo **{model_choice}** nos forneceu as variáveis mais influentes na probabilidade de um cliente registrar uma reclamação. A partir da análise das "Importâncias de Variáveis" (seja por Ganho/Gini, Coeficientes ou Permutação), podemos identificar os **perfis de cliente de alto risco** e propor intervenções estratégicas.

                **Interpretando os Fatores Chave :**

                As variáveis que consistentemente aparecem no topo das listas de importância (Feature Importance e/ou Permutation Importance) são seus principais alvos. Por exemplo, se seu modelo destacar:

                * **`Days_Since_Customer` (Dias Desde a Última Compra)**: Se essa variável tiver alta importância e uma correlação positiva com reclamações, indica que clientes inativos ou que não compram há muito tempo tendem a reclamar mais. Eles podem estar se sentindo negligenciados ou ter tido uma experiência negativa não resolvida.
                * **`NumWebVisitsMonth` (Número de Visitas ao Site no Último Mês)**: Se importante e associado a reclamações, pode significar que clientes estão visitando o site com frequência, talvez buscando soluções para problemas ou informações que não encontram facilmente, levando à frustração.
                * **`MntWines` (Gasto em Vinho)** ou outras categorias de produtos: Altos gastos em categorias específicas podem indicar clientes de alto valor. Se essa variável for importante para prever reclamações, pode sinalizar que esses clientes têm altas expectativas ou que problemas relacionados a esses produtos/serviços geram maior insatisfação.
                * **`Kidhome` / `Teenhome` (Presença de Crianças/Adolescentes)**: Fatores demográficos podem revelar segmentos com necessidades específicas ou sensibilidades que, se não atendidas, resultam em reclamações.

                **Recomendações Gerenciais Estratégicas:**

                Com base nesses insights, a empresa pode adaptar suas estratégias de marketing e relacionamento, focando nos segmentos de maior risco:

                1.  **Priorização do Suporte Personalizado Proativo:**
                    * Monitorar clientes que o modelo classifica com alta probabilidade de reclamação.
                    * Para clientes com **longo tempo de inatividade** e/ou **altas visitas ao site sem conversão**, acione proativamente um contato (e-mail personalizado, ligação, ou pop-up de chat) oferecendo ajuda, coletando feedback ou reengajando com ofertas relevantes. Isso transforma uma potencial reclamação em uma oportunidade de fidelização.

                2.  **Otimização da Jornada do Cliente e Conteúdo:**
                    * Se o **número de visitas do site** for um fator chave para reclamações, investigue as páginas mais visitadas por esses clientes de alto risco. Há informações faltando? O processo de compra ou suporte é confuso? Use esses dados para otimizar a usabilidade do site e a clareza das informações.
                    * Crie **conteúdo direcionado** para as necessidades específicas de segmentos identificados (ex: famílias com crianças/adolescentes) se `Kidhome` ou `Teenhome` forem relevantes.

                3.  **Gestão da Satisfação para Clientes de Alto Valor:**
                    * Para clientes que gastam muito em **categorias de produtos específicas** (como vinho), mas que têm alta propensão a reclamar, implemente um programa de "check-up" de satisfação pós-compra ou um canal de suporte VIP. A perda desses clientes tem um impacto financeiro maior.

                **Exemplo de Recomendação Acionável (Ajuste com seus dados reais):**

                "Clientes que não realizam compras **há mais de 180 dias** e que registraram **mais de 5 visitas ao site no último mês** sem interações significativas, apresentam uma probabilidade de reclamação ** maior**. Estes clientes devem ser imediatamente incluídos em uma **campanha de 'reconexão proativa'**, por meio de comunicações como CRM ou Whatsapp oferecendo suporte personalizado para dúvidas não resolvidas e incentivos de reengajamento adaptados aos seus históricos de compra."

                Ao aplicar esses insights da **Análise de Personalidade do Cliente**, a empresa pode não apenas reduzir o volume de reclamações, mas também aprofundar o entendimento sobre seus clientes, construir lealdade e, em última análise, impulsionar o crescimento do negócio.
                """)