# modules/database/current_situation_mongo_db.py
from datetime import datetime, timezone, timedelta
import logging
from .mongo_db import get_collection

logger = logging.getLogger(__name__)
COLLECTION_NAME = 'student_current_situation'

def store_current_situation_result(username, text, metrics, feedback):
    """
    Guarda los resultados del análisis de situación actual.
    """
    try:
        # Verificar parámetros
        if not all([username, text, metrics]):
            logger.error("Faltan parámetros requeridos")
            return False

        collection = get_collection(COLLECTION_NAME)
        if collection is None:
            logger.error("No se pudo obtener la colección")
            return False

        # Formatear métricas para MongoDB
        formatted_metrics = {
            'vocabulary': {
                'score': metrics['vocabulary']['normalized_score'],
                'details': metrics['vocabulary']['details']
            },
            'structure': {
                'score': metrics['structure']['normalized_score'],
                'details': metrics['structure']['details']
            },
            'cohesion': {
                'score': metrics['cohesion']['normalized_score'],
                'details': metrics['cohesion']['details']
            },
            'clarity': {
                'score': metrics['clarity']['normalized_score'],
                'details': metrics['clarity']['details']
            }
        }

        # Crear documento
        document = {
            'username': username,
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'text': text,
            'metrics': formatted_metrics,  # Usar las métricas formateadas
            'feedback': feedback,
            'analysis_type': 'current_situation'
        }

        # Insertar documento
        result = collection.insert_one(document)
        if result.inserted_id:
            logger.info(f"""
                Análisis guardado exitosamente:
                - Usuario: {username}
                - ID: {result.inserted_id}
                - Longitud del texto: {len(text)}
                - Métricas: {formatted_metrics}
            """)
            
            # Verificar almacenamiento
            if verify_storage(username):
                logger.info("Verificación de almacenamiento exitosa")
                return True
            else:
                logger.warning("Verificación de almacenamiento falló")
                return False

        logger.error("No se pudo insertar el documento")
        return False

    except Exception as e:
        logger.error(f"Error guardando análisis de situación actual: {str(e)}")
        return False

def verify_storage(username):
    """
    Verifica que los datos se están guardando correctamente.
    """
    try:
        collection = get_collection(COLLECTION_NAME)
        if collection is None:
            logger.error("No se pudo obtener la colección para verificación")
            return False
            
        # Buscar documentos recientes del usuario
        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
        
        recent_docs = collection.find({
            'username': username,
            'timestamp': {'$gte': timestamp_threshold}
        }).sort('timestamp', -1).limit(1)

        docs = list(recent_docs)
        if docs:
            logger.info(f"""
                Último documento guardado:
                - ID: {docs[0]['_id']}
                - Timestamp: {docs[0]['timestamp']}
                - Métricas guardadas: {bool(docs[0].get('metrics'))}
            """)
            return True
        
        logger.warning(f"No se encontraron documentos recientes para {username}")
        return False

    except Exception as e:
        logger.error(f"Error verificando almacenamiento: {str(e)}")
        return False

def get_recent_situation_analysis(username, limit=5):
    """
    Obtiene los análisis más recientes de un usuario.
    """
    try:
        collection = get_collection(COLLECTION_NAME)
        if collection is None:
            return []
            
        results = collection.find(
            {'username': username}
        ).sort('timestamp', -1).limit(limit)
        
        return list(results)
        
    except Exception as e:
        logger.error(f"Error obteniendo análisis recientes: {str(e)}")
        return []