import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import warnings
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import statsmodels.api as sm
from statsmodels.formula.api import ols
from statsmodels.stats.anova import anova_lm
from statsmodels.stats.multicomp import pairwise_tukeyhsd
from scipy import stats

# 1. CONFIGURATION ET NETTOYAGE
warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.simplefilter(action='ignore', category=UserWarning)
pd.options.mode.chained_assignment = None

# 2. CHARGEMENT ET RECODAGE
file_path = '/content/RC_AGENT.xlsx'
df = pd.read_excel(file_path, sheet_name='BASE')
df_analysis = df[df['GROUPE'].isin([1, 2, 3])].copy()

mapping_inverse = {1: 5, 2: 4, 3: 3, 4: 2, 5: 1}
df_analysis['CTRL3R_S1'] = df_analysis['CTRL3R_S1'].map(mapping_inverse)

item_labels = {
    'ALIGN1_S1': "Agit dans mon meilleur intérêt",
    'ALIGN2_S1': "Privilégiera mes intérêts vs restaurant",
    'ALIGN3_S1': "Ne poussera pas à un choix avantageux resto",
    'ALIGN4_S1': "Serait honnête sur les limites des plats",
    'ALIGN5_S1': "S'assurera que la commande me convient",
    'COMP1_S1': "Comprend mes préférences alimentaires",
    'COMP2_S1': "Fait de bonnes suggestions de repas",
    'COMP3_S1': "Est fiable pour gérer la commande",
    'COMP4_S1': "Est compétent pour choisir un repas",
    'CTRL1_S1': "Sentiment de garder le contrôle (préférences)",
    'CTRL2_S1': "Contrôle via ajustement des préférences",
    'CTRL3R_S1': "Perception de contrôle personnel (Inversé)",
    'CTRL4_S1': "Facilité à refuser/annuler",
    'CTRL5_S1': "Décision d'activer dépend de moi",
    'INT1_S1': "Prévoit de laisser l'agent agir en mon nom",
    'INT2_S1': "Compte laisser l'agent gérer la commande",
    'INT3_S1': "Prêt à activer mode sans validation",
    'INT4_S1': "Continuerait à utiliser ce mode à l'avenir"
}

concepts = {
    'Alignement': ['ALIGN1_S1','ALIGN2_S1','ALIGN3_S1','ALIGN4_S1','ALIGN5_S1'],
    'Compétence': ['COMP1_S1','COMP2_S1','COMP3_S1','COMP4_S1'],
    'Contrôle':   ['CTRL1_S1','CTRL2_S1','CTRL3R_S1','CTRL4_S1','CTRL5_S1'],
    'Intention':  ['INT1_S1','INT2_S1','INT3_S1','INT4_S1']
}

def calculate_eta_omega(ss_bet, ss_err, df_bet, ms_err):
    ss_tot = ss_bet + ss_err
    eta2 = ss_bet / ss_tot
    omega2 = (ss_bet - (df_bet * ms_err)) / (ss_tot + ms_err)
    return eta2, omega2

def welch_anova_test(data, target, group_col='GROUPE'):
    k = data[group_col].nunique()
    n = data.groupby(group_col)[target].count()
    means = data.groupby(group_col)[target].mean()
    vars_ = data.groupby(group_col)[target].var(ddof=1)
    weights = n / vars_
    sum_weights = weights.sum()
    grand_mean_welch = (weights * means).sum() / sum_weights
    num = (weights * (means - grand_mean_welch)**2).sum() / (k - 1)
    lam = ((1 - weights / sum_weights)**2 / (n - 1)).sum()
    den = 1 + (2 * (k - 2) / (k**2 - 1)) * lam
    f_welch = num / den
    df1 = k - 1
    df2 = (k**2 - 1) / (3 * lam)
    p_val = stats.f.sf(f_welch, df1, df2)
    return f_welch, p_val

def run_full_analysis(data, target, label):
    print(f"\n{'#'*70}\nANALYSE : {label}\n{'#'*70}")
    desc = data.groupby('GROUPE')[target].agg(['mean','std','count','var']).round(3)
    print("\n[1] DESCRIPTIFS :")
    print(desc)
    max_g = desc['mean'].idxmax()
    min_g = desc['mean'].idxmin()
    print(f"\n💡 Scénario {max_g} = meilleure moyenne ({desc.loc[max_g,'mean']}), "
          f"Scénario {min_g} = plus faible ({desc.loc[min_g,'mean']}).")

    g1 = data[data['GROUPE']==1][target]
    g2 = data[data['GROUPE']==2][target]
    g3 = data[data['GROUPE']==3][target]
    levene_stat, levene_p = stats.levene(g1, g2, g3)
    print(f"\n[2] LEVENE : F={levene_stat:.3f}, p={levene_p:.4f}")
    if levene_p > 0.05:
        print("→ Variances homogènes. ANOVA classique OK.")
    else:
        print("→ Variances hétérogènes. Bascule vers Welch.")

    model = ols(f"{target} ~ C(GROUPE)", data=data).fit()
    anova_tab = anova_lm(model, typ=2)
    ss_bet = anova_tab.loc['C(GROUPE)','sum_sq']
    ss_err = anova_tab.loc['Residual','sum_sq']
    df_bet = anova_tab.loc['C(GROUPE)','df']
    df_err = anova_tab.loc['Residual','df']
    ms_bet = ss_bet / df_bet
    ms_err = ss_err / df_err
    f_stat = anova_tab.loc['C(GROUPE)','F']
    p_val = anova_tab.loc['C(GROUPE)','PR(>F)']
    eta2, omega2 = calculate_eta_omega(ss_bet, ss_err, df_bet, ms_err)

    print(f"\n[3a] TABLE ANOVA :")
    print(f"{'Source':<12} | {'SS':<10} | {'df':<4} | {'MS':<10} | {'F':<8} | {'Sig.':<8}")
    print(f"{'Inter-Group':<12} | {ss_bet:<10.3f} | {df_bet:<4.0f} | {ms_bet:<10.3f} | {f_stat:<8.3f} | {p_val:<8.4f}")
    print(f"{'Intra-Group':<12} | {ss_err:<10.3f} | {df_err:<4.0f} | {ms_err:<10.3f} |")

    if levene_p < 0.05:
        print("\n[3b] ⚠️ TEST DE WELCH :")
        f_welch, p_welch = welch_anova_test(data, target, 'GROUPE')
        print(f"F(Welch)={f_welch:.3f}, p={p_welch:.4f}")
        reported_f, reported_p, test_used = f_welch, p_welch, "Welch"
    else:
        reported_f, reported_p, test_used = f_stat, p_val, "ANOVA"

    if reported_p < 0.05:
        print(f"\n💡 [{test_used}] p < 0,05 → Effet significatif.")
    else:
        print(f"\n💡 [{test_used}] p > 0,05 → Pas d'effet.")

    print(f"\n[4] η²={eta2:.4f}, ω²={max(0,omega2):.4f}")
    mag = "faible" if eta2<0.06 else "modérée" if eta2<0.14 else "forte"
    print(f"→ Effet {mag} ({eta2*100:.1f}% de variance expliquée).")

    if reported_p < 0.05:
        print("\n[5] TUKEY HSD :")
        if test_used == "Welch":
            print("(Games-Howell serait préférable)")
        tukey = pairwise_tukeyhsd(data[target], data['GROUPE'])
        print(tukey)
    else:
        print("\n[5] Post-hoc non nécessaire.")

    plt.figure(figsize=(7, 4))
    sns.boxplot(x='GROUPE', y=target, data=data,
                hue='GROUPE', palette='Set2', legend=False)
    sns.swarmplot(x='GROUPE', y=target, data=data,
                  color=".25", alpha=0.5, size=4)
    plt.title(f"Répartition : {label}")
    plt.xlabel("Scénario"); plt.ylabel("Score")
    plt.show()

    return {'Variable': label, 'Test_Appliqué': test_used,
            'F': round(reported_f,3), 'p': round(reported_p,4),
            'Eta2': round(eta2,4), 'Omega2': round(max(0,omega2),4),
            'Levene_p': round(levene_p,4)}

all_results = []

print("=" * 70)
print("ÉTAPE A : CONCEPTS GLOBAUX (ACP)")
print("=" * 70)
pca_df = pd.DataFrame({'GROUPE': df_analysis['GROUPE']})
for name, items in concepts.items():
    scaler = StandardScaler()
    pca = PCA(n_components=1)
    pca_df[name] = pca.fit_transform(
        scaler.fit_transform(
            df_analysis[items].fillna(df_analysis[items].mean())
        )).flatten()
    all_results.append(run_full_analysis(pca_df, name, f"Global : {name}"))

print("\n\n" + "=" * 70)
print("ÉTAPE B : ITEMS INDIVIDUELS")
print("=" * 70)
for code, label in item_labels.items():
    all_results.append(run_full_analysis(df_analysis, code, label))

summary_final = pd.DataFrame(all_results)
print("\n" + "=" * 100)
print("TABLEAU SYNTHÉTIQUE FINAL")
print("=" * 100)
print(summary_final[['Variable','Test_Appliqué','F','p',
                      'Eta2','Omega2','Levene_p']].to_string(index=False))

sig = summary_final[summary_final['p'] < 0.05]
if sig.empty:
    print("\n→ Stabilité : aucune différence significative.")
else:
    print(f"\n→ {len(sig)} variable(s) significative(s). Voir tests post-hoc.")