import pandas as pd
import numpy as np
from sklearn.model_selection import cross_val_predict
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import statsmodels.api as sm
from statsmodels.stats.outliers_influence import variance_inflation_factor
from tqdm import tqdm

# ==========================================
# === 1) CONFIGURATION ET LECTURE DU FICHIER
# ==========================================
FILE_PATH = "/content/BASE-MRC-IHR.xlsx"
SHEET_NAME = "BASE"

df = pd.read_excel(FILE_PATH, sheet_name=SHEET_NAME)
print(f"Fichier chargé : {FILE_PATH} | Taille : {df.shape}")

# Blocs de mesure — construits impliqués dans H1–H6 + H_Dehum + H_Emploi
blocks = {
    "Anthropomorphisme": ["ANT1","ANT2","ANT3","ANT4","ANT5"],
    "Utilite": ["UTIL1","UTIL2","UTIL3","UTIL4","UTIL5","UTIL6","UTIL7"],
    "Plaisir": ["PLAIS1","PLAIS2","PLAIS3","PLAIS4"],
    "RisqueViePrivée": ["RCONTETH1","RCONTETH2","RCONTETH3","RCONTETH4"],
    "RisquePsy": ["RPSY1","RPSY2","RPSY3"],
    "RisqueDehum": ["RDEHUM1","RDEHUM2","RDEHUM3","RDEHUM4","RDEHUM5"], # NOUVEAU
    "RisqueEmploi": ["RPEMP1","RPEMP2","RPEMP3","RPEMP4","RPEMP5"], # NOUVEAU
    "Intention": ["INT1","INT2","INT3","INT4"]
}

# Topographie du réseau (Inner Model)
# Ajout de RisqueDehum → Intention et RisqueEmploi → Intention
base_relations = [
    ("Anthropomorphisme", "Utilite"), # H1
    ("Anthropomorphisme", "Plaisir"), # H2
    ("Plaisir", "Intention"), # H3
    ("Utilite", "Intention"), # H4
    ("RisqueViePrivée", "Intention"), # H5
    ("RisquePsy", "Intention"), # H6
    ("RisqueDehum", "Intention"), # H_Dehum — NOUVEAU
    ("RisqueEmploi", "Intention") # H_Emploi — NOUVEAU
]

# Modèle Structurel (Équations)
# Intention intègre désormais les deux nouveaux prédicteurs de risque
equations = {
    "Utilite": ["Anthropomorphisme"], # H1
    "Plaisir": ["Anthropomorphisme"], # H2
    "Intention": ["Plaisir", "Utilite", "RisqueViePrivée", "RisquePsy",
                  "RisqueDehum", "RisqueEmploi"] # H3–H6 + Dehum + Emploi
}

all_items = [item for sublist in blocks.values() for item in sublist]
df_items = df[all_items].dropna().copy()

# ==========================================
# === 2) L'ALGORITHME ITERATIF PLS-SEM
# ==========================================
def run_pls_sem(data_raw, blks, relations, max_iter=100, tol=1e-5):
    X = (data_raw - data_raw.mean()) / data_raw.std()
    lv_names = list(blks.keys())
    C = pd.DataFrame(0.0, index=lv_names, columns=lv_names)
    
    for s, t in relations:
        if s in lv_names and t in lv_names:
            C.loc[s, t] = 1.0
            C.loc[t, s] = 1.0

    Y = pd.DataFrame({lv: X[items[0]] for lv, items in blks.items()})

    for _ in range(max_iter):
        Y_old = Y.copy()
        E = Y.corr() * C
        Z = Y.dot(E)
        Z = (Z - Z.mean()) / Z.std()

        W = {}
        for lv, items in blks.items():
            w = X[items].apply(lambda col: col.cov(Z[lv]))
            w = w / np.linalg.norm(w)
            W[lv] = w
            Y[lv] = X[items].dot(w)

        Y = (Y - Y.mean()) / Y.std()
        if np.abs(Y - Y_old).max().max() < tol: 
            break

    Loadings = {lv: X[items].apply(lambda col: col.corr(Y[lv])) for lv, items in blks.items()}
    return Y, W, Loadings

Y_final, W_final, L_final = run_pls_sem(df_items, blocks, base_relations)

# La fonction est conservée mais ne crée plus de variables d'interaction
def calculate_inner_variables(Y_df):
    return Y_df.copy()

Y_complet = calculate_inner_variables(Y_final)

# ==========================================
# === 3) CALCUL DES CRITÈRES DE QUALITÉ
# ==========================================
qualite_list = []
loadings_df_list = []

for lv, loadings in L_final.items():
    for item, l_val in loadings.items():
        loadings_df_list.append({"Construit": lv, "Item": item, "Loading_Wold": l_val})

    n = len(blocks[lv])
    corr_matrix = df_items[blocks[lv]].corr()
    avg_corr = corr_matrix.values[np.triu_indices(n, k=1)].mean() if n > 1 else 1.0
    alpha = (n * avg_corr) / (1 + (n - 1) * avg_corr) if n > 1 else 1.0

    ave = np.mean(loadings**2)
    sum_l = np.sum(loadings)
    sum_e = np.sum(1 - loadings**2)
    cr = (sum_l**2) / (sum_l**2 + sum_e)

    qualite_list.append({"Variable": lv, "Cronbach_Alpha": alpha, "Composite_Reliability": cr, "AVE": ave})

df_loadings = pd.DataFrame(loadings_df_list)
df_qualite = pd.DataFrame(qualite_list)

X_std = (df_items - df_items.mean()) / df_items.std()
latent_names = list(blocks.keys())
htmt_df = pd.DataFrame(index=latent_names, columns=latent_names, dtype=float)

for i, b1 in enumerate(latent_names):
    for j, b2 in enumerate(latent_names):
        if i == j: 
            htmt_df.iloc[i,j] = 1.0
        elif i < j:
            items1, items2 = blocks[b1], blocks[b2]
            hetero_mean = X_std[items1 + items2].corr().loc[items1, items2].values.mean()
            mono1 = X_std[items1].corr().values[np.triu_indices(len(items1), k=1)].mean() if len(items1)>1 else 1.0
            mono2 = X_std[items2].corr().values[np.triu_indices(len(items2), k=1)].mean() if len(items2)>1 else 1.0
            htmt_val = abs(hetero_mean / np.sqrt(max(0.0001, abs(mono1 * mono2))))
            htmt_df.iloc[i,j] = htmt_val
            htmt_df.iloc[j,i] = htmt_val

fl_matrix = Y_final.corr()
for b in latent_names:
    fl_matrix.loc[b, b] = np.sqrt(df_qualite.loc[df_qualite['Variable'] == b, 'AVE'].values[0])

# ==========================================
# === 4) MODELE STRUCTUREL (R², f², VIF)
# ==========================================
results_inner = {y: sm.OLS(Y_complet[y], sm.add_constant(Y_complet[xs])).fit() for y, xs in equations.items()}

structurel_data = []
for dep, preds in equations.items():
    X_mat = sm.add_constant(Y_complet[preds])
    R2_incl = results_inner[dep].rsquared

    for i, p in enumerate(preds, start=1):
        vif = variance_inflation_factor(X_mat.values, i)
        preds_excl = [x for x in preds if x != p]
        R2_excl = 0 if not preds_excl else sm.OLS(Y_complet[dep], sm.add_constant(Y_complet[preds_excl])).fit().rsquared
        f2 = (R2_incl - R2_excl) / (1 - R2_incl)

        structurel_data.append({
            "Variable_Dep": dep, "Predictor": p,
            "Coefficient": results_inner[dep].params[p],
            "f2": f2, "VIF": vif
        })
df_structurel = pd.DataFrame(structurel_data)

# ==========================================
# === 5) BOOTSTRAPPING (t-values)
# ==========================================
def run_bootstrap(data_raw, n_boot=500):
    rng = np.random.default_rng(123)
    boot_coefs = []
    for _ in tqdm(range(n_boot), desc="Bootstrapping PLS"):
        sample = data_raw.sample(len(data_raw), replace=True, random_state=rng.integers(0, 100000))
        Y_boot, _, _ = run_pls_sem(sample, blocks, base_relations, max_iter=30)
        Y_boot_comp = calculate_inner_variables(Y_boot)
        row = {}
        for dep, preds in equations.items():
            res = sm.OLS(Y_boot_comp[dep], sm.add_constant(Y_boot_comp[preds])).fit()
            for p in preds: 
                row[(dep, p)] = res.params[p]
        boot_coefs.append(row)
    return pd.DataFrame(boot_coefs)

boot_df = run_bootstrap(df_items, n_boot=500)
boot_std = boot_df.std()
boot_ci = boot_df.quantile([0.025, 0.975]).T
boot_ci.columns = ["CI_lower", "CI_upper"]

df_structurel["t-value"] = df_structurel.apply(
    lambda r: abs(r["Coefficient"] / boot_std[(r["Variable_Dep"], r["Predictor"])]), axis=1
)
df_structurel["p-value"] = [results_inner[r["Variable_Dep"]].pvalues[r["Predictor"]] for _, r in df_structurel.iterrows()]
df_structurel["Significatif_t"] = df_structurel["t-value"] > 1.96

# ==========================================
# === 6) FIT GLOBAL (SRMR) & MACHINE LEARNING (Q² / PLSpredict)
# ==========================================
# --- SRMR ---
R_obs = df_items.corr()
R_implied = pd.DataFrame(np.eye(len(all_items)), index=all_items, columns=all_items)
lv_corr = Y_complet[latent_names].corr()

item_lv_map = {item: lv for lv, items in blocks.items() for item in items}
item_loading_map = {item: L_final[lv][item] for lv, items in blocks.items() for item in items}

for i in range(len(all_items)):
    for j in range(i+1, len(all_items)):
        it1, it2 = all_items[i], all_items[j]
        lv1, lv2 = item_lv_map[it1], item_lv_map[it2]
        r_imp = item_loading_map[it1] * item_loading_map[it2] * lv_corr.loc[lv1, lv2]
        R_implied.loc[it1, it2] = r_imp
        R_implied.loc[it2, it1] = r_imp

diff = R_obs.values - R_implied.values
mask = np.triu(np.ones(diff.shape), k=1).astype(bool)
srmr_value = np.sqrt(np.mean(diff[mask]**2))

df_srmr = pd.DataFrame([{
    "Metric": "SRMR Global", "Valeur": srmr_value,
    "Seuil": "< 0.08 (Idéal) / < 0.10 (Acceptable)",
    "Statut": "Excellent" if srmr_value < 0.08 else ("Acceptable" if srmr_value < 0.10 else "À revoir")
}])

# --- Q² (10-Fold CV sur modèle structurel) ---
lr = LinearRegression()
q2_list = []
for dep, preds in equations.items():
    y_pred_cv = cross_val_predict(lr, Y_complet[preds], Y_complet[dep], cv=10)
    q2_list.append({
        "Variable Endogène": dep,
        "R2_In_Sample": results_inner[dep].rsquared,
        "Q2_Predictive_Relevance": r2_score(Y_complet[dep], y_pred_cv)
    })
df_q2 = pd.DataFrame(q2_list)

# --- PLSpredict (Items endogènes - Uniquement sur l'Intention) ---
plspredict_list = []
endog_targets = ["Intention"]

for target_lv in endog_targets:
    for item in blocks[target_lv]:
        y_item = df_items[item]

        exog_lvs = equations[target_lv]
        exog_items = list(set([it for ex in exog_lvs if ex in blocks for it in blocks[ex]]))
        X_item_lm = df_items[exog_items] if exog_items else df_items.drop(columns=[item])

        y_pred_lm = cross_val_predict(lr, X_item_lm, y_item, cv=10)
        y_pred_naive = np.full_like(y_item, y_item.mean())

        rmse_lm = np.sqrt(mean_squared_error(y_item, y_pred_lm))
        rmse_naive = np.sqrt(mean_squared_error(y_item, y_pred_naive))
        q2_predict_item = 1 - (mean_squared_error(y_item, y_pred_lm) / mean_squared_error(y_item, y_pred_naive))

        plspredict_list.append({
            "Cible": target_lv, "Indicateur": item,
            "RMSE_Machine_Learning (LM)": rmse_lm, "RMSE_Moyenne_Naive": rmse_naive,
            "Q2_predict": q2_predict_item,
            "Pouvoir_Predictif": "Fort" if rmse_lm < rmse_naive else "Faible"
        })
df_plspredict = pd.DataFrame(plspredict_list)

# ==========================================
# === 7) EXPORT EXCEL EXHAUSTIF
# ==========================================
filename = "Resultats_Analyse_Expert_PLS.xlsx"
with pd.ExcelWriter(filename) as writer:
    df_structurel.to_excel(writer, sheet_name='Paths_tvalue_f2_VIF', index=False)
    df_srmr.to_excel(writer, sheet_name='Fit_SRMR', index=False)
    df_q2.to_excel(writer, sheet_name='Q2_Relevance_Structurelle', index=False)
    df_plspredict.to_excel(writer, sheet_name='PLSpredict_Items', index=False)
    df_loadings.to_excel(writer, sheet_name='Loadings_Items', index=False)
    df_qualite.to_excel(writer, sheet_name='Fiabilite_Mesure', index=False)
    fl_matrix.to_excel(writer, sheet_name='Fornell_Larcker')
    htmt_df.to_excel(writer, sheet_name='Validite_HTMT')

print(f"Modèle étendu exécuté avec succès. Fichier généré : {filename}")