# modules/database/discourse_mongo_db.py
# Importaciones estándar
import io
import base64
from datetime import datetime, timezone
import logging

# Importaciones de terceros
import matplotlib.pyplot as plt

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_discourse_analysis'

########################################################################
def store_student_discourse_result(username, text1, text2, analysis_result):
    """
    Guarda el resultado del análisis de discurso comparativo en MongoDB.
    """
    try:
        # Verificar qué tipo de objetos son los gráficos para depuración
        if 'graph1' in analysis_result:
            logger.info(f"Tipo de graph1 recibido: {type(analysis_result['graph1'])}")
        if 'graph2' in analysis_result:
            logger.info(f"Tipo de graph2 recibido: {type(analysis_result['graph2'])}")
        if 'combined_graph' in analysis_result:
            logger.info(f"Tipo de combined_graph recibido: {type(analysis_result['combined_graph'])}")
            
        # Convertir gráficos a bytes o base64 según corresponda
        graph1_data = None
        graph2_data = None
        combined_graph_data = None

        if 'graph1' in analysis_result and analysis_result['graph1'] is not None:
            try:
                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
                if hasattr(analysis_result['graph1'], 'savefig'):
                    logger.info("Convirtiendo graph1 de matplotlib a bytes")
                    buf = io.BytesIO()
                    analysis_result['graph1'].savefig(buf, format='png', dpi=100)
                    buf.seek(0)
                    graph1_bytes = buf.getvalue()
                    graph1_data = base64.b64encode(graph1_bytes).decode('utf-8')
                # Si ya es bytes, codificarlo directamente
                elif isinstance(analysis_result['graph1'], bytes):
                    logger.info("Codificando graph1 (ya en bytes) a base64")
                    graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
                # Si ya es una cadena base64, usarla directamente
                elif isinstance(analysis_result['graph1'], str):
                    logger.info("Usando graph1 (ya en string) directamente")
                    graph1_data = analysis_result['graph1']
                # Otro tipo - convertir a string
                else:
                    logger.warning(f"Tipo inesperado para graph1: {type(analysis_result['graph1'])}")
                    graph1_data = str(analysis_result['graph1'])
            except Exception as e:
                logger.error(f"Error al procesar gráfico 1: {str(e)}")

        if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
            try:
                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
                if hasattr(analysis_result['graph2'], 'savefig'):
                    logger.info("Convirtiendo graph2 de matplotlib a bytes")
                    buf = io.BytesIO()
                    analysis_result['graph2'].savefig(buf, format='png', dpi=100)
                    buf.seek(0)
                    graph2_bytes = buf.getvalue()
                    graph2_data = base64.b64encode(graph2_bytes).decode('utf-8')
                # Si ya es bytes, codificarlo directamente
                elif isinstance(analysis_result['graph2'], bytes):
                    logger.info("Codificando graph2 (ya en bytes) a base64")
                    graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
                # Si ya es una cadena base64, usarla directamente
                elif isinstance(analysis_result['graph2'], str):
                    logger.info("Usando graph2 (ya en string) directamente")
                    graph2_data = analysis_result['graph2']
                # Otro tipo - convertir a string
                else:
                    logger.warning(f"Tipo inesperado para graph2: {type(analysis_result['graph2'])}")
                    graph2_data = str(analysis_result['graph2'])
            except Exception as e:
                logger.error(f"Error al procesar gráfico 2: {str(e)}")

        if 'combined_graph' in analysis_result and analysis_result['combined_graph'] is not None:
            try:
                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
                if hasattr(analysis_result['combined_graph'], 'savefig'):
                    logger.info("Convirtiendo combined_graph de matplotlib a bytes")
                    buf = io.BytesIO()
                    analysis_result['combined_graph'].savefig(buf, format='png', dpi=100)
                    buf.seek(0)
                    combined_graph_bytes = buf.getvalue()
                    combined_graph_data = base64.b64encode(combined_graph_bytes).decode('utf-8')
                # Si ya es bytes, codificarlo directamente
                elif isinstance(analysis_result['combined_graph'], bytes):
                    logger.info("Codificando combined_graph (ya en bytes) a base64")
                    combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
                # Si ya es una cadena base64, usarla directamente
                elif isinstance(analysis_result['combined_graph'], str):
                    logger.info("Usando combined_graph (ya en string) directamente")
                    combined_graph_data = analysis_result['combined_graph']
                # Otro tipo - convertir a string
                else:
                    logger.warning(f"Tipo inesperado para combined_graph: {type(analysis_result['combined_graph'])}")
                    combined_graph_data = str(analysis_result['combined_graph'])
            except Exception as e:
                logger.error(f"Error al procesar gráfico combinado: {str(e)}")

        # Crear documento para MongoDB
        analysis_document = {
            'username': username,
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'text1': text1,
            'text2': text2,
            'analysis_type': 'discourse',
            'key_concepts1': analysis_result.get('key_concepts1', []),
            'key_concepts2': analysis_result.get('key_concepts2', []),
            'graph1': graph1_data,
            'graph2': graph2_data,
            'combined_graph': combined_graph_data
        }

        # Insertar en MongoDB
        result = insert_document(COLLECTION_NAME, analysis_document)
        if result:
            logger.info(f"Análisis del discurso guardado con ID: {result} para el usuario: {username}")
            return True

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

    except Exception as e:
        logger.error(f"Error al guardar el análisis del discurso: {str(e)}")
        return False

#################################################################################

# Corrección 1: Actualizar get_student_discourse_analysis para recuperar todos los campos necesarios

def get_student_discourse_analysis(username, limit=10):
    """
    Recupera los análisis del discurso de un estudiante, incluyendo todos los gráficos y conceptos.
    """
    try:
        # Obtener la colección
        collection = get_collection(COLLECTION_NAME)
        if collection is None:
            logger.error("No se pudo obtener la colección discourse")
            return []

        # Consulta
        query = {
            "username": username,
            "analysis_type": "discourse"
        }
        
        # Eliminar la proyección para recuperar todos los campos
        # No usar projection para obtener TODOS los campos
        
        # Ejecutar consulta
        try:
            cursor = collection.find(query).sort("timestamp", -1)
            if limit:
                cursor = cursor.limit(limit)
            
            # Convertir cursor a lista
            results = list(cursor)
            logger.info(f"Recuperados {len(results)} análisis del discurso para {username}")
            
            # Verificar qué campos contienen los resultados para depuración
            if results:
                for result in results:
                    logger.info(f"Campos disponibles: {list(result.keys())}")
                    if 'graph1' in result:
                        logger.info(f"Tipo de graph1: {type(result['graph1'])}")
                    if 'graph2' in result:
                        logger.info(f"Tipo de graph2: {type(result['graph2'])}")
                    if 'combined_graph' in result:
                        logger.info(f"Tipo de combined_graph: {type(result['combined_graph'])}")
            
            return results
            
        except Exception as db_error:
            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
            return []
        
    except Exception as e:
        logger.error(f"Error recuperando análisis del discurso: {str(e)}")
        return []

#####################################################################################
        
def get_student_discourse_data(username):
    """
    Obtiene un resumen de los análisis del discurso de un estudiante.
    """
    try:
        analyses = get_student_discourse_analysis(username, limit=None)
        formatted_analyses = []
        
        for analysis in analyses:
            formatted_analysis = {
                'timestamp': analysis['timestamp'],
                'text1': analysis.get('text1', ''),
                'text2': analysis.get('text2', ''),
                'key_concepts1': analysis.get('key_concepts1', []),
                'key_concepts2': analysis.get('key_concepts2', [])
            }
            formatted_analyses.append(formatted_analysis)
            
        return {'entries': formatted_analyses}
        
    except Exception as e:
        logger.error(f"Error al obtener datos del discurso: {str(e)}")
        return {'entries': []}

###########################################################################
def update_student_discourse_analysis(analysis_id, update_data):
    """
    Actualiza un análisis del discurso existente.
    """
    try:
        query = {"_id": analysis_id}
        update = {"$set": update_data}
        return update_document(COLLECTION_NAME, query, update)
    except Exception as e:
        logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
        return False

###########################################################################
def delete_student_discourse_analysis(analysis_id):
    """
    Elimina un análisis del discurso.
    """
    try:
        query = {"_id": analysis_id}
        return delete_document(COLLECTION_NAME, query)
    except Exception as e:
        logger.error(f"Error al eliminar análisis del discurso: {str(e)}")
        return False