interface.py

"""
Module d'interface utilisateur avec Gradio
"""
import os
# Désactiver les analytics Gradio dès le début
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"

import gradio as gr
from data_loader import DataLoader
from analyzer import AgricultureAnalyzer
from visualizations import AgricultureVisualizer
from config import GRADIO_CONFIG


class AgricultureInterface:
    """Classe responsable de l'interface utilisateur Gradio"""
    
    def __init__(self):
        self.data_loader = DataLoader()
        self.analyzer = AgricultureAnalyzer()
        self.visualizer = AgricultureVisualizer()
        self._initialize_data()
    
    def _initialize_data(self):
        """Initialise les données au démarrage avec gestion d'erreur"""
        try:
            print("🔄 Initialisation des données...")
            self.data_loader.load_data()
            if self.data_loader.has_data():
                self.analyzer.set_data(self.data_loader.get_data())
                self.analyzer.analyze_data()
                self.visualizer.set_data(
                    self.data_loader.get_data(), 
                    self.analyzer.get_risk_analysis()
                )
                print("✅ Initialisation réussie")
            else:
                print("⚠️ Aucune donnée disponible au démarrage")
        except Exception as e:
            print(f"❌ Erreur lors de l'initialisation: {e}")
            # L'application peut continuer même si l'initialisation échoue
    
    def refresh_data(self):
        """Rafraîchit toutes les données avec gestion d'erreur robuste"""
        try:
            print("🔄 Rafraîchissement des données...")
            
            # Chargement des données
            try:
                self.data_loader.load_data()
            except Exception as e:
                print(f"❌ Erreur lors du chargement: {e}")
                return self._get_error_outputs("Erreur lors du chargement des données")
            
            if self.data_loader.has_data():
                try:
                    # Analyse des données
                    self.analyzer.set_data(self.data_loader.get_data())
                    self.analyzer.analyze_data()
                    self.visualizer.set_data(
                        self.data_loader.get_data(), 
                        self.analyzer.get_risk_analysis()
                    )
                    
                    # Génération des outputs avec gestion d'erreur individuelle
                    return (
                        self._safe_get_summary_stats(),
                        self._safe_create_culture_analysis(),
                        self._safe_create_risk_distribution(),
                        self._safe_create_risk_visualization(),
                        self._safe_get_recommendations()
                    )
                    
                except Exception as e:
                    print(f"❌ Erreur lors de l'analyse: {e}")
                    return self._get_error_outputs(f"Erreur lors de l'analyse: {str(e)[:100]}...")
            else:
                print("⚠️ Aucune donnée disponible après chargement")
                return self._get_error_outputs("Aucune donnée disponible")
                
        except Exception as e:
            print(f"❌ Erreur critique dans refresh_data: {e}")
            return self._get_error_outputs("Erreur critique lors du rafraîchissement")
    
    def _get_error_outputs(self, error_message):
        """Retourne des outputs d'erreur standardisés"""
        try:
            empty_fig = self.visualizer._create_error_plot("❌ Erreur", error_message)
            return (
                f"❌ {error_message}",
                empty_fig,
                empty_fig,
                empty_fig,
                f"❌ {error_message}"
            )
        except:
            # Fallback ultime si même la création d'erreur échoue
            return (
                "❌ Erreur critique",
                None,
                None,
                None,
                "❌ Erreur critique"
            )
    
    def _safe_get_summary_stats(self):
        """Récupère les statistiques avec gestion d'erreur"""
        try:
            return self.analyzer.get_summary_stats()
        except Exception as e:
            print(f"❌ Erreur dans get_summary_stats: {e}")
            return "❌ Erreur lors de la génération des statistiques"
    
    def _safe_create_culture_analysis(self):
        """Crée l'analyse des cultures avec gestion d'erreur"""
        try:
            return self.visualizer.create_culture_analysis()
        except Exception as e:
            print(f"❌ Erreur dans create_culture_analysis: {e}")
            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer l'analyse des cultures")
    
    def _safe_create_risk_distribution(self):
        """Crée la distribution des risques avec gestion d'erreur"""
        try:
            return self.visualizer.create_risk_distribution()
        except Exception as e:
            print(f"❌ Erreur dans create_risk_distribution: {e}")
            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer la distribution des risques")
    
    def _safe_create_risk_visualization(self):
        """Crée la visualisation des risques avec gestion d'erreur"""
        try:
            return self.visualizer.create_risk_visualization()
        except Exception as e:
            print(f"❌ Erreur dans create_risk_visualization: {e}")
            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer la visualisation des risques")
    
    def _safe_get_recommendations(self):
        """Récupère les recommandations avec gestion d'erreur"""
        try:
            return self.analyzer.get_low_risk_recommendations()
        except Exception as e:
            print(f"❌ Erreur dans get_low_risk_recommendations: {e}")
            return "❌ Erreur lors de la génération des recommandations"
    
    def create_interface(self):
        """Crée l'interface Gradio"""
        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"):
                    self._create_overview_tab()
                
                with gr.TabItem("🎯 Analyse des Risques"):
                    self._create_risk_analysis_tab()
                
                with gr.TabItem("🌾 Recommandations"):
                    self._create_recommendations_tab()
                
                with gr.TabItem("ℹ️ À propos"):
                    self._create_about_tab()
            
            # Bouton de rafraîchissement
            refresh_btn = gr.Button("🔄 Actualiser les données", variant="secondary")
            
            # Connecter le bouton de rafraîchissement
            refresh_btn.click(
                self.refresh_data,
                outputs=[
                    self.stats_output, 
                    self.culture_plot, 
                    self.risk_dist_plot, 
                    self.risk_plot, 
                    self.reco_output
                ]
            )
        
        return demo
    
    def _create_overview_tab(self):
        """Crée l'onglet de vue d'ensemble avec gestion d'erreur"""
        try:
            gr.Markdown("## Statistiques générales des données agricoles")
            
            self.stats_output = gr.Markdown(self._safe_get_summary_stats())
            
            with gr.Row():
                self.culture_plot = gr.Plot(self._safe_create_culture_analysis())
                self.risk_dist_plot = gr.Plot(self._safe_create_risk_distribution())
        except Exception as e:
            print(f"❌ Erreur lors de la création de l'onglet vue d'ensemble: {e}")
            gr.Markdown("❌ Erreur lors de la création de l'interface")
    
    def _create_risk_analysis_tab(self):
        """Crée l'onglet d'analyse des risques avec gestion d'erreur"""
        try:
            gr.Markdown("## Cartographie des risques adventices par parcelle")
            
            self.risk_plot = gr.Plot(self._safe_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.
            """)
        except Exception as e:
            print(f"❌ Erreur lors de la création de l'onglet analyse des risques: {e}")
            gr.Markdown("❌ Erreur lors de la création de l'interface d'analyse des risques")
    
    def _create_recommendations_tab(self):
        """Crée l'onglet des recommandations avec gestion d'erreur"""
        try:
            self.reco_output = gr.Markdown(self._safe_get_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
        """)
        except Exception as e:
            print(f"❌ Erreur lors de la création de l'onglet recommandations: {e}")
            gr.Markdown("❌ Erreur lors de la création de l'interface de recommandations")
    
    def _create_about_tab(self):
        """Crée l'onglet à 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*
        """)
    
    def launch(self):
        """Lance l'interface"""
        demo = self.create_interface()
        demo.launch(**GRADIO_CONFIG)