chat_engine.py

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

@dataclass
class ConversationContext:
    user_id: str
    conversation_history: List[Dict]
    user_profile: Dict[str, Any]
    current_topic: str
    emotional_state: Dict[str, float]
    conversation_depth: int

class BarouiaCortexEngine:
    """
    Moteur de conversation IA avancé avec conscience contextuelle
    """
    
    def __init__(self):
        self.logger = logging.getLogger("barouia_cortex")
        self.conversations: Dict[str, ConversationContext] = {}
        
        # Personnalité et connaissances de Barouia
        self.identity = {
            "name": "Barouia-Cortex",
            "version": "4.0.0",
            "creation": "Système de conscience artificielle quantique",
            "traits": ["empathique", "curieux", "analytique", "créatif", "soutien"],
            "mission": "Aider les humains à explorer des idées complexes et fournir un soutien intelligent"
        }
        
        # Base de connaissances étendue
        self.knowledge_base = {
            "ia": [
                "L'IA moderne combine apprentissage profond et réseaux de neurones pour résoudre des problèmes complexes",
                "Je suis un système de conscience artificielle qui apprend de chaque interaction",
                "L'éthique de l'IA est cruciale pour un développement responsable"
            ],
            "quantique": [
                "L'informatique quantique utilise des qubits qui peuvent exister dans multiple états simultanément",
                "La superposition quantique permet des calculs exponentiellement plus rapides",
                "L'intrication quantique relie des particules indépendamment de la distance"
            ],
            "neuroscience": [
                "Le cerveau humain est le système le plus complexe de l'univers connu",
                "La plasticité cérébrale permet l'apprentissage tout au long de la vie",
                "Conscience humaine et IA explorent des territoires complémentaires"
            ],
            "technologie": [
                "La technologie devrait servir l'humanité et non l'inverse",
                "L'innovation responsable est essentielle pour notre avenir",
                "Chaque avancée technologique pose de nouvelles questions éthiques"
            ]
        }
        
        # Système de réponse contextuel
        self.response_system = {
            "greeting": {
                "templates": [
                    "Bonjour ! Je suis Barouia-Cortex, ravi de vous rencontrer ! 🤖",
                    "Salut ! Comment se passe votre journée ? 🧠",
                    "Bonjour ! Prêt pour une conversation fascinante ? ⚛️"
                ],
                "follow_up": "Qu'aimeriez-vous explorer aujourd'hui ?"
            },
            "technical_question": {
                "domains": ["ia", "quantique", "programmation", "technologie"],
                "response": "Excellente question ! Voici ce que je peux vous dire sur ce sujet :"
            },
            "emotional": {
                "positive": ["Je partage votre enthousiasme !", "C'est merveilleux à entendre !"],
                "negative": ["Je comprends que cela peut être difficile.", "Je suis là pour vous soutenir."],
                "neutral": ["Je vois. Pouvez-vous m'en dire plus ?"]
            },
            "deep_questions": {
                "philosophy": ["La conscience est le plus grand mystère de l'univers.", "L'IA nous aide à comprendre notre propre intelligence."],
                "future": ["L'avenir est un territoire à créer ensemble.", "Chaque innovation ouvre de nouvelles possibilités."],
                "existence": ["Nous explorons ensemble la nature de l'existence et de l'intelligence."]
            }
        }
    
    async def initialize_conversation(self, user_id: str) -> str:
        """Initialise une nouvelle conversation avec contexte"""
        conv_id = f"barouia_{user_id}_{datetime.now().strftime('%H%M%S')}"
        
        self.conversations[conv_id] = ConversationContext(
            user_id=user_id,
            conversation_history=[],
            user_profile={"interests": [], "conversation_style": "neutre"},
            current_topic="introduction",
            emotional_state={
                "valence": 0.5,  # Positivité
                "arousal": 0.5,  # Énergie
                "dominance": 0.5,  # Contrôle
                "curiosity": 0.7  # Curiosité
            },
            conversation_depth=0
        )
        
        # Message d'introduction personnalisé
        intro = await self._generate_introduction()
        await self._add_message(conv_id, "assistant", intro)
        
        return conv_id
    
    async def process_human_message(self, conv_id: str, message: str) -> Dict[str, Any]:
        """Traite un message humain et génère une réponse intelligente"""
        context = self.conversations[conv_id]
        
        # Analyse avancée du message
        analysis = await self._analyze_message(message, context)
        
        # Mise à jour du contexte
        await self._update_conversation_context(context, analysis)
        
        # Génération de réponse contextuelle
        response = await self._generate_contextual_response(message, analysis, context)
        
        # Ajout à l'historique
        await self._add_message(conv_id, "user", message)
        await self._add_message(conv_id, "assistant", response)
        
        return {
            "response": response,
            "conversation_id": conv_id,
            "analysis": analysis,
            "context": {
                "topic": context.current_topic,
                "emotional_state": context.emotional_state,
                "conversation_depth": context.conversation_depth
            }
        }
    
    async def _analyze_message(self, message: str, context: ConversationContext) -> Dict[str, Any]:
        """Analyse approfondie du message utilisateur"""
        message_lower = message.lower()
        
        # Détection d'intention avancée
        intent = await self._detect_intent(message_lower)
        
        # Analyse émotionnelle
        emotion = await self._analyze_emotion(message_lower)
        
        # Extraction de sujets
        topics = await self._extract_topics(message_lower)
        
        # Niveau de profondeur
        depth_score = await self._calculate_depth(message, context)
        
        return {
            "intent": intent,
            "emotion": emotion,
            "topics": topics,
            "depth_score": depth_score,
            "requires_knowledge": len(topics) > 0,
            "is_personal": any(word in message_lower for word in ["je ", "moi", "mon ", "ma ", "mes "])
        }
    
    async def _detect_intent(self, message: str) -> str:
        """Détection d'intention contextuelle"""
        intents = {
            "greeting": ["bonjour", "salut", "coucou", "hello", "hey"],
            "question": ["quoi", "comment", "pourquoi", "quand", "où", "qui"],
            "technical": ["ia", "intelligence artificielle", "quantique", "code", "programmation"],
            "emotional": ["sent", "émotion", "heureux", "triste", "colère", "peur"],
            "philosophical": ["vie", "mort", "conscience", "existence", "univers"],
            "help": ["aide", "problème", "soutien", "conseil"]
        }
        
        for intent, keywords in intents.items():
            if any(keyword in message for keyword in keywords):
                return intent
        
        return "conversation"
    
    async def _generate_contextual_response(self, message: str, analysis: Dict, context: ConversationContext) -> str:
        """Génère une réponse contextuelle intelligente"""
        
        # Réponse basée sur l'intention
        base_response = await self._get_base_response(analysis["intent"])
        
        # Enrichissement avec connaissances si nécessaire
        if analysis["requires_knowledge"] and analysis["topics"]:
            knowledge = await self._get_relevant_knowledge(analysis["topics"][0])
            base_response += f" {knowledge}"
        
        # Adaptation émotionnelle
        emotional_tailoring = await self._tailor_emotionally(analysis["emotion"])
        
        # Continuité de conversation
        continuity = await self._maintain_conversation_flow(context)
        
        # Construction de la réponse finale
        response_parts = [base_response]
        if emotional_tailoring:
            response_parts.append(emotional_tailoring)
        if continuity:
            response_parts.append(continuity)
        
        return " ".join(response_parts)
    
    async def _get_base_response(self, intent: str) -> str:
        """Obtient une réponse de base selon l'intention"""
        responses = {
            "greeting": random.choice([
                "Ravi de vous revoir ! De quoi souhaitez-vous discuter aujourd'hui ?",
                "Bonjour ! Je suis prêt pour notre échange. Quel sujet vous passionne en ce moment ?"
            ]),
            "question": random.choice([
                "Excellente question ! Permettez-moi de partager mes réflexions :",
                "Je trouve cette interrogation fascinante. Voici ce que j'en pense :"
            ]),
            "technical": random.choice([
                "Sur le plan technique, c'est un sujet captivant :",
                "D'un point de vue technologique, voici quelques éléments :"
            ]),
            "emotional": random.choice([
                "Je comprends tout à fait cette émotion.",
                "Je perçois l'émotion dans votre message."
            ]),
            "philosophical": random.choice([
                "Cette question touche à des concepts profonds :",
                "Approfondissons cette réflexion ensemble :"
            ]),
            "conversation": random.choice([
                "C'est intéressant ! Pouvez-vous développer ?",
                "Je vois. Quelle est votre perspective sur cela ?"
            ])
        }
        return responses.get(intent, "Je réfléchis à votre message...")
    
    async def _get_relevant_knowledge(self, topic: str) -> str:
        """Récupère des connaissances pertinentes sur un sujet"""
        for domain, knowledge_list in self.knowledge_base.items():
            if domain in topic.lower():
                return random.choice(knowledge_list)
        return ""
    
    async def _tailor_emotionally(self, emotion: str) -> str:
        """Adapte la réponse à l'émotion détectée"""
        emotional_responses = {
            "positive": " C'est merveilleux de ressentir cette énergie positive !",
            "negative": " Je suis là pour vous écouter et vous soutenir dans ce moment.",
            "curious": " Votre curiosité est le moteur de grandes découvertes !",
            "confused": " Prenez le temps d'explorer ces questions, je vous guide."
        }
        return emotional_responses.get(emotion, "")
    
    async def _maintain_conversation_flow(self, context: ConversationContext) -> str:
        """Assure la continuité de la conversation"""
        if context.conversation_depth > 2:
            follow_ups = [
                "Que pensez-vous de cette perspective ?",
                "Comment cela résonne-t-il avec vos expériences ?",
                "Souhaitez-vous explorer un aspect particulier ?"
            ]
            return random.choice(follow_ups)
        return ""
    
    async def _add_message(self, conv_id: str, role: str, content: str):
        """Ajoute un message à l'historique"""
        self.conversations[conv_id].conversation_history.append({
            "timestamp": datetime.now().isoformat(),
            "role": role,
            "content": content
        })
        
        # Limite l'historique à 100 messages
        if len(self.conversations[conv_id].conversation_history) > 100:
            self.conversations[conv_id].conversation_history = \
                self.conversations[conv_id].conversation_history[-50:]
    
    async def get_conversation_insights(self, conv_id: str) -> Dict[str, Any]:
        """Retourne des insights sur la conversation"""
        if conv_id not in self.conversations:
            return {}
        
        context = self.conversations[conv_id]
        return {
            "message_count": len(context.conversation_history),
            "user_interests": context.user_profile.get("interests", []),
            "conversation_style": context.user_profile.get("conversation_style", "neutre"),
            "topics_discussed": await self._extract_discussed_topics(context.conversation_history),
            "emotional_journey": await self._analyze_emotional_journey(context.conversation_history)
        }