# Design - Amélioration GUI et Logs

## Overview

Ce document décrit l'architecture et le design de la nouvelle interface utilisateur minimaliste et du système de logs amélioré pour GeniusIA v2.

## Architecture

```
┌─────────────────────────────────────────────────────────┐
│                    Main Application                      │
└────────────────┬────────────────────────────────────────┘
                 │
        ┌────────┴────────┐
        ▼                 ▼
┌──────────────┐  ┌──────────────────┐
│ Orchestrator │  │  Improved GUI    │
│              │  │                  │
│ - Détecte    │──│ - System Tray   │
│ - Apprend    │  │ - Logs Panel    │
│ - Suggère    │  │ - Popups        │
└──────┬───────┘  └──────────────────┘
       │
       ▼
┌──────────────┐
│ HumanLogger  │
│              │
│ - Messages   │
│ - Formatting │
└──────────────┘
```

## Components and Interfaces

### 1. HumanLogger

Classe pour générer des messages lisibles par l'utilisateur.

```python
class HumanLogger:
    """
    Logger qui génère des messages simples pour l'utilisateur.
    """
    
    def log_observation(self, action_type: str, window: str):
        """Log une action observée."""
        return f"👀 Action dans {window}"
    
    def log_pattern_detected(self, repetitions: int, task_name: str):
        """Log un pattern détecté."""
        return f"🎯 Pattern détecté: {task_name} (répété {repetitions}x)"
    
    def log_workflow_learned(self, task_name: str, count: int):
        """Log un workflow appris."""
        return f"📚 Workflow appris: {task_name} ({count} observations)"
    
    def log_mode_change(self, old_mode: str, new_mode: str):
        """Log un changement de mode."""
        return f"✅ Mode {new_mode} activé"
    
    def log_finetuning_started(self, num_examples: int):
        """Log le début du fine-tuning."""
        return f"🧠 Amélioration du modèle ({num_examples} exemples)..."
    
    def log_finetuning_completed(self, duration: float):
        """Log la fin du fine-tuning."""
        return f"✅ Modèle amélioré (en {duration:.1f}s)"
```

### 2. ImprovedGUI

Interface minimaliste avec system tray.

#### Layout Principal

```
┌─────────────────────────────────────┐
│  GeniusIA v2                  [_][X]│
├─────────────────────────────────────┤
│                                     │
│  Mode: 👀 Observation               │
│  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  │
│                                     │
│  📊 Activité:                       │
│  • 12 actions observées             │
│  • 2 patterns détectés              │
│                                     │
│  🧠 Fine-tuning:                    │
│  • 8/10 exemples collectés          │
│                                     │
├─────────────────────────────────────┤
│  📝 Journal:                        │
│  ┌─────────────────────────────────┐│
│  │14:23 👀 J'observe...            ││
│  │14:24 🎯 Pattern: Calculer 9/9   ││
│  │14:24 📚 J'apprends...           ││
│  │14:25 💡 Prêt à suggérer         ││
│  │14:26 ✅ Mode Suggestions activé ││
│  └─────────────────────────────────┘│
│                                     │
│  [Pause] [Arrêter]                 │
└─────────────────────────────────────┘
```

#### System Tray

```
Icône dans la barre: 🤖

Menu clic droit:
┌─────────────────────┐
│ 🤖 GeniusIA v2      │
├─────────────────────┤
│ 👀 Mode: Shadow     │
│ 📊 12 actions       │
├─────────────────────┤
│ Afficher            │
│ Masquer             │
│ ─────────────────   │
│ Quitter             │
└─────────────────────┘
```

#### Popup Interactif

```
┌─────────────────────────────────────────┐
│  💡 J'ai une idée !                     │
│                                         │
│  J'ai remarqué que vous faites souvent: │
│  "Calculer 9/9 dans la calculatrice"   │
│                                         │
│  Est-ce que je peux essayer de vous    │
│  suggérer cette action la prochaine    │
│  fois ?                                 │
│                                         │
│  [Oui, essaie !]  [Non, continue]     │
│                                         │
│  ⏱️ Fermeture auto dans 10s            │
└─────────────────────────────────────────┘
```

### 3. LogsPanel

Widget pour afficher les logs avec scroll.

```python
class LogsPanel(QWidget):
    """
    Panneau d'affichage des logs avec scroll.
    
    - Affiche 5 dernières actions
    - Scrollable jusqu'à 30
    - Auto-scroll si en bas
    - Format: HH:MM emoji Message
    """
    
    def add_log(self, message: str, emoji: str = "ℹ️"):
        """Ajoute un log avec timestamp."""
        pass
    
    def clear(self):
        """Efface tous les logs."""
        pass
    
    def get_logs(self) -> List[str]:
        """Retourne l'historique."""
        pass
```

### 4. InteractiveDialog

Popup pour dialogues avec timeout.

```python
class InteractiveDialog(QDialog):
    """
    Dialogue interactif avec timeout automatique.
    
    - Non-bloquant (l'app continue)
    - Timeout 10 secondes
    - Callbacks pour réponses
    """
    
    def __init__(
        self,
        title: str,
        message: str,
        on_accept: Callable,
        on_reject: Callable,
        timeout: int = 10
    ):
        pass
```

## Data Models

### LogMessage

```python
@dataclass
class LogMessage:
    """Message de log pour affichage."""
    timestamp: datetime
    emoji: str
    message: str
    level: str  # 'info', 'success', 'warning', 'error'
    technical_details: Optional[str] = None  # Pour logs techniques
```

### GUIState

```python
@dataclass
class GUIState:
    """État de la GUI."""
    mode: str  # 'shadow', 'assist', 'auto'
    is_running: bool
    actions_count: int
    patterns_count: int
    workflows_count: int
    finetuning_status: Optional[str]  # None, 'collecting', 'training', 'completed'
    finetuning_progress: Optional[int]  # 0-100 ou None
```

## Error Handling

### Erreurs GUI

- **Erreur d'affichage** : Logger et continuer sans GUI
- **Erreur system tray** : Fallback vers fenêtre normale
- **Erreur popup** : Logger et utiliser notification simple

### Erreurs Logs

- **Fichier de log inaccessible** : Créer nouveau fichier avec timestamp
- **Disque plein** : Nettoyer anciens logs automatiquement
- **Permission refusée** : Logger dans /tmp en fallback

## Testing Strategy

### Unit Tests

- Test HumanLogger : Vérifier format des messages
- Test LogsPanel : Vérifier scroll et limite 30
- Test InteractiveDialog : Vérifier timeout
- Test GUIState : Vérifier mise à jour

### Integration Tests

- Test Orchestrator → GUI : Vérifier envoi de messages
- Test Popup → Orchestrator : Vérifier callbacks
- Test System Tray : Vérifier menu et actions

### Manual Tests

- Test sur Ubuntu : Vérifier system tray et thème
- Test avec actions répétitives : Vérifier détection
- Test timeout : Vérifier fermeture auto après 10s

## Correctness Properties

*A property is a characteristic or behavior that should hold true across all valid executions of a system.*

### Property 1: Log History Bounds

*For any* sequence of log messages, the visible history should never exceed 30 messages.

**Validates: Requirements 3.3**

### Property 2: Timeout Consistency

*For any* interactive dialog, if no user response is received within 10 seconds, the dialog should close automatically.

**Validates: Requirements 4.3**

### Property 3: Mode Display Consistency

*For any* mode change, the GUI should display the correct mode icon and label within 100ms.

**Validates: Requirements 5.1**

### Property 4: Message Ordering

*For any* sequence of events, the logs should appear in chronological order.

**Validates: Requirements 2.1, 2.2, 2.3, 2.4**

### Property 5: Non-blocking Dialogs

*For any* interactive dialog displayed, the Orchestrator should continue processing events.

**Validates: Requirements 4.2**

## Implementation Notes

### PyQt5 Signals

Utiliser des signaux Qt pour communication thread-safe :

```python
class GUISignals(QObject):
    """Signaux pour communication Orchestrator → GUI."""
    log_message = pyqtSignal(str, str)  # (emoji, message)
    update_stats = pyqtSignal(dict)  # GUIState
    show_dialog = pyqtSignal(str, str, object, object)  # (title, msg, on_accept, on_reject)
    mode_changed = pyqtSignal(str)  # nouveau mode
```

### System Tray Ubuntu

Utiliser `QSystemTrayIcon` avec fallback si non supporté :

```python
if QSystemTrayIcon.isSystemTrayAvailable():
    self.tray_icon = QSystemTrayIcon(QIcon.fromTheme("robot"))
    self.tray_icon.setToolTip("GeniusIA v2")
else:
    # Fallback: fenêtre normale
    self.setWindowFlags(Qt.Window)
```

### Logs Techniques

Format structuré pour parsing facile :

```
2024-11-20 14:23:45.123 [INFO] EventCapture: Mouse click at (450, 320) in "Calculator"
2024-11-20 14:23:46.456 [DEBUG] SessionManager: Action added to session_001
2024-11-20 14:24:12.789 [INFO] WorkflowDetector: Pattern detected (3 repetitions)
```

### Performance

- Logs GUI : Max 30 messages en mémoire
- Logs fichier : Rotation à 10MB
- Mise à jour GUI : Max 10 fois/seconde
- Popups : Timeout 10s pour éviter accumulation

## UI/UX Considerations

### Discrétion

- Fenêtre petite (300x400px)
- Minimisable
- System tray toujours visible
- Pas de sons

### Clarté

- Messages courts (max 50 caractères)
- Emojis pour reconnaissance rapide
- Couleurs pour niveaux (info/success/warning/error)
- Timestamps relatifs ("il y a 2 min")

### Réactivité

- Mise à jour en temps réel
- Pas de freeze
- Feedback immédiat sur actions

## Migration Plan

### Phase 1: Créer nouveaux composants

1. HumanLogger
2. ImprovedGUI
3. LogsPanel
4. InteractiveDialog

### Phase 2: Modifier Orchestrator

1. Ajouter envoi de messages humains
2. Connecter aux signaux GUI
3. Déclencher dialogues interactifs

### Phase 3: Remplacer ancienne GUI

1. Renommer `minimal_gui.py` → `minimal_gui_old.py`
2. Renommer `improved_gui.py` → `minimal_gui.py`
3. Tester

### Phase 4: Cleanup

1. Supprimer anciens boutons (liste blanche, etc.)
2. Supprimer code inutilisé
3. Documentation

## Security Considerations

- Logs techniques : Ne pas logger de données sensibles
- Popups : Timeout pour éviter DOS
- System tray : Vérifier permissions Ubuntu

## Accessibility

- Contraste suffisant pour lisibilité
- Taille de police ajustable
- Support clavier complet
- Screen reader compatible (ARIA labels)
