import pandas as pd
import matplotlib.pyplot as plt
import numpy as np 
# 1. Chargement des données
RESULTS_FILE = "kmedoids_results.csv"

try:
    df = pd.read_csv(RESULTS_FILE)
    # On trie par k pour être sûr que la ligne du graphe ne s'emmêle pas
    df = df.sort_values('k')

    # 2. Création du graphique
    plt.figure(figsize=(12, 6))
    plt.plot(df['k'], np.log(df['objective_cost']), label='Inertie (Coût total)', color='blue')

    # Mise en forme
    plt.title("Évolution du coût K-Medoids en fonction de k", fontsize=14)
    plt.xlabel("Nombre de clusters (k)", fontsize=12)
    plt.ylabel("Coût de l'objectif", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.legend()

    # Sauvegarde de l'image
    plt.savefig("kmedoids_plot_log.png")
    print(f"Graphique généré avec {len(df)} points. Fichier : kmedoids_plot_log.png")
    
    plt.show()

except FileNotFoundError:
    print("Le fichier de résultats n'existe pas encore.")
except Exception as e:
    print(f"Erreur : {e}")

###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################

import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm

# 1. Chargement et tri
RESULTS_FILE = "kmedoids_results.csv"

try:
    df = pd.read_csv(RESULTS_FILE)
    df = df.sort_values('k').reset_index(drop=True)
    
    k_values = []
    percentages = []

    print("Calcul des inversions de coût en cours...")
    
    # 2. Calcul du pourcentage d'anomalies pour chaque k
    for i in tqdm(range(len(df))):
        current_k = df.loc[i, 'k']
        current_cost = df.loc[i, 'objective_cost']
        
        # On regarde k' > k
        future_costs = df.iloc[i+1:]['objective_cost']
        
        if len(future_costs) > 0:
            # Compte combien de fois le coût futur est strictement supérieur au coût actuel
            nb_anomalies = (future_costs > current_cost).sum()
            percent = (nb_anomalies / len(future_costs)) * 100
            
            k_values.append(current_k)
            percentages.append(percent)

    # 3. Tracé du graphique
    plt.figure(figsize=(14, 7))
    plt.fill_between(k_values, percentages, color="red", alpha=0.3)
    plt.plot(k_values, percentages, color="red", linewidth=1.5, label="Inversions (Coût k' > Coût k)")

    # Mise en forme
    plt.title("Pourcentage d'anomalies de convergence (Non-décroissance du coût)", fontsize=14)
    plt.xlabel("Nombre de clusters (k)", fontsize=12)
    plt.ylabel("% de k' > k tels que Coût(k') > Coût(k)", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.ylim(0, max(percentages) + 5 if percentages else 100)
    plt.legend()

    # Sauvegarde
    plt.savefig("anomalies_convergence.png")
    print("\nGraphique sauvegardé sous : anomalies_convergence.png")
    plt.show()

except FileNotFoundError:
    print("Le fichier de résultats n'existe pas encore.")


###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################
###################################################################################################################################################

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# 1. Chargement et préparation
RESULTS_FILE = "kmedoids_results.csv"

try:
    df = pd.read_csv(RESULTS_FILE)
    df = df.sort_values('k').reset_index(drop=True)
    
    costs = df['objective_cost'].values
    k_values = df['k'].values
    
    # 2. Calcul de B_k (le minimum rencontré jusqu'à présent)
    # cummin() est parfait pour cela : il garde le minimum glissant
    b_k = pd.Series(costs).cummin().shift(1)
    
    # Pour k=1 (le premier), B_k n'est pas défini, on met l'infini pour que le ratio soit < 1
    b_k.iloc[0] = np.inf 
    
    # 3. Calcul de la marge : max(1, Cout(k) / B_k)
    ratios = costs / b_k
    marge_erreur = np.maximum(1, ratios)

    # 4. Tracé du graphique
    plt.figure(figsize=(14, 7))
    
    # On trace la ligne de base 1
    plt.axhline(y=1, color='green', linestyle='--', alpha=0.5, label="Optimalité théorique (1.0)")
    
    # On trace la marge d'erreur
    plt.plot(k_values, marge_erreur, color='darkorange', linewidth=1.5, label="Marge d'erreur ($C_k / \min_{l<k} C_l$)")
    
    # Remplissage pour visualiser l'aire d'erreur
    plt.fill_between(k_values, 1, marge_erreur, color='orange', alpha=0.2)

    # Mise en forme
    plt.title("Marge d'erreur de l'approximation K-Medoids", fontsize=14)
    plt.xlabel("Nombre de clusters (k)", fontsize=12)
    plt.ylabel("Ratio d'erreur (1 = pas d'erreur)", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.6)
    
    # Optionnel : échelle log si tu as des pics très violents
    # plt.yscale('log') 
    
    plt.legend()
    
    # Sauvegarde
    plt.savefig("marge_erreur_kmedoids.png")
    print(f"Graphique sauvegardé. Valeur max de l'erreur : {marge_erreur.max():.4f}")
    plt.show()

except Exception as e:
    print(f"Erreur lors du calcul : {e}")