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"""
        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()
            )
    
    def refresh_data(self):
        """Rafraîchit toutes les 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()
            )
            return (
                self.analyzer.get_summary_stats(),
                self.visualizer.create_culture_analysis(),
                self.visualizer.create_risk_distribution(),
                self.visualizer.create_risk_visualization(),
                self.analyzer.get_low_risk_recommendations()
            )
        else:
            # Retourner des valeurs par défaut si pas de données
            empty_fig = self.visualizer.create_culture_analysis()  # Créera un graphique vide
            return (
                "❌ Aucune donnée disponible",
                empty_fig,
                empty_fig,
                empty_fig,
                "❌ Aucune recommandation disponible"
            )
    
    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"""
        gr.Markdown("## Statistiques générales des données agricoles")
        
        self.stats_output = gr.Markdown(self.analyzer.get_summary_stats())
        
        with gr.Row():
            self.culture_plot = gr.Plot(self.visualizer.create_culture_analysis())
            self.risk_dist_plot = gr.Plot(self.visualizer.create_risk_distribution())
    
    def _create_risk_analysis_tab(self):
        """Crée l'onglet d'analyse des risques"""
        gr.Markdown("## Cartographie des risques adventices par parcelle")
        
        self.risk_plot = gr.Plot(self.visualizer.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.
        """)
    
    def _create_recommendations_tab(self):
        """Crée l'onglet des recommandations"""
        self.reco_output = gr.Markdown(self.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
        """)
    
    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)