"""
HumanLogger - Générateur de messages lisibles pour l'interface utilisateur
Transforme les événements techniques en messages simples et contextuels.
"""

from datetime import datetime
from typing import Optional, Dict, Any


class HumanLogger:
    """
    Logger qui génère des messages simples et lisibles pour l'utilisateur.
    
    Transforme les événements techniques du système en messages compréhensibles
    avec emojis et contexte approprié.
    
    Attributes:
        first_time_events: Dictionnaire pour tracker les événements "première fois"
    """
    
    def __init__(self):
        """Initialise le HumanLogger avec tracking des premières fois."""
        self.first_time_events: Dict[str, bool] = {
            "workflow_detected": False,
            "mode_change": False,
            "pattern_detected": False,
            "finetuning_started": False
        }
    
    def log_observation(self, action_type: str, window: str) -> str:
        """
        Génère un message pour une action observée.
        
        Args:
            action_type: Type d'action (click, type, scroll, etc.)
            window: Nom de la fenêtre où l'action a eu lieu
            
        Returns:
            Message formaté pour l'utilisateur
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_observation("click", "Calculator")
            "👀 J'observe vos actions dans Calculator"
        """
        # Message simple et discret
        return f"👀 J'observe vos actions dans {window}"
    
    def log_pattern_detected(self, repetitions: int, task_name: str) -> str:
        """
        Génère un message pour un pattern détecté.
        
        Args:
            repetitions: Nombre de répétitions détectées
            task_name: Nom de la tâche répétée
            
        Returns:
            Message formaté avec contexte si première fois
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_pattern_detected(3, "Calculer 9/9")
            "🎯 Tiens ! Vous avez fait 3 fois la même chose"
        """
        # Message d'excitation pour pattern détecté
        message = f"🎯 Tiens ! Vous avez fait {repetitions} fois la même chose"
        
        # Ajouter contexte si première fois
        if not self.first_time_events["pattern_detected"]:
            self.first_time_events["pattern_detected"] = True
            message += " (Je commence à apprendre vos habitudes)"
        
        return message
    
    def log_workflow_learned(self, task_name: str, count: int) -> str:
        """
        Génère un message pour un workflow appris.
        
        Args:
            task_name: Nom du workflow appris
            count: Nombre d'observations utilisées pour l'apprentissage
            
        Returns:
            Message formaté avec explication si première fois
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_workflow_learned("Ouvrir facture", 5)
            "📚 J'apprends: Ouvrir facture (5 observations)"
        """
        message = f"📚 J'apprends: {task_name} ({count} observations)"
        
        # Ajouter explication si première workflow
        if not self.first_time_events["workflow_detected"]:
            self.first_time_events["workflow_detected"] = True
            message += "\n💡 Un workflow est une séquence d'actions que vous répétez"
        
        return message
    
    def log_mode_change(self, old_mode: str, new_mode: str, reason: Optional[str] = None) -> str:
        """
        Génère un message pour un changement de mode.
        
        Args:
            old_mode: Mode précédent (shadow, assist, auto)
            new_mode: Nouveau mode (shadow, assist, auto)
            reason: Raison du changement (optionnel)
            
        Returns:
            Message formaté avec explication du nouveau mode si première fois
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_mode_change("shadow", "assist")
            "✅ Mode Suggestions activé"
        """
        # Mapper les modes techniques vers des noms lisibles
        mode_names = {
            "shadow": "Observation",
            "assist": "Suggestions",
            "copilot": "Copilote",
            "auto": "Autonome"
        }
        
        new_mode_name = mode_names.get(new_mode, new_mode)
        message = f"✅ Mode {new_mode_name} activé"
        
        # Ajouter explication si premier changement de mode
        if not self.first_time_events["mode_change"]:
            self.first_time_events["mode_change"] = True
            
            # Expliquer ce que fait le nouveau mode
            mode_explanations = {
                "assist": "\n💡 Je vais maintenant vous suggérer des actions",
                "copilot": "\n💡 Je peux maintenant exécuter avec votre validation",
                "auto": "\n💡 Je peux maintenant agir de manière autonome"
            }
            
            if new_mode in mode_explanations:
                message += mode_explanations[new_mode]
        
        return message
    
    def log_finetuning_started(self, num_examples: int) -> str:
        """
        Génère un message pour le début du fine-tuning.
        
        Args:
            num_examples: Nombre d'exemples utilisés pour le fine-tuning
            
        Returns:
            Message formaté avec explication si première fois
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_finetuning_started(10)
            "🧠 Amélioration du modèle (10 exemples)..."
        """
        message = f"🧠 Amélioration du modèle ({num_examples} exemples)..."
        
        # Ajouter explication si premier fine-tuning
        if not self.first_time_events["finetuning_started"]:
            self.first_time_events["finetuning_started"] = True
            message += "\n💡 J'améliore ma compréhension de vos actions"
        
        return message
    
    def log_finetuning_completed(self, duration: float) -> str:
        """
        Génère un message pour la fin du fine-tuning.
        
        Args:
            duration: Durée du fine-tuning en secondes
            
        Returns:
            Message formaté de succès
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_finetuning_completed(2.5)
            "✅ Modèle amélioré (en 2.5s)"
        """
        return f"✅ Modèle amélioré (en {duration:.1f}s)"
    
    def log_error(self, error_type: str, context: Optional[str] = None) -> str:
        """
        Génère un message d'erreur compréhensible avec suggestion d'action.
        
        Args:
            error_type: Type d'erreur (connection, permission, not_found, etc.)
            context: Contexte additionnel (optionnel)
            
        Returns:
            Message d'erreur avec suggestion corrective
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_error("connection", "Calculator")
            "⚠️ Impossible de se connecter à Calculator"
        """
        # Messages d'erreur avec suggestions
        error_messages = {
            "connection": "⚠️ Impossible de se connecter",
            "permission": "⚠️ Permission refusée",
            "not_found": "⚠️ Élément introuvable",
            "timeout": "⚠️ Délai d'attente dépassé",
            "whitelist": "⚠️ Application non autorisée",
            "unknown": "⚠️ Une erreur est survenue"
        }
        
        message = error_messages.get(error_type, error_messages["unknown"])
        
        # Ajouter contexte si fourni
        if context:
            message += f" - {context}"
        
        # Ajouter suggestion corrective selon le type d'erreur
        suggestions = {
            "connection": "\n💡 Vérifiez que l'application est ouverte",
            "permission": "\n💡 Vérifiez les permissions de l'application",
            "not_found": "\n💡 L'interface a peut-être changé",
            "timeout": "\n💡 L'application est peut-être trop lente",
            "whitelist": "\n💡 Ajoutez l'application à la liste autorisée"
        }
        
        if error_type in suggestions:
            message += suggestions[error_type]
        
        return message
    
    def log_idle(self) -> str:
        """
        Génère un message d'encouragement après inactivité.
        
        Returns:
            Message d'encouragement
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_idle()
            "💤 En attente de vos actions..."
        """
        return "💤 En attente de vos actions..."
    
    def log_stats_update(self, actions_count: int, patterns_count: int, workflows_count: int) -> str:
        """
        Génère un message de mise à jour des statistiques.
        
        Args:
            actions_count: Nombre d'actions observées
            patterns_count: Nombre de patterns détectés
            workflows_count: Nombre de workflows appris
            
        Returns:
            Message formaté avec statistiques
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_stats_update(12, 2, 1)
            "📊 12 actions • 2 patterns • 1 workflow"
        """
        return f"📊 {actions_count} actions • {patterns_count} patterns • {workflows_count} workflow{'s' if workflows_count > 1 else ''}"
    
    def log_suggestion_ready(self, task_name: str) -> str:
        """
        Génère un message indiquant qu'une suggestion est prête.
        
        Args:
            task_name: Nom de la tâche pour laquelle une suggestion est disponible
            
        Returns:
            Message formaté
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_suggestion_ready("Ouvrir facture")
            "💡 Prêt à suggérer: Ouvrir facture"
        """
        return f"💡 Prêt à suggérer: {task_name}"
    
    def log_collecting_examples(self, current: int, target: int) -> str:
        """
        Génère un message pour la collecte d'exemples de fine-tuning.
        
        Args:
            current: Nombre d'exemples collectés
            target: Nombre d'exemples cibles
            
        Returns:
            Message formaté avec progression
            
        Examples:
            >>> logger = HumanLogger()
            >>> logger.log_collecting_examples(8, 10)
            "🧠 Collecte d'exemples: 8/10"
        """
        return f"🧠 Collecte d'exemples: {current}/{target}"


if __name__ == "__main__":
    # Tests du HumanLogger
    print("Test du HumanLogger")
    print("=" * 50)
    
    logger = HumanLogger()
    
    # Test 1: Observation
    print("\n1. Test log_observation:")
    msg = logger.log_observation("click", "Calculator")
    print(f"   {msg}")
    
    # Test 2: Pattern détecté (première fois)
    print("\n2. Test log_pattern_detected (première fois):")
    msg = logger.log_pattern_detected(3, "Calculer 9/9")
    print(f"   {msg}")
    
    # Test 3: Pattern détecté (deuxième fois)
    print("\n3. Test log_pattern_detected (deuxième fois):")
    msg = logger.log_pattern_detected(4, "Ouvrir fichier")
    print(f"   {msg}")
    
    # Test 4: Workflow appris (première fois)
    print("\n4. Test log_workflow_learned (première fois):")
    msg = logger.log_workflow_learned("Ouvrir facture", 5)
    print(f"   {msg}")
    
    # Test 5: Workflow appris (deuxième fois)
    print("\n5. Test log_workflow_learned (deuxième fois):")
    msg = logger.log_workflow_learned("Calculer total", 3)
    print(f"   {msg}")
    
    # Test 6: Changement de mode (première fois)
    print("\n6. Test log_mode_change (première fois):")
    msg = logger.log_mode_change("shadow", "assist")
    print(f"   {msg}")
    
    # Test 7: Changement de mode (deuxième fois)
    print("\n7. Test log_mode_change (deuxième fois):")
    msg = logger.log_mode_change("assist", "auto")
    print(f"   {msg}")
    
    # Test 8: Fine-tuning démarré (première fois)
    print("\n8. Test log_finetuning_started (première fois):")
    msg = logger.log_finetuning_started(10)
    print(f"   {msg}")
    
    # Test 9: Fine-tuning démarré (deuxième fois)
    print("\n9. Test log_finetuning_started (deuxième fois):")
    msg = logger.log_finetuning_started(15)
    print(f"   {msg}")
    
    # Test 10: Fine-tuning terminé
    print("\n10. Test log_finetuning_completed:")
    msg = logger.log_finetuning_completed(2.5)
    print(f"    {msg}")
    
    # Test 11: Erreurs avec suggestions
    print("\n11. Test log_error:")
    for error_type in ["connection", "permission", "not_found", "timeout", "whitelist"]:
        msg = logger.log_error(error_type, "Calculator")
        print(f"    {msg}")
        print()
    
    # Test 12: Idle
    print("\n12. Test log_idle:")
    msg = logger.log_idle()
    print(f"    {msg}")
    
    # Test 13: Stats update
    print("\n13. Test log_stats_update:")
    msg = logger.log_stats_update(12, 2, 1)
    print(f"    {msg}")
    
    # Test 14: Suggestion ready
    print("\n14. Test log_suggestion_ready:")
    msg = logger.log_suggestion_ready("Ouvrir facture")
    print(f"    {msg}")
    
    # Test 15: Collecting examples
    print("\n15. Test log_collecting_examples:")
    msg = logger.log_collecting_examples(8, 10)
    print(f"    {msg}")
    
    print("\n✓ Tous les tests manuels terminés!")
