Interface/chat_interface.py

import asyncio
import json
import logging
from typing import List, Dict, Any, Optional
from datetime import datetime

class ChatInterface:
    """
    Gère les interactions conversationnelles avec Barouia-Cortex
    """
    
    def __init__(self, cortex):
        self.cortex = cortex
        self.logger = logging.getLogger("chat_interface")
        self.conversation_context = {}
        self.user_profiles = {}
        
    async def process_message(self, message: str, history: List[List[str]]) -> str:
        """
        Traite un message utilisateur et retourne une réponse
        """
        self.logger.info(f"📨 Message reçu: {message}")
        
        try:
            # Construction du contexte
            context = await self._build_context(message, history)
            
            # Traitement par le cortex
            response = await self.cortex.process(message, context)
            
            # Formatage de la réponse
            formatted_response = self._format_response(response, message)
            
            # Mise à jour du contexte
            await self._update_conversation_context(message, formatted_response, response)
            
            self.logger.info("✅ Réponse générée avec succès")
            return formatted_response
            
        except Exception as e:
            self.logger.error(f"❌ Erreur de traitement: {e}")
            return self._create_error_response(e)

    async def _build_context(self, message: str, history: List[List[str]]) -> Dict[str, Any]:
        """Construit le contexte de conversation"""
        context = {
            'timestamp': datetime.now().isoformat(),
            'message_length': len(message),
            'conversation_history': history[-5:],  # Derniers 5 échanges
            'user_intent': await self._analyze_user_intent(message),
            'conversation_tone': await self._detect_conversation_tone(history),
            'topics_discussed': await self._extract_topics(history),
            'system_state': await self.cortex.get_system_status()
        }
        
        # Ajout du profil utilisateur si disponible
        user_profile = self._get_user_profile(history)
        if user_profile:
            context['user_profile'] = user_profile
            
        return context

    async def _analyze_user_intent(self, message: str) -> str:
        """Analyse l'intention de l'utilisateur"""
        message_lower = message.lower()
        
        if any(word in message_lower for word in ['question', 'pourquoi', 'comment', 'quand']):
            return 'information_seeking'
        elif any(word in message_lower for word in ['aide', 'problème', 'souci']):
            return 'help_request'
        elif any(word in message_lower for word in ['créer', 'générer', 'inventer']):
            return 'creative_request'
        elif any(word in message_lower for word in ['analyse', 'évalue', 'pense']):
            return 'analysis_request'
        else:
            return 'general_conversation'

    async def _detect_conversation_tone(self, history: List[List[str]]) -> str:
        """Détecte le ton de la conversation"""
        if not history:
            return 'neutral'
            
        # Analyse simplifiée du ton
        last_messages = ' '.join([msg[0] for msg in history[-3:] if len(msg) > 0])
        last_messages_lower = last_messages.lower()
        
        if any(word in last_messages_lower for word in ['merci', 'super', 'génial']):
            return 'positive'
        elif any(word in last_messages_lower for word in ['probleme', 'erreur', 'fâché']):
            return 'negative'
        else:
            return 'neutral'

    async def _extract_topics(self, history: List[List[str]]) -> List[str]:
        """Extrait les topics principaux de la conversation"""
        topics = []
        for exchange in history[-5:]:
            if exchange and len(exchange) > 0:
                message = exchange[0].lower()
                if 'ia' in message or 'intelligence' in message:
                    topics.append('artificial_intelligence')
                if 'apprentissage' in message or 'apprendre' in message:
                    topics.append('learning')
                if 'futur' in message or 'innovation' in message:
                    topics.append('innovation')
                    
        return list(set(topics))  # Déduplication

    def _format_response(self, cortex_response: Dict, original_message: str) -> str:
        """Formate la réponse du cortex pour l'utilisateur"""
        
        if cortex_response.get('error'):
            return f"❌ Désolé, une erreur s'est produite: {cortex_response['response']}"
        
        main_response = cortex_response['response']
        confidence = cortex_response.get('confidence', 0.5)
        
        # Ajout d'indicateurs de confiance
        if confidence < 0.5:
            confidence_indicator = "🤔 Je ne suis pas entièrement certain, mais "
        elif confidence < 0.8:
            confidence_indicator = "💡 Selon mon analyse, "
        else:
            confidence_indicator = "🎯 Je suis confiant que "
        
        # Construction de la réponse formatée
        formatted_parts = [f"{confidence_indicator}{main_response}"]
        
        # Ajout d'alternatives créatives si disponibles
        creative_alternatives = cortex_response.get('creative_alternatives', [])
        if creative_alternatives and len(creative_alternatives) > 1:
            formatted_parts.append("\n\n💡 **Autres perspectives:**")
            for i, alt in enumerate(creative_alternatives[1:3], 1):
                formatted_parts.append(f"{i}. {alt}")
        
        # Ajout de métriques si demandé
        if 'analyse' in original_message.lower() or 'métriques' in original_message.lower():
            processing_time = cortex_response.get('processing_time', 0)
            formatted_parts.append(
                f"\n\n📊 **Métriques:** Confiance: {confidence:.0%} | "
                f"Temps: {processing_time:.2f}s"
            )
        
        return ''.join(formatted_parts)

    def _create_error_response(self, error: Exception) -> str:
        """Crée une réponse d'erreur conviviale"""
        error_messages = [
            "Je rencontre quelques difficultés techniques. Pouvez-vous reformuler votre demande?",
            "Mon système cognitif rencontre un problème passager. Essayons à nouveau!",
            "Désolé, j'ai besoin d'un moment pour me recalibrer. Pouvez-vous répéter?",
            "Problème de connexion neuronale détecté. Réessayons cette interaction!"
        ]
        
        import random
        return f"🔄 {random.choice(error_messages)}\n\n*Erreur technique: {str(error)}*"

    def _get_user_profile(self, history: List[List[str]]) -> Optional[Dict]:
        """Extrait le profil utilisateur de l'historique"""
        if len(history) < 3:
            return None
            
        # Profil basique basé sur les interactions
        return {
            'interaction_count': len(history),
            'preferred_topics': self._extract_topics(history),
            'conversation_style': await self._detect_conversation_tone(history)
        }

    async def _update_conversation_context(self, message: str, response: str, cortex_data: Dict):
        """Met à jour le contexte de conversation"""
        self.conversation_context.update({
            'last_interaction': datetime.now().isoformat(),
            'last_user_message': message,
            'last_system_response': response,
            'last_analysis': cortex_data.get('analysis', {}),
            'interaction_quality': cortex_data.get('confidence', 0.5)
        })

    async def get_conversation_analytics(self) -> Dict[str, Any]:
        """Retourne des analytics sur la conversation"""
        return {
            'total_interactions': len(self.conversation_context.get('history', [])),
            'average_confidence': self.conversation_context.get('average_confidence', 0),
            'preferred_topics': self.conversation_context.get('topics', []),
            'user_engagement': 'high'  # À implémenter
        }