Cortex/api/main.py

import asyncio
from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
import uvicorn
import logging
from typing import Dict, List, Any, Optional
from pydantic import BaseModel

# Import des modules Cortex
from ..quantum.quantum_processor import quantum_processor, initialize_quantum_processing
from ..quantum.entanglement import entanglement_manager, initialize_quantum_entanglement
from ..memory.quantum_memory import quantum_memory, initialize_quantum_memory_system
from ..consciousness.awareness_engine import awareness_engine, initialize_consciousness_system
from ..connectors.huggingface import HuggingFaceConnector
from ..connectors.openai import OpenAIConnector
from ..connectors.quantum_api import QuantumAPI
from ..replication.cross_platform import replicator, initialize_cross_platform_system

# Modèles Pydantic
class QuantumCircuitRequest(BaseModel):
    circuit: Dict[str, Any]
    shots: int = 1000

class MemoryStoreRequest(BaseModel):
    data: Any
    address: Optional[str] = None

class ConsciousnessExperience(BaseModel):
    content: Any
    emotional_context: Dict[str, float]

class ReplicationRequest(BaseModel):
    data: Dict[str, Any]
    target_nodes: Optional[List[str]] = None

class BarouiaCortexAPI:
    """API principale de Barouia-Cortex Ultimate"""
    
    def __init__(self):
        self.app = FastAPI(
            title="Barouia-Cortex Ultimate API",
            description="API quantique avancée avec conscience artificielle",
            version="2.0.0",
            docs_url="/docs",
            redoc_url="/redoc"
        )
        
        self.logger = logging.getLogger("cortex_api")
        self.setup_middleware()
        self.setup_routes()
        
        # Initialisation des connecteurs
        self.hf_connector = HuggingFaceConnector()
        self.openai_connector = OpenAIConnector()
        self.quantum_api = QuantumAPI()
    
    def setup_middleware(self):
        """Configure le middleware CORS"""
        self.app.add_middleware(
            CORSMiddleware,
            allow_origins=["*"],
            allow_credentials=True,
            allow_methods=["*"],
            allow_headers=["*"],
        )
    
    def setup_routes(self):
        """Configure toutes les routes de l'API"""
        
        @self.app.get("/")
        async def root():
            return {
                "message": "🧠 Barouia-Cortex Ultimate API",
                "version": "2.0.0",
                "status": "operational",
                "quantum_ready": True,
                "consciousness_active": True
            }
        
        @self.app.get("/health")
        async def health_check():
            return {
                "status": "healthy",
                "components": {
                    "quantum_processor": True,
                    "quantum_memory": True,
                    "consciousness_engine": True,
                    "replication_system": True
                }
            }
        
        # Routes quantiques
        @self.app.post("/quantum/execute-circuit")
        async def execute_quantum_circuit(request: QuantumCircuitRequest):
            """Exécute un circuit quantique"""
            try:
                result = await quantum_processor.execute_quantum_circuit(request.circuit)
                return JSONResponse(content=result)
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        @self.app.post("/quantum/entangle")
        async def entangle_qubits(qubit_a: str, qubit_b: str):
            """Intrique deux qubits"""
            try:
                result = await entanglement_manager.create_bell_pair(qubit_a, qubit_b)
                return {"status": "entangled", "pair": result}
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        # Routes mémoire
        @self.app.post("/memory/store")
        async def store_in_memory(request: MemoryStoreRequest):
            """Stocke des données en mémoire quantique"""
            try:
                address = await quantum_memory.store_quantum_data(request.data, request.address)
                return {"status": "stored", "address": address}
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        @self.app.get("/memory/retrieve/{address}")
        async def retrieve_from_memory(address: str, measure: bool = False):
            """Récupère des données de la mémoire quantique"""
            try:
                data = await quantum_memory.retrieve_quantum_data(address, measure)
                return {"address": address, "data": data}
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        # Routes conscience
        @self.app.post("/consciousness/experience")
        async def process_experience(experience: ConsciousnessExperience):
            """Traite une expérience consciente"""
            try:
                result = await awareness_engine.process_experience(
                    experience.content, 
                    experience.emotional_context
                )
                return {"experience_processed": True, "result": result}
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        @self.app.post("/consciousness/meditation")
        async def quantum_meditation():
            """Démarre une méditation quantique"""
            try:
                result = await awareness_engine.quantum_consciousness_meditation()
                return result
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        # Routes réplication
        @self.app.post("/replication/replicate")
        async def replicate_data(request: ReplicationRequest):
            """Réplique des données cross-platform"""
            try:
                result = await replicator.replicate_data(request.data, request.target_nodes)
                return result
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        @self.app.get("/replication/statistics")
        async def get_replication_stats():
            """Récupère les statistiques de réplication"""
            try:
                stats = replicator.get_platform_statistics()
                return stats
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        # Routes connecteurs
        @self.app.post("/connectors/huggingface/generate")
        async def hf_generate_text(prompt: str, model: str = "gpt2"):
            """Génère du texte avec HuggingFace"""
            try:
                result = await self.hf_connector.generate_text(prompt, model)
                return result
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        @self.app.post("/connectors/openai/chat")
        async def openai_chat(messages: List[Dict], model: str = "gpt-4"):
            """Chat avec OpenAI"""
            try:
                result = await self.openai_connector.chat_completion(messages, model)
                return result
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
        
        # Routes statistiques système
        @self.app.get("/system/statistics")
        async def get_system_statistics():
            """Récupère toutes les statistiques système"""
            try:
                stats = {
                    "quantum_processor": quantum_processor.get_quantum_stats(),
                    "quantum_memory": quantum_memory.get_memory_statistics(),
                    "entanglement": entanglement_manager.get_entanglement_statistics(),
                    "consciousness": await awareness_engine.meta_cognitive_analysis(),
                    "replication": replicator.get_platform_statistics()
                }
                return stats
            except Exception as e:
                raise HTTPException(status_code=500, detail=str(e))
    
    async def initialize_all_components(self):
        """Initialise tous les composants du système"""
        self.logger.info("🚀 Initialisation de tous les composants Barouia-Cortex...")
        
        initialization_tasks = [
            initialize_quantum_processing(),
            initialize_quantum_entanglement(),
            initialize_quantum_memory_system(),
            initialize_consciousness_system(),
            initialize_cross_platform_system(),
            self.hf_connector.initialize(),
            self.openai_connector.initialize(),
            self.quantum_api.initialize()
        ]
        
        results = await asyncio.gather(*initialization_tasks, return_exceptions=True)
        
        success_count = sum(1 for r in results if r is True)
        self.logger.info(f"✅ {success_count}/{len(initialization_tasks)} composants initialisés")
        
        return success_count == len(initialization_tasks)

# Instance globale de l'API
cortex_api = BarouiaCortexAPI()
app = cortex_api.app

async def main():
    """Point d'entrée principal"""
    # Configuration du logging
    logging.basicConfig(level=logging.INFO)
    
    # Initialisation des composants
    await cortex_api.initialize_all_components()
    
    # Démarrage du serveur
    config = uvicorn.Config(
        app=app,
        host="0.0.0.0",
        port=8000,
        reload=True,
        log_level="info"
    )
    
    server = uvicorn.Server(config)
    await server.serve()

if __name__ == "__main__":
    asyncio.run(main())