modules/database/semantic_mongo_live_db.py

# modules/database/semantic_mongo_live_db.py
import logging
import base64
from datetime import datetime, timezone
from pymongo.errors import PyMongoError

# Importaciones locales
from .mongo_db import (
    get_collection,
    insert_document, 
    find_documents, 
    update_document, 
    delete_document
)

# Configuración del logger
logger = logging.getLogger(__name__)
COLLECTION_NAME = 'student_semantic_live_analysis'

def store_student_semantic_live_result(username, text, analysis_result, lang_code='en'):
    """
    Guarda el resultado del análisis semántico en vivo en MongoDB.
    Versión mejorada con validación de datos y manejo de errores.
    """
    try:
        # Validación de parámetros
        if not username or not isinstance(username, str):
            logger.error("Nombre de usuario inválido")
            return False

        if not text or not isinstance(text, str):
            logger.error("Texto de análisis inválido")
            return False

        if not analysis_result or not isinstance(analysis_result, dict):
            logger.error("Resultado de análisis inválido")
            return False

        # Preparar el gráfico conceptual
        concept_graph_data = None
        if 'concept_graph' in analysis_result and analysis_result['concept_graph']:
            try:
                if isinstance(analysis_result['concept_graph'], bytes):
                    concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
                elif isinstance(analysis_result['concept_graph'], str):
                    # Verificar si ya está en base64
                    concept_graph_data = analysis_result['concept_graph']
            except Exception as e:
                logger.error(f"Error al procesar gráfico: {str(e)}")

        # Crear documento con campos validados
        analysis_document = {
            'username': username,
            'timestamp': datetime.now(timezone.utc),
            'text': text[:50000],  # Limitar tamaño
            'analysis_type': 'semantic_live',
            'language': lang_code,
            'key_concepts': analysis_result.get('key_concepts', [])[:50],  # Limitar a 50 conceptos
            'concept_centrality': analysis_result.get('concept_centrality', {}),
            'metadata': {
                'version': '1.0',
                'source': 'live_interface'
            }
        }

        if concept_graph_data:
            analysis_document['concept_graph'] = concept_graph_data

        # Operación de base de datos
        try:
            result = insert_document(COLLECTION_NAME, analysis_document)
            if result:
                logger.info(f"Análisis en vivo guardado para {username}")
                return True
            logger.error("Inserción fallida (sin ID devuelto)")
            return False
        except PyMongoError as e:
            logger.error(f"Error de MongoDB: {str(e)}")
            return False

    except Exception as e:
        logger.error(f"Error inesperado: {str(e)}", exc_info=True)
        return False

def get_student_semantic_live_analysis(username, limit=10):
    """
    Recupera los análisis semánticos en vivo de un estudiante.
    Versión corregida con consulta adecuada.
    """
    try:
        query = {
            "username": username,
            "analysis_type": "semantic_live"  # Corregido a semantic_live
        }
        
        projection = {
            "timestamp": 1,
            "text": {"$substr": ["$text", 0, 200]},  # Solo primeros 200 chars
            "key_concepts": 1,
            "concept_graph": 1,
            "_id": 1
        }
        
        results = find_documents(
            COLLECTION_NAME,
            query,
            projection=projection,
            sort=[("timestamp", -1)],
            limit=limit
        )
        
        logger.info(f"Recuperados {len(results)} análisis en vivo para {username}")
        return results
        
    except PyMongoError as e:
        logger.error(f"Error de MongoDB: {str(e)}")
        return []
    except Exception as e:
        logger.error(f"Error inesperado: {str(e)}")
        return []

def update_student_semantic_live_analysis(analysis_id, update_data):
    """Actualiza un análisis existente con manejo de errores"""
    try:
        query = {"_id": analysis_id}
        update = {"$set": update_data}
        return update_document(COLLECTION_NAME, query, update) > 0
    except PyMongoError as e:
        logger.error(f"Error al actualizar: {str(e)}")
        return False

def delete_student_semantic_live_analysis(analysis_id):
    """Elimina un análisis con manejo de errores"""
    try:
        query = {"_id": analysis_id}
        return delete_document(COLLECTION_NAME, query) > 0
    except PyMongoError as e:
        logger.error(f"Error al eliminar: {str(e)}")
        return False

def get_student_semantic_live_data(username):
    """
    Obtiene todos los análisis semánticos en vivo de un estudiante.
    Versión corregida que usa la función _live.
    """
    try:
        analyses = get_student_semantic_live_analysis(username, limit=None)
        
        formatted_analyses = []
        for analysis in analyses:
            formatted_analysis = {
                'timestamp': analysis.get('timestamp'),
                'text': analysis.get('text', ''),
                'key_concepts': analysis.get('key_concepts', []),
                'concept_graph': analysis.get('concept_graph')
            }
            formatted_analyses.append(formatted_analysis)
        
        return {
            'username': username,
            'entries': formatted_analyses,
            'count': len(formatted_analyses),
            'status': 'success'
        }
    
    except Exception as e:
        logger.error(f"Error al obtener datos: {str(e)}")
        return {
            'username': username,
            'entries': [],
            'count': 0,
            'status': 'error',
            'error': str(e)
        }

__all__ = [
    'store_student_semantic_live_result',
    'get_student_semantic_live_analysis',
    'update_student_semantic_live_analysis',
    'delete_student_semantic_live_analysis',
    'get_student_semantic_live_data'
]