import csv

with open('etudiants.csv', 'r', encoding='utf-8') as fichier:
    lecteur = csv.DictReader(fichier)
    donnees = list(lecteur)

for i, ligne in enumerate(donnees):
    if i < 3:
        print(f"Nom: {ligne['nom']}, Âge: {ligne['âge']}, Note: {ligne['note']}, Ville: {ligne['ville']}")
    else:
        break

etudiants_excellents = []
for etudiant in donnees:
    if float(etudiant['note']) > 15:
        etudiants_excellents.append(etudiant)

print(f"Nombre d'étudiants avec note > 15 : {len(etudiants_excellents)}")

compteur_villes = {}
for etudiant in donnees:
    ville = etudiant['ville']
    compteur_villes[ville] = compteur_villes.get(ville, 0) + 1

for ville, count in compteur_villes.items():
    print(f"{ville}: {count} étudiant(s)")

etudiants_par_note = sorted(donnees, key=lambda x: float(x['note']), reverse=True)
for etudiant in etudiants_par_note:
    print(f"{etudiant['nom']}: {etudiant['note']}")

etudiants_alpha = sorted(donnees, key=lambda x: x['nom'])
for etudiant in etudiants_alpha:
    print(f"{etudiant['nom']}")

top_5 = etudiants_par_note[:5]
print("Top 5 des meilleurs étudiants :")
for i, etudiant in enumerate(top_5, 1):
    print(f"{i}. {etudiant['nom']}: {etudiant['note']}")

etudiants_ville_note = sorted(donnees, 
                               key=lambda x: (x['ville'], -float(x['note'])))
for etudiant in etudiants_ville_note:
    print(f"{etudiant['ville']} - {etudiant['nom']}: {etudiant['note']}")

def trier_donnees(donnees, criteres):
    """
    criteres: liste de tuples (champ, reverse)
    exemple: [('ville', False), ('note', True)]
    """
    def cle_tri(item):
        result = []
        for champ, reverse in criteres:
            valeur = item[champ]
            if champ in ['note', 'âge']:
                valeur = float(valeur)
            if reverse:
                valeur = -valeur if isinstance(valeur, (int, float)) else valeur
            result.append(valeur)
        return tuple(result)
    
    return sorted(donnees, key=cle_tri)

criteres = [('âge', False), ('nom', False)]
result = trier_donnees(donnees, criteres)
for etudiant in result:
    print(f"{etudiant['âge']} ans - {etudiant['nom']}")

import pandas as pd

df = pd.read_csv('etudiants.csv')
moyenne_par_ville = df.groupby('ville')['note'].mean()
print("Moyenne des notes par ville :")
print(moyenne_par_ville)

etudiants_filtres = df.query('18 <= âge <= 25 and note > 12')
print(f"Nombre d'étudiants correspondants : {len(etudiants_filtres)}")
print(etudiants_filtres[['nom', 'âge', 'note', 'ville']])

tableau_croise = pd.pivot_table(df, 
                                values='nom', 
                                index='âge', 
                                columns='ville', 
                                aggfunc='count', 
                                fill_value=0)
print("Répartition âge/ville :")
print(tableau_croise)

import csv

# Méthode 1 : csv.reader() - Liste de listes
def lire_csv_listes(nom_fichier):
    with open(nom_fichier, 'r', newline='', encoding='utf-8') as fichier:
        lecteur = csv.reader(fichier)
        entetes = next(lecteur)
        donnees = []
        for ligne in lecteur:
            donnees.append(ligne)
    return entetes, donnees

# Méthode 2 : csv.DictReader() - Liste de dictionnaires  
def lire_csv_dict(nom_fichier):
    with open(nom_fichier, 'r', newline='', encoding='utf-8') as fichier:
        lecteur = csv.DictReader(fichier)
        return list(lecteur)

# Test méthode 1
entetes, produits_listes = lire_csv_listes('produits.csv')
print("Structure liste:", entetes)
print("Premier produit:", produits_listes[0])
print("Prix du premier:", produits_listes[0][1])  # Index 1 pour prix

# Test méthode 2
produits_dict = lire_csv_dict('produits.csv')
print("Premier produit dict:", produits_dict[0])
print("Prix du premier:", produits_dict[0]['prix'])  # Accès par nom

def calculer_statistiques(produits, colonne):
    """Calcule les statistiques d'une colonne numérique"""
    valeurs = []
    for produit in produits:
        if colonne in ['prix', 'stock']:
            valeurs.append(float(produit[colonne]))
    
    if not valeurs:
        return None
    
    return {
        'moyenne': sum(valeurs) / len(valeurs),
        'min': min(valeurs),
        'max': max(valeurs),
        'etendue': max(valeurs) - min(valeurs),
        'nombre': len(valeurs)
    }

# Utilisation
stats_prix = calculer_statistiques(produits, 'prix')
print(f"Prix moyen: {stats_prix['moyenne']:.2f}€")

def grouper_par_categorie(produits):
    """Regroupe les produits par catégorie"""
    groupes = {}
    for produit in produits:
        categorie = produit['categorie']
        if categorie not in groupes:
            groupes[categorie] = []
        groupes[categorie].append(produit)
    return groupes

# Test
groupes = grouper_par_categorie(produits)
for cat, liste_produits in groupes.items():
    print(f"{cat}: {len(liste_produits)} produit(s)")

def trier_produits(produits, critere, decroissant=False):
    """Tri intelligent selon le type de colonne"""
    def cle_tri(produit):
        valeur = produit[critere]
        # Conversion automatique pour colonnes numériques
        if critere in ['prix', 'stock']:
            return float(valeur)
        return valeur.lower()  # Tri insensible à la casse pour texte
    
    return sorted(produits, key=cle_tri, reverse=decroissant)

# Test
produits_par_prix = trier_produits(produits, 'prix', decroissant=True)

def tri_multi_criteres(produits, criteres):
    """
    criteres: liste de tuples (nom_colonne, decroissant)
    Exemple: [('categorie', False), ('prix', True)]
    """
    def cle_tri(produit):
        cle = []
        for nom_colonne, decroissant in criteres:
            valeur = produit[nom_colonne]
            
            # Conversion selon le type
            if nom_colonne in ['prix', 'stock']:
                valeur = float(valeur)
                if decroissant:
                    valeur = -valeur  # Négation pour ordre décroissant
            else:
                valeur = valeur.lower()
                # Pour texte décroissant, on inverse avec un artifice
            
            cle.append(valeur)
        return tuple(cle)
    
    return sorted(produits, key=cle_tri)

# Test
criteres = [('categorie', False), ('prix', True)]
produits_tries = tri_multi_criteres(produits, criteres)
for p in produits_tries[:5]:
    print(f"{p['categorie']} - {p['nom']}: {p['prix']}€")

def tri_multi_criteres_ameliore(produits, criteres):
    # Tri en plusieurs passes pour gérer texte décroissant
    result = produits.copy()
    
    # Tri dans l'ordre inverse des critères
    for nom_colonne, decroissant in reversed(criteres):
        if nom_colonne in ['prix', 'stock']:
            result = sorted(result, 
                          key=lambda x: float(x[nom_colonne]), 
                          reverse=decroissant)
        else:
            result = sorted(result, 
                          key=lambda x: x[nom_colonne].lower(), 
                          reverse=decroissant)
    
    return result

import csv

class GestionCSV:
    def __init__(self, fichier):
        """Initialise avec le chargement des données"""
        self.fichier = fichier
        self.donnees = self.charger_donnees()
        self.colonnes_numeriques = ['prix', 'stock']  # Configurable
    
    def charger_donnees(self):
        """Charge les données du fichier CSV"""
        with open(self.fichier, 'r', newline='', encoding='utf-8') as f:
            return list(csv.DictReader(f))
    
    def filtrer(self, critere, valeur):
        """Filtre selon un critère exact"""
        return [item for item in self.donnees if item[critere] == str(valeur)]
    
    def rechercher_avancee(self, **kwargs):
        """Recherche avec critères multiples et opérateurs"""
        resultats = self.donnees.copy()
        
        for cle, valeur in kwargs.items():
            if cle.endswith('_min'):
                # Critère minimum (ex: prix_min)
                colonne = cle[:-4]
                if colonne in self.colonnes_numeriques:
                    resultats = [r for r in resultats 
                               if float(r[colonne]) >= float(valeur)]
            elif cle.endswith('_max'):
                # Critère maximum (ex: prix_max)
                colonne = cle[:-4]
                if colonne in self.colonnes_numeriques:
                    resultats = [r for r in resultats 
                               if float(r[colonne]) <= float(valeur)]
            elif cle.endswith('_contient'):
                # Recherche textuelle (ex: nom_contient)
                colonne = cle[:-9]
                resultats = [r for r in resultats 
                           if str(valeur).lower() in r[colonne].lower()]
            else:
                # Critère exact
                resultats = [r for r in resultats if r[cle] == str(valeur)]
        
        return resultats
    
    def exporter_filtre(self, donnees, nom_fichier):
        """Exporte un sous-ensemble des données"""
        if not donnees:
            print("Aucune donnée à exporter")
            return
        
        with open(nom_fichier, 'w', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=donnees[0].keys())
            writer.writeheader()
            writer.writerows(donnees)
        
        print(f"Exporté {len(donnees)} lignes vers {nom_fichier}")
    
    def statistiques_globales(self):
        """Retourne des statistiques générales"""
        stats = {}
        for col in self.colonnes_numeriques:
            valeurs = [float(item[col]) for item in self.donnees]
            stats[col] = {
                'moyenne': sum(valeurs) / len(valeurs),
                'min': min(valeurs),
                'max': max(valeurs)
            }
        return stats

# Initialisation
gestion = GestionCSV('produits.csv')

# Recherches avancées
chers = gestion.rechercher_avancee(prix_min=50, categorie="Electronique")
recherche = gestion.rechercher_avancee(nom_contient="phone", prix_max=800)

# Export des résultats
gestion.exporter_filtre(chers, 'produits_chers_electronique.csv')

# Statistiques
stats = gestion.statistiques_globales()
print(f"Prix moyen: {stats['prix']['moyenne']:.2f}€")

def comparer_annees(fichier_ancien, fichier_nouveau):
    """Compare deux fichiers CSV de produits"""
    import csv
    
    # Chargement des données
    def charger_dict_produits(fichier):
        with open(fichier, 'r', newline='', encoding='utf-8') as f:
            lecteur = csv.DictReader(f)
            return {row['nom']: row for row in lecteur}
    
    produits_2023 = charger_dict_produits(fichier_ancien)
    produits_2024 = charger_dict_produits(fichier_nouveau)
    
    # Analyse des changements
    rapport = {
        'ajoutes': [],
        'supprimes': [],
        'modifies': [],
        'inchanges': []
    }
    
    # Produits de 2024
    for nom, produit_2024 in produits_2024.items():
        if nom not in produits_2023:
            rapport['ajoutes'].append(produit_2024)
        else:
            produit_2023 = produits_2023[nom]
            if produit_2023['prix'] != produit_2024['prix']:
                rapport['modifies'].append({
                    'nom': nom,
                    'ancien_prix': float(produit_2023['prix']),
                    'nouveau_prix': float(produit_2024['prix']),
                    'evolution': float(produit_2024['prix']) - float(produit_2023['prix']),
                    'categorie': produit_2024['categorie']
                })
            else:
                rapport['inchanges'].append(produit_2024)
    
    # Produits supprimés (présents en 2023 mais pas en 2024)
    for nom, produit in produits_2023.items():
        if nom not in produits_2024:
            rapport['supprimes'].append(produit)
    
    return rapport

def generer_rapport_textuel(rapport, nom_fichier_rapport):
    """Génère un rapport textuel détaillé"""
    with open(nom_fichier_rapport, 'w', encoding='utf-8') as f:
        f.write("RAPPORT D'ÉVOLUTION DES PRODUITS 2023-2024\n")
        f.write("=" * 50 + "\n\n")
        
        # Statistiques générales
        f.write(f"📊 STATISTIQUES GÉNÉRALES\n")
        f.write(f"Produits ajoutés: {len(rapport['ajoutes'])}\n")
        f.write(f"Produits supprimés: {len(rapport['supprimes'])}\n")
        f.write(f"Produits modifiés: {len(rapport['modifies'])}\n")
        f.write(f"Produits inchangés: {len(rapport['inchanges'])}\n\n")
        
        # Détail des modifications
        if rapport['modifies']:
            f.write("💰 ÉVOLUTIONS DE PRIX\n")
            f.write("-" * 30 + "\n")
            for modif in rapport['modifies']:
                evolution = modif['evolution']
                signe = "📈" if evolution > 0 else "📉"
                f.write(f"{signe} {modif['nom']}: ")
                f.write(f"{modif['ancien_prix']:.2f}€ → {modif['nouveau_prix']:.2f}€ ")
                f.write(f"({evolution:+.2f}€)\n")
        
        # Nouveaux produits
        if rapport['ajoutes']:
            f.write(f"\n✅ NOUVEAUX PRODUITS ({len(rapport['ajoutes'])})\n")
            f.write("-" * 30 + "\n")
            for produit in rapport['ajoutes']:
                f.write(f"• {produit['nom']} - {produit['prix']}€ ")
                f.write(f"({produit['categorie']})\n")
        
        # Produits supprimés
        if rapport['supprimes']:
            f.write(f"\n❌ PRODUITS SUPPRIMÉS ({len(rapport['supprimes'])})\n")
            f.write("-" * 30 + "\n")
            for produit in rapport['supprimes']:
                f.write(f"• {produit['nom']} - {produit['prix']}€\n")
    
    print(f"Rapport généré: {nom_fichier_rapport}")

def analyser_evolution_categories(rapport):
    """Analyse les évolutions de prix par catégorie"""
    stats_categories = {}
    
    for modif in rapport['modifies']:
        cat = modif['categorie']
        if cat not in stats_categories:
            stats_categories[cat] = {
                'evolutions': [],
                'hausse_count': 0,
                'baisse_count': 0
            }
        
        evolution = modif['evolution']
        stats_categories[cat]['evolutions'].append(evolution)
        
        if evolution > 0:
            stats_categories[cat]['hausse_count'] += 1
        else:
            stats_categories[cat]['baisse_count'] += 1
    
    # Calcul des moyennes
    for cat, data in stats_categories.items():
        evolutions = data['evolutions']
        data['evolution_moyenne'] = sum(evolutions) / len(evolutions)
        data['total_modifies'] = len(evolutions)
    
    return stats_categories

# Utilisation complète
rapport = comparer_annees('produits_2023.csv', 'produits_2024.csv')
generer_rapport_textuel(rapport, 'rapport_evolution.txt')
stats_cat = analyser_evolution_categories(rapport)

print("Évolution par catégorie:")
for cat, stats in stats_cat.items():
    print(f"{cat}: {stats['evolution_moyenne']:+.2f}€ en moyenne")

import csv

def charger_employes(fichier):
    """Charge les employés depuis le CSV"""
    with open(fichier, 'r', newline='', encoding='utf-8') as f:
        return list(csv.DictReader(f))

def calculer_salaire_total(employes):
    """Ajoute le salaire total à chaque employé"""
    for employe in employes:
        salaire_base = float(employe['salaire_base'])
        heures_sup = float(employe['heures_sup'])
        taux_horaire = float(employe['taux_horaire'])
        
        # Ajout de la nouvelle clé au dictionnaire
        employe['salaire_total'] = salaire_base + (heures_sup * taux_horaire)
    
    return employes

# Test
employes = charger_employes('employes.csv')
employes = calculer_salaire_total(employes)
print(f"Premier employé: {employes[0]['prenom']} {employes[0]['nom']}")
print(f"Salaire total: {employes[0]['salaire_total']:.2f}€")

def top_employes_par_departement(employes, n=3):
    """Retourne les n meilleurs salaires par département"""
    # Groupement par département
    departements = {}
    for employe in employes:
        dept = employe['departement']
        if dept not in departements:
            departements[dept] = []
        departements[dept].append(employe)
    
    # Tri et sélection des top n pour chaque département
    top_par_dept = {}
    for dept, liste_employes in departements.items():
        # Tri par salaire total décroissant
        employes_tries = sorted(liste_employes, 
                               key=lambda x: x['salaire_total'], 
                               reverse=True)
        top_par_dept[dept] = employes_tries[:n]
    
    return top_par_dept

# Utilisation
top_employes = top_employes_par_departement(employes, 3)
for dept, top_liste in top_employes.items():
    print(f"\nTop 3 - {dept}:")
    for i, emp in enumerate(top_liste, 1):
        print(f"  {i}. {emp['prenom']} {emp['nom']}: {emp['salaire_total']:.2f}€")

from datetime import datetime

def enrichir_ventes(ventes):
    """Enrichit chaque vente avec CA et trimestre"""
    for vente in ventes:
        # Calcul du chiffre d'affaires
        quantite = float(vente['quantite'])
        prix_unitaire = float(vente['prix_unitaire'])
        vente['chiffre_affaires'] = quantite * prix_unitaire
        
        # Calcul du trimestre depuis la date
        date_vente = datetime.strptime(vente['date'], '%Y-%m-%d')
        mois = date_vente.month
        
        if mois <= 3:
            vente['trimestre'] = 'Q1'
        elif mois <= 6:
            vente['trimestre'] = 'Q2'
        elif mois <= 9:
            vente['trimestre'] = 'Q3'
        else:
            vente['trimestre'] = 'Q4'
    
    return ventes

# Test d'enrichissement
ventes = charger_ventes('ventes.csv')
ventes_enrichies = enrichir_ventes(ventes)
print(f"Première vente enrichie:")
print(f"CA: {ventes_enrichies[0]['chiffre_affaires']:.2f}€")
print(f"Trimestre: {ventes_enrichies[0]['trimestre']}")

def performance_vendeurs(ventes):
    """Analyse la performance de chaque vendeur"""
    performances = {}
    
    for vente in ventes:
        vendeur = vente['vendeur']
        ca = vente['chiffre_affaires']
        date_vente = datetime.strptime(vente['date'], '%Y-%m-%d')
        mois = date_vente.strftime('%Y-%m')
        
        # Initialisation du vendeur s'il n'existe pas
        if vendeur not in performances:
            performances[vendeur] = {
                'total_ca': 0,
                'nb_ventes': 0,
                'ventes_par_mois': {},
                'region': vente['region']  # Info supplémentaire
            }
        
        # Mise à jour des métriques
        perf = performances[vendeur]
        perf['total_ca'] += ca
        perf['nb_ventes'] += 1
        
        # Suivi par mois
        if mois not in perf['ventes_par_mois']:
            perf['ventes_par_mois'][mois] = 0
        perf['ventes_par_mois'][mois] += ca
    
    # Calculs finaux pour chaque vendeur
    for vendeur, perf in performances.items():
        perf['ca_moyen'] = perf['total_ca'] / perf['nb_ventes']
        
        # Meilleur mois
        meilleur_mois = max(perf['ventes_par_mois'].items(), 
                           key=lambda x: x[1])
        perf['meilleur_mois'] = meilleur_mois[0]
        perf['ca_meilleur_mois'] = meilleur_mois[1]
    
    return performances

# Utilisation et affichage
perfs = performance_vendeurs(ventes_enrichies)
for vendeur, stats in perfs.items():
    print(f"\n🏆 {vendeur} ({stats['region']}):")
    print(f"   CA Total: {stats['total_ca']:,.2f}€")
    print(f"   Nb ventes: {stats['nb_ventes']}")
    print(f"   CA moyen: {stats['ca_moyen']:.2f}€")
    print(f"   Meilleur mois: {stats['meilleur_mois']} ({stats['ca_meilleur_mois']:,.2f}€)")

def profil_utilisateur(ratings, user_id):
    """Génère le profil complet d'un utilisateur"""
    ratings_user = [r for r in ratings if r['user_id'] == user_id]
    
    if not ratings_user:
        return None
    
    # Calculs de base
    notes = [float(r['note']) for r in ratings_user]
    durees = [int(r['duree_minutes']) for r in ratings_user]
    
    # Analyse des genres
    compteur_genres = {}
    notes_par_genre = {}
    
    for rating in ratings_user:
        genre = rating['genre']
        note = float(rating['note'])
        
        # Comptage des genres
        compteur_genres[genre] = compteur_genres.get(genre, 0) + 1
        
        # Notes par genre
        if genre not in notes_par_genre:
            notes_par_genre[genre] = []
        notes_par_genre[genre].append(note)
    
    # Genres favoris (par fréquence et note moyenne)
    genres_avec_stats = []
    for genre, count in compteur_genres.items():
        note_moy_genre = sum(notes_par_genre[genre]) / len(notes_par_genre[genre])
        genres_avec_stats.append({
            'genre': genre,
            'count': count,
            'note_moyenne': note_moy_genre,
            'score_preference': count * note_moy_genre  # Score combiné
        })
    
    # Tri par score de préférence
    genres_favoris = sorted(genres_avec_stats, 
                           key=lambda x: x['score_preference'], 
                           reverse=True)
    
    return {
        'user_id': user_id,
        'nb_films_notes': len(ratings_user),
        'note_moyenne': sum(notes) / len(notes),
        'temps_total_minutes': sum(durees),
        'temps_total_heures': sum(durees) / 60,
        'genres_favoris': genres_favoris[:3],  # Top 3
        'meilleur_film': max(ratings_user, key=lambda x: float(x['note'])),
        'dernier_visionnage': max(ratings_user, key=lambda x: x['date_visionnage'])
    }

def calculer_similarite_utilisateurs(profil1, profil2):
    """Calcule la similarité entre deux profils utilisateur"""
    if not profil1 or not profil2:
        return 0
    
    # Similarité basée sur les notes moyennes
    diff_notes = abs(profil1['note_moyenne'] - profil2['note_moyenne'])
    sim_notes = max(0, 1 - diff_notes / 5)  # Normalisation sur 5
    
    # Similarité des genres favoris
    genres1 = set(g['genre'] for g in profil1['genres_favoris'])
    genres2 = set(g['genre'] for g in profil2['genres_favoris'])
    
    if genres1 and genres2:
        intersection = len(genres1.intersection(genres2))
        union = len(genres1.union(genres2))
        sim_genres = intersection / union if union > 0 else 0
    else:
        sim_genres = 0
    
    # Score de similarité combiné
    return (sim_notes * 0.4) + (sim_genres * 0.6)

def recommander_films(ratings, user_id, nb_recommandations=5):
    """Recommande des films basés sur des utilisateurs similaires"""
    # Profil de l'utilisateur cible
    profil_cible = profil_utilisateur(ratings, user_id)
    if not profil_cible:
        return []
    
    # Films déjà vus par l'utilisateur
    films_vus = set(r['film_titre'] for r in ratings if r['user_id'] == user_id)
    
    # Calcul de similarité avec tous les autres utilisateurs
    autres_users = list(set(r['user_id'] for r in ratings if r['user_id'] != user_id))
    similarities = []
    
    for other_user in autres_users:
        profil_autre = profil_utilisateur(ratings, other_user)
        if profil_autre:
            sim_score = calculer_similarite_utilisateurs(profil_cible, profil_autre)
            if sim_score > 0.3:  # Seuil de similarité
                similarities.append((other_user, sim_score))
    
    # Tri par similarité décroissante
    similarities.sort(key=lambda x: x[1], reverse=True)
    users_similaires = similarities[:10]  # Top 10 utilisateurs similaires
    
    # Collecte des recommandations
    recommandations = {}
    for similar_user, sim_score in users_similaires:
        user_ratings = [r for r in ratings if r['user_id'] == similar_user]
        
        for rating in user_ratings:
            film = rating['film_titre']
            note = float(rating['note'])
            
            # Seulement les films bien notés (>= 4) et non vus
            if note >= 4 and film not in films_vus:
                if film not in recommandations:
                    recommandations[film] = {
                        'score_total': 0,
                        'nb_recommandeurs': 0,
                        'genre': rating['genre'],
                        'duree_minutes': rating['duree_minutes']
                    }
                
                # Score pondéré par la similarité
                recommandations[film]['score_total'] += note * sim_score
                recommandations[film]['nb_recommandeurs'] += 1
    
    # Calcul du score final et tri
    films_recommandes = []
    for film, data in recommandations.items():
        if data['nb_recommandeurs'] >= 2:  # Au moins 2 recommandeurs
            score_final = data['score_total'] / data['nb_recommandeurs']
            films_recommandes.append({
                'film': film,
                'score': score_final,
                'genre': data['genre'],
                'duree_minutes': data['duree_minutes'],
                'nb_recommandeurs': data['nb_recommandeurs']
            })
    
    # Tri par score et retour des top recommandations
    films_recommandes.sort(key=lambda x: x['score'], reverse=True)
    return films_recommandes[:nb_recommandations]

# Utilisation complète
profil = profil_utilisateur(ratings, 'user_123')
print(f"Profil de {profil['user_id']}:")
print(f"Films notés: {profil['nb_films_notes']}")
print(f"Note moyenne: {profil['note_moyenne']:.2f}")
print(f"Genres favoris: {[g['genre'] for g in profil['genres_favoris']]}")

recommandations = recommander_films(ratings, 'user_123', 5)
print(f"\n🎬 Recommandations pour user_123:")
for i, rec in enumerate(recommandations, 1):
    print(f"{i}. {rec['film']} ({rec['genre']}) - Score: {rec['score']:.2f}")

from datetime import datetime
from collections import defaultdict
import pandas as pd

def calculer_portefeuille_actuel(transactions):
    """Calcule le portefeuille actuel de chaque client"""
    portefeuilles = defaultdict(lambda: defaultdict(lambda: {'quantite': 0, 'historique': []}))
    
    # Tri chronologique des transactions
    transactions_triees = sorted(transactions, 
                                key=lambda x: datetime.strptime(x['date'], '%Y-%m-%d'))
    
    for transaction in transactions_triees:
        client = transaction['client_id']
        symbole = transaction['symbole']
        quantite = int(transaction['quantite'])
        prix = float(transaction['prix'])
        frais = float(transaction['frais'])
        action = transaction['action_type']
        
        position = portefeuilles[client][symbole]
        
        if action == 'BUY':
            # Achat : augmente la position
            position['quantite'] += quantite
            position['historique'].append({
                'type': 'BUY',
                'quantite': quantite,
                'prix': prix,
                'frais': frais,
                'date': transaction['date']
            })
        
        elif action == 'SELL':
            # Vente : diminue la position
            position['quantite'] -= quantite
            position['historique'].append({
                'type': 'SELL',
                'quantite': quantite,
                'prix': prix,
                'frais': frais,
                'date': transaction['date']
            })
    
    # Nettoyage : suppression des positions nulles
    portefeuilles_nettoyes = {}
    for client, positions in portefeuilles.items():
        portefeuilles_nettoyes[client] = {
            symbole: data for symbole, data in positions.items() 
            if data['quantite'] > 0
        }
    
    return portefeuilles_nettoyes


def analyser_performance_client(transactions, client_id, prix_actuels):
    """Analyse complète de performance d'un client avec méthode FIFO"""
    
    # Filtrage des transactions du client
    trans_client = [t for t in transactions if t['client_id'] == client_id]
    trans_client = sorted(trans_client, 
                         key=lambda x: datetime.strptime(x['date'], '%Y-%m-%d'))
    
    # Structure pour gérer les positions FIFO
    positions = defaultdict(list)  # Liste des achats par symbole
    plus_values_realisees = []
    frais_totaux = 0
    
    for transaction in trans_client:
        symbole = transaction['symbole']
        quantite = int(transaction['quantite'])
        prix = float(transaction['prix'])
        frais = float(transaction['frais'])
        action = transaction['action_type']
        date = transaction['date']
        
        frais_totaux += frais
        
        if action == 'BUY':
            # Ajout à la pile FIFO
            positions[symbole].append({
                'quantite': quantite,
                'prix': prix,
                'date': date
            })
        
        elif action == 'SELL':
            # Vente FIFO : on vend les plus anciens achats en premier
            quantite_a_vendre = quantite
            
            while quantite_a_vendre > 0 and positions[symbole]:
                achat = positions[symbole][0]
                
                if achat['quantite'] <= quantite_a_vendre:
                    # Vente complète de cet achat
                    quantite_vendue = achat['quantite']
                    plus_value = (prix - achat['prix']) * quantite_vendue
                    
                    plus_values_realisees.append({
                        'symbole': symbole,
                        'quantite': quantite_vendue,
                        'prix_achat': achat['prix'],
                        'prix_vente': prix,
                        'plus_value': plus_value,
                        'date_achat': achat['date'],
                        'date_vente': date
                    })
                    
                    quantite_a_vendre -= quantite_vendue
                    positions[symbole].pop(0)  # Retrait de la pile
                
                else:
                    # Vente partielle
                    plus_value = (prix - achat['prix']) * quantite_a_vendre
                    
                    plus_values_realisees.append({
                        'symbole': symbole,
                        'quantite': quantite_a_vendre,
                        'prix_achat': achat['prix'],
                        'prix_vente': prix,
                        'plus_value': plus_value,
                        'date_achat': achat['date'],
                        'date_vente': date
                    })
                    
                    achat['quantite'] -= quantite_a_vendre
                    quantite_a_vendre = 0
    
    # Calcul des plus-values latentes (positions actuelles)
    plus_values_latentes = []
    valeur_portefeuille = 0
    cout_total_positions = 0
    
    for symbole, achats in positions.items():
        if symbole in prix_actuels:
            prix_actuel = prix_actuels[symbole]
            
            for achat in achats:
                quantite = achat['quantite']
                prix_achat = achat['prix']
                
                valeur_actuelle = quantite * prix_actuel
                cout_achat = quantite * prix_achat
                plus_value_latente = valeur_actuelle - cout_achat
                
                plus_values_latentes.append({
                    'symbole': symbole,
                    'quantite': quantite,
                    'prix_achat': prix_achat,
                    'prix_actuel': prix_actuel,
                    'plus_value_latente': plus_value_latente,
                    'valeur_actuelle': valeur_actuelle,
                    'date_achat': achat['date']
                })
                
                valeur_portefeuille += valeur_actuelle
                cout_total_positions += cout_achat
    
    # Calculs de synthèse
    total_plus_values_realisees = sum(pv['plus_value'] for pv in plus_values_realisees)
    total_plus_values_latentes = sum(pv['plus_value_latente'] for pv in plus_values_latentes)
    
    return {
        'client_id': client_id,
        'plus_values_realisees': plus_values_realisees,
        'plus_values_latentes': plus_values_latentes,
        'resume': {
            'total_pv_realisees': total_plus_values_realisees,
            'total_pv_latentes': total_plus_values_latentes,
            'total_pv_globales': total_plus_values_realisees + total_plus_values_latentes,
            'valeur_portefeuille': valeur_portefeuille,
            'cout_total_positions': cout_total_positions,
            'frais_totaux': frais_totaux,
            'rendement_net': ((total_plus_values_realisees + total_plus_values_latentes - frais_totaux) / cout_total_positions * 100) if cout_total_positions > 0 else 0
        }
    }


def analyser_risque_portefeuille(transactions, prix_actuels, volatilites):
    """Analyse de risque avancée pour tous les portefeuilles"""
    portefeuilles = calculer_portefeuille_actuel(transactions)
    analyses_risque = {}
    
    for client_id in portefeuilles.keys():
        performance = analyser_performance_client(transactions, client_id, prix_actuels)
        
        # Calcul de la répartition du portefeuille
        positions_actuelles = {}
        valeur_totale = performance['resume']['valeur_portefeuille']
        
        for pv_latente in performance['plus_values_latentes']:
            symbole = pv_latente['symbole']
            valeur = pv_latente['valeur_actuelle']
            
            if symbole in positions_actuelles:
                positions_actuelles[symbole] += valeur
            else:
                positions_actuelles[symbole] = valeur
        
        # Calcul du risque (écart-type pondéré)
        risque_portefeuille = 0
        if valeur_totale > 0:
            for symbole, valeur in positions_actuelles.items():
                poids = valeur / valeur_totale
                volatilite = volatilites.get(symbole, 0.2)  # 20% par défaut
                risque_portefeuille += (poids * volatilite) ** 2
            
            risque_portefeuille = (risque_portefeuille ** 0.5) * 100
        
        # Ratio de Sharpe simplifié (rendement / risque)
        rendement = performance['resume']['rendement_net']
        ratio_sharpe = rendement / risque_portefeuille if risque_portefeuille > 0 else 0
        
        analyses_risque[client_id] = {
            'risque_portefeuille': risque_portefeuille,
            'rendement_net': rendement,
            'ratio_sharpe': ratio_sharpe,
            'diversification': len(positions_actuelles),
            'concentration_max': (max(positions_actuelles.values()) / valeur_totale * 100) if valeur_totale > 0 else 0
        }
    
    return analyses_risque


def generer_rapport_complet(transactions, prix_actuels, volatilites=None):
    """Génère un rapport complet d'analyse de portefeuille"""
    if volatilites is None:
        # Volatilités par défaut pour l'exemple
        volatilites = {
            'AAPL': 0.25, 'GOOGL': 0.30, 'MSFT': 0.22, 'TSLA': 0.45,
            'AMZN': 0.28, 'META': 0.35, 'NVDA': 0.40
        }
    
    print("="*80)
    print("📊 RAPPORT D'ANALYSE DE PORTEFEUILLE - SOCIÉTÉ DE GESTION")
    print("="*80)
    
    # Analyse globale
    portefeuilles = calculer_portefeuille_actuel(transactions)
    analyses_risque = analyser_risque_portefeuille(transactions, prix_actuels, volatilites)
    
    print(f"\n📈 RÉSUMÉ EXÉCUTIF")
    print(f"Nombre de clients analysés: {len(portefeuilles)}")
    
    # Analyse par client
    for client_id in portefeuilles.keys():
        print(f"\n" + "="*60)
        print(f"💼 CLIENT: {client_id}")
        print("="*60)
        
        # Performance détaillée
        performance = analyser_performance_client(transactions, client_id, prix_actuels)
        resume = performance['resume']
        
        print(f"💰 PERFORMANCE FINANCIÈRE:")
        print(f"  • Valeur du portefeuille: {resume['valeur_portefeuille']:,.2f} €")
        print(f"  • Plus-values réalisées: {resume['total_pv_realisees']:,.2f} €")
        print(f"  • Plus-values latentes: {resume['total_pv_latentes']:,.2f} €")
        print(f"  • Frais totaux: {resume['frais_totaux']:,.2f} €")
        print(f"  • Rendement net: {resume['rendement_net']:.2f}%")
        
        # Analyse de risque
        if client_id in analyses_risque:
            risque = analyses_risque[client_id]
            print(f"\n⚠️  ANALYSE DE RISQUE:")
            print(f"  • Risque du portefeuille: {risque['risque_portefeuille']:.2f}%")
            print(f"  • Ratio de Sharpe: {risque['ratio_sharpe']:.2f}")
            print(f"  • Diversification: {risque['diversification']} titres")
            print(f"  • Concentration max: {risque['concentration_max']:.1f}%")
        
        # Détail des positions actuelles
        print(f"\n📋 POSITIONS ACTUELLES:")
        portefeuille_client = portefeuilles[client_id]
        for symbole, data in portefeuille_client.items():
            if symbole in prix_actuels:
                valeur = data['quantite'] * prix_actuels[symbole]
                print(f"  • {symbole}: {data['quantite']} actions → {valeur:,.2f} €")
        
        # Top 3 des meilleures plus-values réalisées
        if performance['plus_values_realisees']:
            print(f"\n🏆 TOP 3 MEILLEURES OPÉRATIONS:")
            top_operations = sorted(performance['plus_values_realisees'], 
                                  key=lambda x: x['plus_value'], reverse=True)[:3]
            for i, op in enumerate(top_operations, 1):
                print(f"  {i}. {op['symbole']}: +{op['plus_value']:,.2f} € "
                      f"({op['quantite']} actions à {op['prix_vente']:.2f} €)")
    
    return {
        'portefeuilles': portefeuilles,
        'analyses_performance': {client_id: analyser_performance_client(transactions, client_id, prix_actuels) 
                               for client_id in portefeuilles.keys()},
        'analyses_risque': analyses_risque
    }


# ========================================
# EXEMPLE D'UTILISATION ET TESTS
# ========================================

if __name__ == "__main__":
    # Données de test
    transactions_exemple = [
        {'client_id': 'C001', 'date': '2023-01-15', 'action_type': 'BUY', 'symbole': 'AAPL', 'quantite': 100, 'prix': 150.0, 'frais': 10.0},
        {'client_id': 'C001', 'date': '2023-02-01', 'action_type': 'BUY', 'symbole': 'GOOGL', 'quantite': 50, 'prix': 2800.0, 'frais': 15.0},
        {'client_id': 'C001', 'date': '2023-03-15', 'action_type': 'SELL', 'symbole': 'AAPL', 'quantite': 30, 'prix': 165.0, 'frais': 8.0},
        {'client_id': 'C001', 'date': '2023-04-01', 'action_type': 'BUY', 'symbole': 'MSFT', 'quantite': 75, 'prix': 280.0, 'frais': 12.0},
        
        {'client_id': 'C002', 'date': '2023-01-20', 'action_type': 'BUY', 'symbole': 'TSLA', 'quantite': 80, 'prix': 200.0, 'frais': 20.0},
        {'client_id': 'C002', 'date': '2023-02-15', 'action_type': 'BUY', 'symbole': 'NVDA', 'quantite': 40, 'prix': 450.0, 'frais': 18.0},
        {'client_id': 'C002', 'date': '2023-03-01', 'action_type': 'SELL', 'symbole': 'TSLA', 'quantite': 20, 'prix': 250.0, 'frais': 10.0},
    ]
    
    prix_actuels_exemple = {
        'AAPL': 175.0,
        'GOOGL': 2900.0,
        'MSFT': 320.0,
        'TSLA': 240.0,
        'NVDA': 520.0
    }
    
    # Test des fonctions
    print("🧪 TESTS DES FONCTIONS")
    print("-" * 50)
    
    # Test 1: Calcul des portefeuilles actuels
    print("✅ Test 1: Portefeuilles actuels")
    portefeuilles = calculer_portefeuille_actuel(transactions_exemple)
    for client, positions in portefeuilles.items():
        print(f"  {client}: {len(positions)} positions")
    
    # Test 2: Analyse de performance
    print("\n✅ Test 2: Analyse de performance C001")
    perf_c001 = analyser_performance_client(transactions_exemple, 'C001', prix_actuels_exemple)
    print(f"  Plus-values réalisées: {perf_c001['resume']['total_pv_realisees']:.2f} €")
    print(f"  Plus-values latentes: {perf_c001['resume']['total_pv_latentes']:.2f} €")
    
    # Test 3: Rapport complet
    print("\n" + "="*80)
    print("📊 GÉNÉRATION DU RAPPORT COMPLET")
    print("="*80)
    
    rapport = generer_rapport_complet(transactions_exemple, prix_actuels_exemple)