app.py

import os, shutil
# Désactiver les analytics Gradio dès le débu
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
# shutil.rmtree(os.path.expanduser("~/.cache/huggingface/datasets"), ignore_errors=True)

import gradio as gr
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import warnings
from datasets import load_dataset
import pandas as pd
from huggingface_hub import HfApi, hf_hub_download
import urllib.parse
warnings.filterwarnings('ignore')

# Configuration Hugging Face
hf_token = os.environ.get("HF_TOKEN")
dataset_id = "HackathonCRA/2024"

# Configuration des graphiques
plt.style.use('default')
sns.set_palette("husl")

class AgricultureAnalyzer:
    def __init__(self):
        self.df = None
        self.risk_analysis = None

    def load_data(self):
        """Charge les données du dataset Hugging Face"""
        print("🔄 Chargement des données depuis Hugging Face...")
        print(f"📋 Dataset ID: {dataset_id}")
        print(f"📋 Token disponible: {'Oui' if hf_token else 'Non'}")

        self.df = None

        # 1) Tentative de chargement direct via datasets.load_dataset
        try:
            dataset = load_dataset(
                dataset_id,
                split="train",
                token=hf_token,
                trust_remote_code=True,
            )
            print(f"📊 Dataset chargé: {len(dataset)} exemples")

            try:
                self.df = dataset.to_pandas()
                print("✅ Conversion to_pandas() réussie")
            except Exception as pandas_error:
                print(f"❌ Erreur to_pandas(): {pandas_error}")
                print("🔄 Tentative de conversion manuelle...")
                data_list = []
                for i, item in enumerate(dataset):
                    data_list.append(item)
                    if i < 5:
                        print(f"📋 Exemple {i}: {list(item.keys())}")
                self.df = pd.DataFrame(data_list)
                print(f"✅ Conversion manuelle réussie: {len(self.df)} lignes")
        except Exception as e:
            print(f"❌ Erreur lors du chargement depuis Hugging Face: {str(e)}")
            print(f"❌ Type d'erreur: {type(e).__name__}")
            # 2) Fallback: récupérer directement les fichiers du repo (csv/parquet/tsv/json)
            fallback_msg = self._fallback_load_from_repo_files()
            if self.df is None:
                return f"❌ Erreur lors du chargement du dataset : {str(e)} | Fallback: {fallback_msg}"

        # Si on n'a toujours pas de dataframe, arrêter
        if self.df is None:
            return "❌ Impossible de charger les données"

        print(f"📊 Données chargées: {len(self.df)} lignes")
        print(f"📊 Colonnes disponibles: {list(self.df.columns)}")

        # Nettoyage et validation
        required_columns = ["numparcell", "surfparc", "millesime"]
        missing_cols = [col for col in required_columns if col not in self.df.columns]

        if missing_cols:
            print(f"❌ Colonnes manquantes: {missing_cols}")
            self.df = None
            return f"❌ Colonnes manquantes: {missing_cols}"

        # Nettoyage
        initial_len = len(self.df)
        self.df = self.df.dropna(subset=required_columns)

        print(f"📊 Avant nettoyage: {initial_len} lignes")
        print(f"📊 Après nettoyage: {len(self.df)} lignes")

    def _fallback_load_from_repo_files(self):
        """Fallback pour charger les données en téléchargeant directement les fichiers du repo HF."""
        try:
            print("🔄 Tentative de chargement alternatif via fichiers du dépôt Hugging Face...")
            api = HfApi()
            files = api.list_repo_files(repo_id=dataset_id, repo_type="dataset", token=hf_token)
            if not files:
                print("❌ Aucun fichier dans le dépôt")
                return "Aucun fichier trouvé dans le dépôt."

            data_files = [
                f for f in files if f.lower().endswith((".parquet", ".csv", ".tsv", ".json"))
            ]
            if not data_files:
                print("❌ Aucun fichier de données exploitable (csv/tsv/parquet/json)")
                return "Aucun fichier exploitable (csv/tsv/parquet/json)."

            # Priorité: parquet > csv > tsv > json
            for ext in [".parquet", ".csv", ".tsv", ".json"]:
                selected = [f for f in data_files if f.lower().endswith(ext)]
                if selected:
                    chosen_ext = ext
                    selected_files = selected
                    break

            print(f"📂 Fichiers détectés ({chosen_ext}): {selected_files[:5]}{' ...' if len(selected_files) > 5 else ''}")

            local_paths = []
            for f in selected_files:
                local_path = hf_hub_download(
                    repo_id=dataset_id,
                    repo_type="dataset",
                    filename=f,
                    token=hf_token,
                )
                local_paths.append(local_path)

            frames = []
            if chosen_ext == ".parquet":
                for p in local_paths:
                    frames.append(pd.read_parquet(p))
            elif chosen_ext == ".csv":
                for p in local_paths:
                    frames.append(pd.read_csv(p))
            elif chosen_ext == ".tsv":
                for p in local_paths:
                    frames.append(pd.read_csv(p, sep="\t"))
            elif chosen_ext == ".json":
                for p in local_paths:
                    try:
                        frames.append(pd.read_json(p, lines=True))
                    except Exception:
                        frames.append(pd.read_json(p))

            self.df = pd.concat(frames, ignore_index=True) if len(frames) > 1 else frames[0]
            print(f"✅ Fallback réussi: {len(self.df)} lignes chargées depuis les fichiers du dépôt")
            return None
        except Exception as e:
            print(f"❌ Fallback échoué: {e}")
            # Dernier recours: fichier local d'exemple
            sample_path = os.path.join(os.path.dirname(__file__), "sample_data.csv")
            if os.path.exists(sample_path):
                try:
                    self.df = pd.read_csv(sample_path)
                    print(f"✅ Chargement du fichier local 'sample_data.csv' ({len(self.df)} lignes)")
                    return "Chargement via fichier local de secours."
                except Exception as e2:
                    print(f"❌ Échec du chargement du fichier local: {e2}")
            return f"Fallback échoué: {e}"

    
    def analyze_data(self):
        """Analyse des données et calcul des risques"""
        if self.df is None or len(self.df) == 0:
            print("❌ Pas de données à analyser")
            return "Erreur: Aucune donnée chargée"
        
        try:
            print(f"🔄 Début de l'analyse sur {len(self.df)} enregistrements...")
            
            # Analyse générale
            general_stats = {
                'total_parcelles': self.df['numparcell'].nunique(),
                'total_interventions': len(self.df),
                'surface_totale': self.df['surfparc'].sum(),
                'surface_moyenne': self.df['surfparc'].mean(),
                'periode': f"{self.df['millesime'].min()} - {self.df['millesime'].max()}"
            }
            
            # Analyse des herbicides
            if 'familleprod' in self.df.columns:
                herbicides_df = self.df[self.df['familleprod'] == 'Herbicides'].copy()
                herbicide_stats = {
                    'nb_interventions_herbicides': len(herbicides_df),
                    'pourcentage_herbicides': (len(herbicides_df) / len(self.df)) * 100,
                    'parcelles_traitees': herbicides_df['numparcell'].nunique()
                }
            else:
                herbicide_stats = {
                    'nb_interventions_herbicides': 0,
                    'pourcentage_herbicides': 0,
                    'parcelles_traitees': 0
                }
            
            # Calcul de l'analyse des risques
            self.calculate_risk_analysis()
            
            print("✅ Analyse terminée avec succès")
            return general_stats, herbicide_stats
            
        except Exception as e:
            print(f"❌ Erreur lors de l'analyse: {str(e)}")
            return None, None
    
    def calculate_risk_analysis(self):
        """Calcule l'analyse des risques par parcelle"""
        try:
            print("🔄 Calcul de l'analyse des risques...")
            
            # Vérifier les colonnes nécessaires
            required_group_cols = ['numparcell', 'surfparc']
            optional_group_cols = ['nomparc', 'libelleusag']
            
            # Construire la liste des colonnes de groupement disponibles
            group_cols = [col for col in required_group_cols if col in self.df.columns]
            group_cols.extend([col for col in optional_group_cols if col in self.df.columns])
            
            if len(group_cols) < 2:
                print(f"❌ Colonnes insuffisantes pour le groupement: {group_cols}")
                self.risk_analysis = pd.DataFrame()
                return
            
            # Construire l'agrégation selon les colonnes disponibles
            agg_dict = {}
            if 'familleprod' in self.df.columns:
                agg_dict['familleprod'] = lambda x: (x == 'Herbicides').sum()
            if 'libevenem' in self.df.columns:
                agg_dict['libevenem'] = lambda x: len(x.unique())
            if 'produit' in self.df.columns:
                agg_dict['produit'] = lambda x: len(x.unique())
            if 'quantitetot' in self.df.columns:
                agg_dict['quantitetot'] = 'sum'
            
            if not agg_dict:
                print("❌ Aucune colonne disponible pour l'agrégation")
                self.risk_analysis = pd.DataFrame()
                return
                
            # Groupement des données par parcelle
            risk_analysis = self.df.groupby(group_cols).agg(agg_dict).round(2)
            
            # Quantités d'herbicides spécifiques (seulement si les colonnes existent)
            if 'familleprod' in self.df.columns and 'quantitetot' in self.df.columns:
                herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
                if len(herbicides_df) > 0:
                    herbicide_quantities = herbicides_df.groupby(group_cols)['quantitetot'].sum().fillna(0)
                    risk_analysis['Quantite_herbicides'] = herbicide_quantities.reindex(risk_analysis.index, fill_value=0)
                else:
                    risk_analysis['Quantite_herbicides'] = 0
            else:
                risk_analysis['Quantite_herbicides'] = 0
            
            # Renommer les colonnes de façon sécurisée
            new_column_names = {}
            if 'familleprod' in agg_dict:
                new_column_names['familleprod'] = 'Nb_herbicides'
            if 'libevenem' in agg_dict:
                new_column_names['libevenem'] = 'Diversite_evenements'
            if 'produit' in agg_dict:
                new_column_names['produit'] = 'Diversite_produits'
            if 'quantitetot' in agg_dict:
                new_column_names['quantitetot'] = 'Quantite_totale'
                
            risk_analysis = risk_analysis.rename(columns=new_column_names)
            
            # Calcul de l'IFT approximatif
            if 'surfparc' in group_cols:
                risk_analysis['IFT_herbicide_approx'] = (risk_analysis['Quantite_herbicides'] / 
                                                        risk_analysis.index.get_level_values('surfparc')).round(2)
            else:
                risk_analysis['IFT_herbicide_approx'] = 0
            
            # Classification du risque
            def classify_risk(row):
                ift = row.get('IFT_herbicide_approx', 0)
                nb_herb = row.get('Nb_herbicides', 0)
                
                if ift == 0 and nb_herb == 0:
                    return 'TRÈS FAIBLE'
                elif ift < 1 and nb_herb <= 1:
                    return 'FAIBLE'
                elif ift < 3 and nb_herb <= 3:
                    return 'MODÉRÉ'
                elif ift < 5 and nb_herb <= 5:
                    return 'ÉLEVÉ'
                else:
                    return 'TRÈS ÉLEVÉ'
            
            risk_analysis['Risque_adventice'] = risk_analysis.apply(classify_risk, axis=1)
            
            # Tri par risque
            risk_order = ['TRÈS FAIBLE', 'FAIBLE', 'MODÉRÉ', 'ÉLEVÉ', 'TRÈS ÉLEVÉ']
            risk_analysis['Risk_Score'] = risk_analysis['Risque_adventice'].map({r: i for i, r in enumerate(risk_order)})
            
            self.risk_analysis = risk_analysis.sort_values(['Risk_Score', 'IFT_herbicide_approx'])
            print(f"✅ Analyse des risques terminée: {len(self.risk_analysis)} parcelles analysées")
            
        except Exception as e:
            print(f"❌ Erreur lors du calcul des risques: {str(e)}")
            self.risk_analysis = pd.DataFrame()
    
    def get_summary_stats(self):
        """Retourne les statistiques de résumé"""
        if self.df is None:
            return "Aucune donnée disponible"
        
        stats_text = f"""
        ## 📊 Statistiques Générales
        - **Nombre total de parcelles**: {self.df['numparcell'].nunique()}
        - **Nombre d'interventions**: {len(self.df):,}
        - **Surface totale**: {self.df['surfparc'].sum():.2f} hectares
        - **Surface moyenne par parcelle**: {self.df['surfparc'].mean():.2f} hectares
        - **Période**: {self.df['millesime'].min()} - {self.df['millesime'].max()}
        
        ## 🧪 Analyse Herbicides
        """
        
        herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
        if len(herbicides_df) > 0:
            stats_text += f"""
        - **Interventions herbicides**: {len(herbicides_df)} ({(len(herbicides_df)/len(self.df)*100):.1f}%)
        - **Parcelles traitées**: {herbicides_df['numparcell'].nunique()}
        - **Produits herbicides différents**: {herbicides_df['produit'].nunique()}
        """
        
        if self.risk_analysis is not None:
            risk_distribution = self.risk_analysis['Risque_adventice'].value_counts()
            stats_text += f"""
        
        ## 🎯 Répartition des Risques Adventices
        """
            for risk_level in ['TRÈS FAIBLE', 'FAIBLE', 'MODÉRÉ', 'ÉLEVÉ', 'TRÈS ÉLEVÉ']:
                if risk_level in risk_distribution:
                    count = risk_distribution[risk_level]
                    pct = (count / len(self.risk_analysis)) * 100
                    stats_text += f"- **{risk_level}**: {count} parcelles ({pct:.1f}%)\n"
        
        return stats_text
    
    def get_low_risk_recommendations(self):
        """Retourne les recommandations pour les parcelles à faible risque"""
        if self.risk_analysis is None:
            return "Analyse des risques non disponible"
        
        low_risk = self.risk_analysis[
            self.risk_analysis['Risque_adventice'].isin(['TRÈS FAIBLE', 'FAIBLE'])
        ].head(10)
        
        recommendations = "## 🌾 TOP 10 - Parcelles Recommandées pour Cultures Sensibles (Pois, Haricot)\n\n"
        
        for idx, row in low_risk.iterrows():
            if isinstance(idx, tuple) and len(idx) >= 4:
                parcelle, nom, culture, surface = idx[:4]
            else:
                # Fallback si l'index n'est pas un tuple de 4 éléments
                parcelle = str(idx)
                nom = "N/A"
                culture = "N/A"
                surface = row.get('surfparc', 0) if 'surfparc' in row else 0
            
            recommendations += f"""
**Parcelle {parcelle}** ({nom})
- Culture actuelle: {culture}
- Surface: {surface:.2f} ha
- Niveau de risque: {row['Risque_adventice']}
- IFT herbicide: {row['IFT_herbicide_approx']:.2f}
- Nombre d'herbicides: {row.get('Nb_herbicides', 0)}

---
"""
        
        return recommendations
    
    def create_risk_visualization(self):
        """Crée la visualisation des risques"""
        if self.risk_analysis is None or len(self.risk_analysis) == 0:
            # Créer un graphique vide avec message d'erreur
            fig = px.scatter(title="❌ Aucune donnée d'analyse des risques disponible")
            fig.add_annotation(text="Veuillez charger les données d'abord", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        risk_df = self.risk_analysis.reset_index()
        
        # Vérifier quelles colonnes sont disponibles pour hover_data
        available_hover_cols = []
        for col in ['nomparc', 'libelleusag']:
            if col in risk_df.columns:
                available_hover_cols.append(col)
        
        fig = px.scatter(risk_df, 
                        x='surfparc', 
                        y='IFT_herbicide_approx',
                        color='Risque_adventice',
                        size='Nb_herbicides',
                        hover_data=available_hover_cols if available_hover_cols else None,
                        color_discrete_map={
                            'TRÈS FAIBLE': 'green',
                            'FAIBLE': 'lightgreen', 
                            'MODÉRÉ': 'orange',
                            'ÉLEVÉ': 'red',
                            'TRÈS ÉLEVÉ': 'darkred'
                        },
                        title="🎯 Analyse du Risque Adventice par Parcelle",
                        labels={
                            'surfparc': 'Surface de la parcelle (ha)',
                            'IFT_herbicide_approx': 'IFT Herbicide (approximatif)',
                            'Risque_adventice': 'Niveau de risque'
                        })
        
        fig.update_layout(width=800, height=600, title_font_size=16)
        return fig
    
    def create_culture_analysis(self):
        """Analyse par type de culture"""
        if self.df is None or len(self.df) == 0:
            # Créer un graphique vide avec message d'erreur
            fig = px.pie(title="❌ Aucune donnée disponible")
            fig.add_annotation(text="Veuillez charger les données d'abord", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        culture_counts = self.df['libelleusag'].value_counts()
        
        fig = px.pie(values=culture_counts.values, 
                    names=culture_counts.index,
                    title="🌱 Répartition des Cultures")
        
        fig.update_layout(width=700, height=500)
        return fig
    
    def create_risk_distribution(self):
        """Distribution des niveaux de risque"""
        if self.risk_analysis is None or len(self.risk_analysis) == 0:
            # Créer un graphique vide avec message d'erreur
            fig = px.bar(title="❌ Aucune analyse des risques disponible")
            fig.add_annotation(text="Veuillez charger les données d'abord", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        risk_counts = self.risk_analysis['Risque_adventice'].value_counts()
        
        fig = px.bar(x=risk_counts.index, 
                    y=risk_counts.values,
                    color=risk_counts.index,
                    color_discrete_map={
                        'TRÈS FAIBLE': 'green',
                        'FAIBLE': 'lightgreen', 
                        'MODÉRÉ': 'orange',
                        'ÉLEVÉ': 'red',
                        'TRÈS ÉLEVÉ': 'darkred'
                    },
                    title="📊 Distribution des Niveaux de Risque Adventice",
                    labels={'x': 'Niveau de risque', 'y': 'Nombre de parcelles'})
        
        fig.update_layout(width=700, height=500, showlegend=False)
        return fig
    
    def get_available_years(self):
        """Retourne la liste des années disponibles dans les données"""
        if self.df is None or len(self.df) == 0:
            return []
        
        years = sorted(self.df['millesime'].dropna().unique())
        return [int(year) for year in years if pd.notna(year)]
    
    def filter_data_by_year(self, year):
        """Filtre les données par année"""
        if self.df is None or year is None:
            return None
        
        year_data = self.df[self.df['millesime'] == year].copy()
        return year_data
    
    def get_year_summary_stats(self, year):
        """Retourne les statistiques de résumé pour une année spécifique"""
        year_data = self.filter_data_by_year(year)
        
        if year_data is None or len(year_data) == 0:
            return f"❌ Aucune donnée disponible pour l'année {year}"
        
        stats_text = f"""
        ## 📊 Statistiques pour l'année {year}
        - **Nombre de parcelles**: {year_data['numparcell'].nunique()}
        - **Nombre d'interventions**: {len(year_data):,}
        - **Surface totale**: {year_data['surfparc'].sum():.2f} hectares
        - **Surface moyenne par parcelle**: {year_data['surfparc'].mean():.2f} hectares
        
        ## 🧪 Analyse Herbicides
        """
        
        if 'familleprod' in year_data.columns:
            herbicides_df = year_data[year_data['familleprod'] == 'Herbicides']
            if len(herbicides_df) > 0:
                stats_text += f"""
        - **Interventions herbicides**: {len(herbicides_df)} ({(len(herbicides_df)/len(year_data)*100):.1f}%)
        - **Parcelles traitées**: {herbicides_df['numparcell'].nunique()}
        - **Produits herbicides différents**: {herbicides_df['produit'].nunique()}
        """
            else:
                stats_text += "\n- **Aucune intervention herbicide cette année**"
        
        return stats_text
    
    def create_year_culture_analysis(self, year):
        """Analyse par type de culture pour une année spécifique"""
        year_data = self.filter_data_by_year(year)
        
        if year_data is None or len(year_data) == 0:
            fig = px.pie(title=f"❌ Aucune donnée disponible pour {year}")
            fig.add_annotation(text=f"Aucune donnée pour l'année {year}", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        if 'libelleusag' not in year_data.columns:
            fig = px.pie(title=f"❌ Données de culture manquantes pour {year}")
            fig.add_annotation(text="Colonne 'libelleusag' manquante", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        culture_counts = year_data['libelleusag'].value_counts()
        
        fig = px.pie(values=culture_counts.values, 
                    names=culture_counts.index,
                    title=f"🌱 Répartition des Cultures - {year}")
        
        fig.update_layout(width=700, height=500)
        return fig
    
    def create_year_interventions_timeline(self, year):
        """Crée un graphique temporel des interventions pour une année"""
        year_data = self.filter_data_by_year(year)
        
        if year_data is None or len(year_data) == 0:
            fig = px.bar(title=f"❌ Aucune donnée disponible pour {year}")
            fig.add_annotation(text=f"Aucune donnée pour l'année {year}", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        if 'datedebut' not in year_data.columns:
            # Fallback: graphique des types d'événements
            if 'libevenem' in year_data.columns:
                event_counts = year_data['libevenem'].value_counts()
                fig = px.bar(x=event_counts.index, 
                            y=event_counts.values,
                            title=f"📊 Types d'Interventions - {year}",
                            labels={'x': 'Type d\'intervention', 'y': 'Nombre'})
                fig.update_layout(width=800, height=500)
                fig.update_xaxis(tickangle=45)
                return fig
            else:
                fig = px.bar(title=f"❌ Données d'intervention manquantes pour {year}")
                fig.add_annotation(text="Colonnes de dates manquantes", 
                                 xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
                return fig
        
        # Convertir les dates et créer le graphique temporel
        try:
            year_data['datedebut_parsed'] = pd.to_datetime(year_data['datedebut'], 
                                                          format='%d/%m/%y', errors='coerce')
            year_data['mois'] = year_data['datedebut_parsed'].dt.month
            
            monthly_counts = year_data.groupby('mois').size().reset_index()
            monthly_counts.columns = ['mois', 'nb_interventions']
            
            # Ajouter les noms des mois
            month_names = {1: 'Jan', 2: 'Fév', 3: 'Mar', 4: 'Avr', 5: 'Mai', 6: 'Jun',
                          7: 'Jul', 8: 'Aoû', 9: 'Sep', 10: 'Oct', 11: 'Nov', 12: 'Déc'}
            monthly_counts['mois_nom'] = monthly_counts['mois'].map(month_names)
            
            fig = px.bar(monthly_counts, 
                        x='mois_nom', 
                        y='nb_interventions',
                        title=f"📅 Répartition Mensuelle des Interventions - {year}",
                        labels={'mois_nom': 'Mois', 'nb_interventions': 'Nombre d\'interventions'})
            
            fig.update_layout(width=800, height=500)
            return fig
            
        except Exception as e:
            print(f"❌ Erreur lors de la création du graphique temporel: {e}")
            # Fallback vers le graphique des événements
            if 'libevenem' in year_data.columns:
                event_counts = year_data['libevenem'].value_counts()
                fig = px.bar(x=event_counts.index, 
                            y=event_counts.values,
                            title=f"📊 Types d'Interventions - {year}",
                            labels={'x': 'Type d\'intervention', 'y': 'Nombre'})
                fig.update_layout(width=800, height=500)
                fig.update_xaxis(tickangle=45)
                return fig
            else:
                fig = px.bar(title=f"❌ Erreur lors du traitement des données {year}")
                return fig
    
    def create_year_herbicide_analysis(self, year):
        """Analyse des herbicides pour une année spécifique"""
        year_data = self.filter_data_by_year(year)
        
        if year_data is None or len(year_data) == 0:
            fig = px.bar(title=f"❌ Aucune donnée disponible pour {year}")
            fig.add_annotation(text=f"Aucune donnée pour l'année {year}", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        if 'familleprod' not in year_data.columns:
            fig = px.bar(title=f"❌ Données de produits manquantes pour {year}")
            fig.add_annotation(text="Colonne 'familleprod' manquante", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        herbicides_df = year_data[year_data['familleprod'] == 'Herbicides']
        
        if len(herbicides_df) == 0:
            fig = px.bar(title=f"✅ Aucun herbicide utilisé en {year}")
            fig.add_annotation(text=f"Aucune intervention herbicide en {year}", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig
        
        if 'produit' in herbicides_df.columns:
            herbicide_counts = herbicides_df['produit'].value_counts().head(10)
            
            fig = px.bar(x=herbicide_counts.values, 
                        y=herbicide_counts.index,
                        orientation='h',
                        title=f"🧪 Top 10 Herbicides Utilisés - {year}",
                        labels={'x': 'Nombre d\'utilisations', 'y': 'Produit'})
            
            fig.update_layout(width=800, height=500)
            return fig
        else:
            fig = px.bar(title=f"❌ Détails des produits manquants pour {year}")
            fig.add_annotation(text="Colonne 'produit' manquante", 
                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
            return fig

# Initialisation de l'analyseur
analyzer = AgricultureAnalyzer()
analyzer.load_data()
analyzer.analyze_data()  # Analyse des données après chargement

# Interface Gradio
def create_interface():
    with gr.Blocks(title="🌾 Analyse Adventices Agricoles CRA", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🌾 Analyse des Adventices Agricoles - CRA Bretagne
        
        **Objectif**: Anticiper et réduire la pression des adventices dans les parcelles agricoles bretonnes
        
        Cette application analyse les données historiques pour identifier les parcelles les plus adaptées 
        à la culture de plantes sensibles comme le pois ou le haricot.
        """)
        
        with gr.Tabs():
            with gr.TabItem("📊 Vue d'ensemble"):
                gr.Markdown("## Statistiques générales des données agricoles")
                
                stats_output = gr.Markdown(analyzer.get_summary_stats())
                
                with gr.Row():
                    culture_plot = gr.Plot(analyzer.create_culture_analysis())
                    risk_dist_plot = gr.Plot(analyzer.create_risk_distribution())
            
            with gr.TabItem("🎯 Analyse des Risques"):
                gr.Markdown("## Cartographie des risques adventices par parcelle")
                
                risk_plot = gr.Plot(analyzer.create_risk_visualization())
                
                gr.Markdown("""
                **Interprétation du graphique**:
                - **Axe X**: Surface de la parcelle (hectares)
                - **Axe Y**: IFT Herbicide approximatif 
                - **Couleur**: Niveau de risque adventice
                - **Taille**: Nombre d'herbicides utilisés
                
                Les parcelles vertes (risque faible) sont idéales pour les cultures sensibles.
                """)
            
            with gr.TabItem("🌾 Recommandations"):
                reco_output = gr.Markdown(analyzer.get_low_risk_recommendations())
                
                gr.Markdown("""
                ## 💡 Conseils pour la gestion des adventices
                
                ### Parcelles à Très Faible Risque (Vertes)
                - ✅ **Idéales pour pois et haricot**
                - ✅ Historique d'usage herbicide minimal
                - ✅ Pression adventice faible attendue
                
                ### Parcelles à Faible Risque (Vert clair)
                - ⚠️ Surveillance légère recommandée
                - ✅ Conviennent aux cultures sensibles avec précautions
                
                ### Parcelles à Risque Modéré/Élevé (Orange/Rouge)
                - ❌ Éviter pour cultures sensibles
                - 🔍 Rotation nécessaire avant implantation
                - 📈 Surveillance renforcée des adventices
                
                ### Stratégies alternatives
                - **Rotation longue**: 3-4 ans avant cultures sensibles
                - **Cultures intermédiaires**: CIPAN pour réduire la pression
                - **Techniques mécaniques**: Hersage, binage
                - **Biostimulants**: Renforcement naturel des cultures
                """)
            
            with gr.TabItem("ℹ️ À propos"):
                gr.Markdown("""
                ## 🎯 Méthodologie
                
                Cette analyse se base sur :
                
                ### Calcul de l'IFT (Indice de Fréquence de Traitement)
                - **IFT ≈ Quantité appliquée / Surface de parcelle**
                - Indicateur de l'intensité des traitements herbicides
                
                ### Classification des risques
                - **TRÈS FAIBLE**: IFT = 0, aucun herbicide
                - **FAIBLE**: IFT < 1, usage minimal
                - **MODÉRÉ**: IFT < 3, usage modéré  
                - **ÉLEVÉ**: IFT < 5, usage important
                - **TRÈS ÉLEVÉ**: IFT ≥ 5, usage intensif
                
                ### Données analysées
                - **Source**: Station Expérimentale de Kerguéhennec
                - **Période**: Campagne 2025
                - **Variables**: Interventions, produits, quantités, surfaces
                
                ---
                
                **Développé pour le Hackathon CRA Bretagne** 🏆
                
                *Application d'aide à la décision pour une agriculture durable*
                """)
        
        # Bouton de rafraîchissement
        refresh_btn = gr.Button("🔄 Actualiser les données", variant="secondary")
        
        def refresh_data():
            analyzer.load_data()
            analyzer.analyze_data()  # Recalculer l'analyse après rechargement
            return (
                analyzer.get_summary_stats(),
                analyzer.create_culture_analysis(),
                analyzer.create_risk_distribution(),
                analyzer.create_risk_visualization(),
                analyzer.get_low_risk_recommendations()
            )
        
        refresh_btn.click(
            refresh_data,
            outputs=[stats_output, culture_plot, risk_dist_plot, risk_plot, reco_output]
        )
    
    return demo

# Lancement de l'application
if __name__ == "__main__":
    demo = create_interface()
    # Configuration pour Hugging Face Spaces
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False  # Pas besoin de share sur HF Spaces
    )