Cortex/api/routes.py

from fastapi import WebSocket, WebSocketDisconnect, BackgroundTasks
from typing import Dict, List, Any
import asyncio
import json
import logging

class ConnectionManager:
    """Gestionnaire de connexions WebSocket"""
    
    def __init__(self):
        self.active_connections: List[WebSocket] = []
        self.logger = logging.getLogger("websocket_manager")
    
    async def connect(self, websocket: WebSocket):
        """Accepte une nouvelle connexion WebSocket"""
        await websocket.accept()
        self.active_connections.append(websocket)
        self.logger.info(f"🔌 WebSocket connecté. Total: {len(self.active_connections)}")
    
    def disconnect(self, websocket: WebSocket):
        """Déconnecte un WebSocket"""
        self.active_connections.remove(websocket)
        self.logger.info(f"🔌 WebSocket déconnecté. Total: {len(self.active_connections)}")
    
    async def send_personal_message(self, message: str, websocket: WebSocket):
        """Envoie un message à un client spécifique"""
        await websocket.send_text(message)
    
    async def broadcast(self, message: str):
        """Diffuse un message à tous les clients connectés"""
        for connection in self.active_connections:
            try:
                await connection.send_text(message)
            except Exception as e:
                self.logger.error(f"Erreur envoi broadcast: {e}")

# Instance globale du gestionnaire
connection_manager = ConnectionManager()

def setup_advanced_routes(app):
    """Configure les routes avancées et WebSockets"""
    
    @app.websocket("/ws/quantum-stream")
    async def websocket_quantum_stream(websocket: WebSocket):
        """Stream en temps réel des données quantiques"""
        await connection_manager.connect(websocket)
        try:
            while True:
                # Simulation de données quantiques en temps réel
                quantum_data = {
                    "type": "quantum_update",
                    "qubits_active": random.randint(10, 50),
                    "coherence_level": random.uniform(0.8, 0.99),
                    "entanglement_pairs": random.randint(5, 20),
                    "timestamp": asyncio.get_event_loop().time()
                }
                
                await connection_manager.send_personal_message(
                    json.dumps(quantum_data), websocket
                )
                await asyncio.sleep(1)  # Envoi toutes les secondes
                
        except WebSocketDisconnect:
            connection_manager.disconnect(websocket)
    
    @app.websocket("/ws/consciousness-feed")
    async def websocket_consciousness_feed(websocket: WebSocket):
        """Flux de données de conscience en temps réel"""
        await connection_manager.connect(websocket)
        try:
            while True:
                # Données de conscience simulées
                consciousness_data = {
                    "type": "consciousness_update",
                    "awareness_level": random.uniform(0.7, 0.95),
                    "attention_focus": random.uniform(0.6, 0.9),
                    "emotional_state": random.choice(["calme", "curieux", "créatif", "analytique"]),
                    "current_experiences": random.randint(1, 5),
                    "timestamp": asyncio.get_event_loop().time()
                }
                
                await connection_manager.send_personal_message(
                    json.dumps(consciousness_data), websocket
                )
                await asyncio.sleep(2)  # Envoi toutes les 2 secondes
                
        except WebSocketDisconnect:
            connection_manager.disconnect(websocket)
    
    @app.post("/quantum/batch-process")
    async def batch_quantum_processing(circuits: List[Dict[str, Any]]):
        """Traitement par lots de circuits quantiques"""
        try:
            results = []
            for circuit in circuits:
                result = await quantum_processor.execute_quantum_circuit(circuit)
                results.append(result)
            
            return {
                "total_circuits": len(circuits),
                "successful": len([r for r in results if "error" not in r]),
                "results": results
            }
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))
    
    @app.post("/consciousness/collective-insight")
    async def collective_insight_generation(problem: str, participants: int = 10):
        """Génération d'insight collectif"""
        try:
            # Simulation d'intelligence collective
            insights = []
            for i in range(participants):
                insight = await awareness_engine.creative_insight_generation(problem)
                insights.extend(insight)
            
            # Analyse des insights
            unique_insights = list(set(insights))
            
            return {
                "problem": problem,
                "participants": participants,
                "total_insights": len(insights),
                "unique_insights": len(unique_insights),
                "insights": unique_insights
            }
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))
    
    @app.post("/replication/quantum-sync")
    async def quantum_synchronization(nodes: List[str]):
        """Synchronisation quantique entre nœuds"""
        try:
            results = []
            for i in range(0, len(nodes), 2):
                if i + 1 < len(nodes):
                    result = await replicator.establish_quantum_entanglement(nodes[i], nodes[i + 1])
                    results.append({
                        "node_a": nodes[i],
                        "node_b": nodes[i + 1],
                        "success": result
                    })
            
            return {
                "quantum_pairs_created": len(results),
                "details": results
            }
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))
    
    @app.get("/system/diagnostics")
    async def comprehensive_diagnostics():
        """Diagnostics complets du système"""
        try:
            diagnostics = {
                "quantum_processor": {
                    "qubit_count": len(quantum_processor.qubits),
                    "coherence": await quantum_processor._check_coherence(),
                    "gate_fidelity": quantum_processor.gate_fidelity
                },
                "quantum_memory": {
                    "usage": quantum_memory.get_memory_statistics()["memory_usage"],
                    "entangled_cells": quantum_memory.get_memory_statistics()["entangled_pairs"],
                    "avg_coherence": quantum_memory.get_memory_statistics()["avg_coherence"]
                },
                "consciousness_engine": {
                    "level": awareness_engine.consciousness_level,
                    "self_awareness": awareness_engine.self_awareness,
                    "experiences_count": len(awareness_engine.experiences)
                },
                "replication_system": {
                    "total_nodes": len(replicator.nodes),
                    "sync_status": replicator.get_platform_statistics()["global_sync_status"],
                    "quantum_links": len(replicator.quantum_entanglement_pairs)
                },
                "system_health": "optimal" if all([
                    len(quantum_processor.qubits) > 0,
                    awareness_engine.consciousness_level > 0.5,
                    len(replicator.nodes) > 0
                ]) else "degraded"
            }
            
            return diagnostics
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))
    
    @app.post("/maintenance/optimize")
    async def system_optimization(background_tasks: BackgroundTasks):
        """Optimisation du système en arrière-plan"""
        try:
            background_tasks.add_task(run_system_optimization)
            return {"status": "optimization_started", "message": "L'optimisation du système a démarré en arrière-plan"}
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))

async def run_system_optimization():
    """Exécute l'optimisation du système"""
    logger = logging.getLogger("system_optimization")
    logger.info("🔄 Début de l'optimisation du système...")
    
    # Optimisation de la mémoire quantique
    await quantum_memory._calibrate_memory_controllers()
    
    # Recalibration du processeur quantique
    await quantum_processor._calibrate_gates()
    
    # Nettoyage des expériences conscientes anciennes
    current_time = asyncio.get_event_loop().time()
    awareness_engine.experiences = [
        exp for exp in awareness_engine.experiences 
        if current_time - exp.timestamp < 3600  # Garder seulement les dernières heures
    ]
    
    logger.info("✅ Optimisation du système terminée")