Geniusia_v2/test_improved_gui.py

"""
Test de l'ImprovedGUI - Interface améliorée avec LogsPanel
"""

import sys
sys.path.insert(0, 'geniusia2')

from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QTimer
from gui import ImprovedGUI

def main():
    """Test de l'ImprovedGUI avec simulation d'événements"""
    app = QApplication(sys.argv)
    
    print("=" * 60)
    print("Test de l'ImprovedGUI")
    print("=" * 60)
    
    # Créer la GUI
    gui = ImprovedGUI()
    gui.show()
    
    print("\n✓ GUI créée et affichée")
    print(f"  Taille: {gui.width()}x{gui.height()}px")
    print(f"  Mode initial: {gui.state.mode}")
    print(f"  Statut: {'En cours' if gui.state.is_running else 'Arrêté'}")
    
    # Fonction pour simuler des événements
    def simulate_workflow():
        print("\n📝 Simulation d'un workflow complet...")
        
        # 1. Démarrage du système
        print("  1. Démarrage du système")
        gui.signals.emit_status_change(True)
        gui.signals.emit_log("👀", "Système démarré en mode Observation", "info")
        
        # 2. Observation d'actions
        QTimer.singleShot(1000, lambda: [
            print("  2. Observation d'actions"),
            gui.signals.emit_log("👀", "J'observe vos actions dans Calculator", "info"),
            gui.signals.emit_stats_update({
                'actions_count': 3,
                'patterns_count': 0,
                'workflows_count': 0
            })
        ])
        
        # 3. Détection de pattern
        QTimer.singleShot(2000, lambda: [
            print("  3. Détection de pattern"),
            gui.signals.emit_log("🎯", "Tiens ! Vous avez fait 3 fois la même chose", "success"),
            gui.signals.emit_stats_update({
                'actions_count': 9,
                'patterns_count': 1,
                'workflows_count': 0
            })
        ])
        
        # 4. Apprentissage de workflow
        QTimer.singleShot(3000, lambda: [
            print("  4. Apprentissage de workflow"),
            gui.signals.emit_log("📚", "J'apprends: Calculer 9/9 (5 observations)", "info"),
            gui.signals.emit_stats_update({
                'actions_count': 12,
                'patterns_count': 2,
                'workflows_count': 1
            })
        ])
        
        # 5. Changement de mode
        QTimer.singleShot(4000, lambda: [
            print("  5. Changement de mode vers Suggestions"),
            gui.signals.emit_mode_change("assist"),
            gui.signals.emit_log("✅", "Mode Suggestions activé", "success")
        ])
        
        # 6. Collecte d'exemples pour fine-tuning
        QTimer.singleShot(5000, lambda: [
            print("  6. Collecte d'exemples pour fine-tuning"),
            gui.signals.emit_log("🧠", "Collecte d'exemples: 8/10", "info"),
            gui.signals.emit_stats_update({
                'actions_count': 15,
                'patterns_count': 2,
                'workflows_count': 1,
                'finetuning_status': 'collecting',
                'finetuning_progress': 8
            })
        ])
        
        # 7. Fine-tuning en cours
        QTimer.singleShot(6000, lambda: [
            print("  7. Fine-tuning en cours"),
            gui.signals.emit_log("🧠", "Amélioration du modèle (10 exemples)...", "info"),
            gui.signals.emit_stats_update({
                'actions_count': 17,
                'patterns_count': 2,
                'workflows_count': 1,
                'finetuning_status': 'training',
                'finetuning_progress': None
            })
        ])
        
        # 8. Fine-tuning terminé
        QTimer.singleShot(7000, lambda: [
            print("  8. Fine-tuning terminé"),
            gui.signals.emit_log("✅", "Modèle amélioré (en 2.3s)", "success"),
            gui.signals.emit_stats_update({
                'actions_count': 17,
                'patterns_count': 2,
                'workflows_count': 1,
                'finetuning_status': 'completed',
                'finetuning_progress': None
            })
        ])
        
        # 9. Suggestion prête
        QTimer.singleShot(8000, lambda: [
            print("  9. Suggestion prête"),
            gui.signals.emit_log("💡", "Prêt à suggérer: Calculer 9/9", "info")
        ])
        
        # 10. Test d'erreur
        QTimer.singleShot(9000, lambda: [
            print("  10. Test d'erreur"),
            gui.signals.emit_log("⚠️", "Application non autorisée - Terminal", "warning")
        ])
        
        # 11. Test d'erreur critique
        QTimer.singleShot(10000, lambda: [
            print("  11. Test d'erreur critique"),
            gui.signals.emit_log("❌", "Impossible de se connecter - Calculator", "error")
        ])
        
        # 12. Changement vers mode Copilote
        QTimer.singleShot(11000, lambda: [
            print("  12. Changement vers mode Copilote"),
            gui.signals.emit_mode_change("copilot"),
            gui.signals.emit_log("✅", "Mode Copilote activé", "success")
        ])
        
        # 13. Changement vers mode Autonome
        QTimer.singleShot(12000, lambda: [
            print("  13. Changement vers mode Autonome"),
            gui.signals.emit_mode_change("auto"),
            gui.signals.emit_log("✅", "Mode Autonome activé", "success")
        ])
        
        # 14. Test de la limite de 30 logs
        QTimer.singleShot(13000, lambda: [
            print("  14. Test de la limite de 30 logs (ajout de 25 logs)"),
            *[gui.signals.emit_log("📝", f"Message de test #{i+1}", "info") for i in range(25)]
        ])
        
        # 15. Vérification finale
        QTimer.singleShot(14000, lambda: [
            print("\n✅ Simulation terminée!"),
            print(f"\nStatistiques finales:"),
            print(f"  Actions: {gui.state.actions_count}"),
            print(f"  Patterns: {gui.state.patterns_count}"),
            print(f"  Workflows: {gui.state.workflows_count}"),
            print(f"  Logs affichés: {gui.logs_panel.get_log_count()}"),
            print(f"\n💡 Testez maintenant:"),
            print(f"  - Scroll dans les logs"),
            print(f"  - Boutons Pause/Arrêter"),
            print(f"  - Icône system tray (clic droit)"),
            print(f"  - Minimisation vers le tray"),
            print(f"\nFermez la fenêtre pour quitter.")
        ])
    
    # Démarrer la simulation après 500ms
    QTimer.singleShot(500, simulate_workflow)
    
    sys.exit(app.exec_())

if __name__ == "__main__":
    main()