# Guide d'Intégration de la GUI Améliorée

## 🎯 Objectif

Ce guide explique comment intégrer la nouvelle GUI améliorée dans votre application GeniusIA v2.

## ✅ Composants Disponibles

### Composants Principaux
- **ImprovedGUI** : Interface principale avec LogsPanel et statistiques
- **HumanLogger** : Générateur de messages lisibles
- **GUISignals** : Système de signaux Qt pour communication
- **InteractiveDialog** : Dialogues avec timeout
- **OrchestratorGUIBridge** : Pont Orchestrator ↔ GUI

### Modèles de Données
- **GUIState** : État de la GUI
- **LogMessage** : Messages de log

## 🚀 Méthode 1 : Intégration Automatique (Recommandée)

### Utilisation Simple

```python
from PyQt5.QtWidgets import QApplication
from geniusia2.core import Orchestrator
from geniusia2.gui import setup_gui_for_orchestrator

# Créer l'application Qt
app = QApplication(sys.argv)

# Créer l'Orchestrator
orchestrator = Orchestrator()

# Configurer la GUI automatiquement
bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()

# Maintenant l'orchestrator peut logger vers la GUI
orchestrator.log_to_gui("👀", "Système démarré", "success")
orchestrator.update_gui_stats(actions_count=0, patterns_count=0)

# Lancer l'application
sys.exit(app.exec_())
```

### Avantages
- ✅ Configuration automatique
- ✅ Connexion bidirectionnelle Orchestrator ↔ GUI
- ✅ Méthodes helper ajoutées à l'Orchestrator
- ✅ Gestion des signaux automatique

## 🔧 Méthode 2 : Intégration Manuelle

### Étape 1 : Créer la GUI

```python
from PyQt5.QtWidgets import QApplication
from geniusia2.gui import ImprovedGUI

app = QApplication(sys.argv)
gui = ImprovedGUI(orchestrator)
gui.show()
```

### Étape 2 : Connecter les Signaux

```python
from geniusia2.gui import add_gui_logging_to_orchestrator

# Ajouter le logging GUI à l'orchestrator
add_gui_logging_to_orchestrator(orchestrator, gui.signals)

# Connecter les boutons de contrôle
gui.start_requested.connect(orchestrator.start)
gui.stop_requested.connect(orchestrator.stop)
gui.pause_requested.connect(orchestrator.pause)
```

### Étape 3 : Utiliser dans l'Orchestrator

```python
class Orchestrator:
    def on_action_observed(self, action):
        # Logger vers la GUI
        self.log_to_gui("👀", f"Action dans {action.window}", "info")
        
        # Mettre à jour les stats
        self.update_gui_stats(
            actions_count=self.actions_count,
            patterns_count=self.patterns_count,
            workflows_count=self.workflows_count
        )
    
    def on_pattern_detected(self, pattern):
        self.log_to_gui("🎯", "Pattern détecté !", "success")
    
    def on_mode_change(self, new_mode):
        self.change_mode_gui(new_mode)
        self.log_to_gui("✅", f"Mode {new_mode} activé", "success")
```

## 📝 Méthodes Disponibles dans l'Orchestrator

Après l'intégration, ces méthodes sont disponibles :

### log_to_gui(emoji, message, level)
```python
# Envoyer un log à la GUI
orchestrator.log_to_gui("👀", "Message", "info")
orchestrator.log_to_gui("✅", "Succès", "success")
orchestrator.log_to_gui("⚠️", "Attention", "warning")
orchestrator.log_to_gui("❌", "Erreur", "error")
```

### update_gui_stats(**stats)
```python
# Mettre à jour les statistiques
orchestrator.update_gui_stats(
    actions_count=12,
    patterns_count=2,
    workflows_count=1,
    finetuning_status='collecting',
    finetuning_progress=8
)
```

### change_mode_gui(mode)
```python
# Changer le mode affiché
orchestrator.change_mode_gui("shadow")   # 👀 Observation
orchestrator.change_mode_gui("assist")   # 💡 Suggestions
orchestrator.change_mode_gui("copilot")  # 🤝 Copilote
orchestrator.change_mode_gui("auto")     # 🤖 Autonome
```

## 💬 Utiliser les Dialogues Interactifs

### Dialogue Simple

```python
from geniusia2.gui import InteractiveDialog

def on_accept():
    print("Utilisateur a accepté")
    orchestrator.change_mode("assist")

def on_reject():
    print("Utilisateur a refusé")

# Afficher un dialogue
dialog = InteractiveDialog.show_dialog(
    "J'ai une idée !",
    "Voulez-vous que je vous suggère des actions ?",
    on_accept,
    on_reject,
    timeout_seconds=10
)
```

### Dialogue via Signaux

```python
# Utiliser le signal show_dialog
orchestrator.gui_signals.emit_dialog(
    "Confirmation",
    "Voulez-vous continuer ?",
    on_accept,
    on_reject
)
```

## 📊 Exemples d'Utilisation

### Exemple 1 : Observer une Action

```python
def on_action_observed(self, action):
    # Incrémenter le compteur
    self.actions_count += 1
    
    # Logger
    message = self.human_logger.log_observation(
        action.type,
        action.window
    )
    self.log_to_gui("👀", message, "info")
    
    # Mettre à jour les stats
    self.update_gui_stats(actions_count=self.actions_count)
```

### Exemple 2 : Détecter un Pattern

```python
def on_pattern_detected(self, pattern):
    # Incrémenter le compteur
    self.patterns_count += 1
    
    # Logger
    message = self.human_logger.log_pattern_detected(
        pattern.repetitions,
        pattern.task_name
    )
    self.log_to_gui("🎯", message, "success")
    
    # Mettre à jour les stats
    self.update_gui_stats(
        actions_count=self.actions_count,
        patterns_count=self.patterns_count
    )
    
    # Demander confirmation pour changer de mode
    def switch_to_assist():
        self.change_mode("assist")
        self.change_mode_gui("assist")
        self.log_to_gui("✅", "Mode Suggestions activé", "success")
    
    InteractiveDialog.show_dialog(
        "Pattern détecté !",
        f"J'ai remarqué que vous faites souvent:\n\"{pattern.task_name}\"\n\n"
        "Voulez-vous que je vous suggère cette action ?",
        switch_to_assist,
        lambda: None,
        timeout_seconds=10
    )
```

### Exemple 3 : Fine-tuning

```python
def on_finetuning_start(self, num_examples):
    message = self.human_logger.log_finetuning_started(num_examples)
    self.log_to_gui("🧠", message, "info")
    
    self.update_gui_stats(
        finetuning_status='training',
        finetuning_progress=None
    )

def on_finetuning_complete(self, duration):
    message = self.human_logger.log_finetuning_completed(duration)
    self.log_to_gui("✅", message, "success")
    
    self.update_gui_stats(
        finetuning_status='completed',
        finetuning_progress=None
    )
```

### Exemple 4 : Gestion d'Erreurs

```python
def on_error(self, error_type, context=None):
    message = self.human_logger.log_error(error_type, context)
    self.log_to_gui("❌", message, "error")
```

## 🔄 Modifier main.py

### Avant (MinimalGUI)

```python
from geniusia2.gui import MinimalGUI

gui = MinimalGUI(orchestrator)
gui.show()
```

### Après (ImprovedGUI)

```python
from geniusia2.gui import setup_gui_for_orchestrator

bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()
```

## 🧪 Tester l'Intégration

### Test Simple

```python
# test_integration_gui.py
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QTimer
import sys

from geniusia2.core import Orchestrator
from geniusia2.gui import setup_gui_for_orchestrator

app = QApplication(sys.argv)

# Créer et configurer
orchestrator = Orchestrator()
bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()

# Tester après 1 seconde
def test():
    orchestrator.log_to_gui("👀", "Test de log", "info")
    orchestrator.update_gui_stats(actions_count=5)
    orchestrator.change_mode_gui("assist")

QTimer.singleShot(1000, test)

sys.exit(app.exec_())
```

## 📋 Checklist d'Intégration

- [ ] Importer `setup_gui_for_orchestrator`
- [ ] Créer l'application Qt
- [ ] Configurer le bridge
- [ ] Afficher la GUI
- [ ] Tester `log_to_gui()`
- [ ] Tester `update_gui_stats()`
- [ ] Tester `change_mode_gui()`
- [ ] Tester les boutons de contrôle
- [ ] Tester le system tray
- [ ] Tester les dialogues interactifs

## 🐛 Dépannage

### La GUI ne s'affiche pas
```python
# Vérifier que l'application Qt est créée
app = QApplication(sys.argv)
# ... créer la GUI ...
sys.exit(app.exec_())  # Important !
```

### Les logs n'apparaissent pas
```python
# Vérifier que le bridge est configuré
bridge = setup_gui_for_orchestrator(orchestrator)

# Vérifier que la méthode existe
if hasattr(orchestrator, 'log_to_gui'):
    orchestrator.log_to_gui("✅", "Test", "info")
```

### Les statistiques ne se mettent pas à jour
```python
# Utiliser un dictionnaire complet
orchestrator.update_gui_stats(
    actions_count=0,
    patterns_count=0,
    workflows_count=0
)
```

## 📚 Ressources

- **test_improved_gui.py** : Exemple complet avec simulation
- **GUI_AMELIOREE_PRETE.md** : Guide détaillé de la GUI
- **RESUME_GUI_COMPLETE.md** : Résumé des fonctionnalités

## ✨ Conseils

1. **Utilisez HumanLogger** pour générer des messages lisibles
2. **Mettez à jour les stats régulièrement** pour une GUI réactive
3. **Utilisez les dialogues** pour les confirmations importantes
4. **Testez le system tray** sur Ubuntu
5. **Gérez les erreurs** avec des messages clairs

---

**Bonne intégration ! 🚀**