modules/database/database.py

# database.py
import logging
import os
from azure.cosmos import CosmosClient
from azure.cosmos.exceptions import CosmosHttpResponseError
from pymongo import MongoClient
import certifi
from datetime import datetime
import io
import base64
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
import bcrypt
print(f"Bcrypt version: {bcrypt.__version__}")
import uuid

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

# Variables globales para Cosmos DB SQL API
application_requests_container = None
cosmos_client = None
user_database = None
user_container = None

# Variables globales para Cosmos DB MongoDB API
mongo_client = None
mongo_db = None
analysis_collection = None
chat_collection = None  # Nueva variable global


#####################################################################################33
def initialize_database_connections():
    try:
        print("Iniciando conexión a MongoDB")
        mongodb_success = initialize_mongodb_connection()
        print(f"Conexión a MongoDB: {'exitosa' if mongodb_success else 'fallida'}")
    except Exception as e:
        print(f"Error al conectar con MongoDB: {str(e)}")
        mongodb_success = False

    try:
        print("Iniciando conexión a Cosmos DB SQL API")
        sql_success = initialize_cosmos_sql_connection()
        print(f"Conexión a Cosmos DB SQL API: {'exitosa' if sql_success else 'fallida'}")
    except Exception as e:
        print(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
        sql_success = False

    return {
        "mongodb": mongodb_success,
        "cosmos_sql": sql_success
    }

#####################################################################################33
def initialize_cosmos_sql_connection():
    global cosmos_client, user_database, user_container, application_requests_container
    logger.info("Initializing Cosmos DB SQL API connection")
    try:
        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
        cosmos_key = os.environ.get("COSMOS_KEY")
        logger.info(f"Cosmos Endpoint: {cosmos_endpoint}")
        logger.info(f"Cosmos Key: {'*' * len(cosmos_key) if cosmos_key else 'Not set'}")
        
        if not cosmos_endpoint or not cosmos_key:
            logger.error("COSMOS_ENDPOINT or COSMOS_KEY environment variables are not set")
            raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
        
        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
        user_database = cosmos_client.get_database_client("user_database")
        user_container = user_database.get_container_client("users")
        application_requests_container = user_database.get_container_client("application_requests")
        
        logger.info(f"user_container initialized: {user_container is not None}")
        logger.info(f"application_requests_container initialized: {application_requests_container is not None}")
        
        logger.info("Conexión a Cosmos DB SQL API exitosa")
        return True
    except Exception as e:
        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}", exc_info=True)
        return False

############################################################################################3        
def initialize_mongodb_connection():
    global mongo_client, mongo_db, analysis_collection, chat_collection
    try:
        cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
        if not cosmos_mongodb_connection_string:
            logger.error("La variable de entorno MONGODB_CONNECTION_STRING no está configurada")
            return False

        mongo_client = MongoClient(cosmos_mongodb_connection_string,
                                   tls=True,
                                   tlsCAFile=certifi.where(),
                                   retryWrites=False,
                                   serverSelectionTimeoutMS=5000,
                                   connectTimeoutMS=10000,
                                   socketTimeoutMS=10000)

        mongo_client.admin.command('ping')
        
        mongo_db = mongo_client['aideatext_db']
        analysis_collection = mongo_db['text_analysis']
        chat_collection = mongo_db['chat_history']  # Inicializar la nueva colección

        # Verificar la conexión
        mongo_client.admin.command('ping')
        
        logger.info("Conexión a Cosmos DB MongoDB API exitosa")
        return True
    except Exception as e:
        logger.error(f"Error al conectar con Cosmos DB MongoDB API: {str(e)}", exc_info=True)
        return False

#######################################################################################################
def create_user(username, password, role):
    global user_container
    try:
        print(f"Attempting to create user: {username} with role: {role}")
        if user_container is None:
            print("Error: user_container is None. Attempting to reinitialize connection.")
            if not initialize_cosmos_sql_connection():
                raise Exception("Failed to initialize SQL connection")
        
        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
        print(f"Password hashed successfully for user: {username}")
        user_data = {
            'id': username,
            'password': hashed_password,
            'role': role,
            'created_at': datetime.utcnow().isoformat()
        }
        user_container.create_item(body=user_data)
        print(f"Usuario {role} creado: {username}")  # Log para depuración
        return True
    except Exception as e:
        print(f"Detailed error in create_user: {str(e)}")
        return False

#######################################################################################################
def create_admin_user(username, password):
    return create_user(username, password, 'Administrador')
    
#######################################################################################################
def create_student_user(username, password):
    return create_user(username, password, 'Estudiante')
       
#######################################################################################################
# Funciones para Cosmos DB SQL API (manejo de usuarios)
def get_user(username):
    try:
        query = f"SELECT * FROM c WHERE c.id = '{username}'"
        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
        user = items[0] if items else None
        if user:
            print(f"Usuario encontrado: {username}, Rol: {user.get('role')}")  # Log añadido
        else:
            print(f"Usuario no encontrado: {username}")  # Log añadido
        return user
    except Exception as e:
        print(f"Error al obtener usuario {username}: {str(e)}")
        return None

#######################################################################################################
def store_application_request(name, email, institution, role, reason):
    global application_requests_container
    logger.info("Entering store_application_request function")
    try:
        logger.info("Checking application_requests_container")
        if application_requests_container is None:
            logger.error("application_requests_container is not initialized")
            return False

        logger.info("Creating application request document")
        application_request = {
            "id": str(uuid.uuid4()),
            "name": name,
            "email": email,
            "institution": institution,
            "role": role,
            "reason": reason,
            "requestDate": datetime.utcnow().isoformat()
        }

        logger.info(f"Attempting to store document: {application_request}")
        application_requests_container.create_item(body=application_request)
        logger.info(f"Application request stored for email: {email}")
        return True
    except Exception as e:
        logger.error(f"Error storing application request: {str(e)}")
        return False
        
#######################################################################################################
def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
    if analysis_collection is None:
        logger.error("La conexión a MongoDB no está inicializada")
        return False

    try:
        word_count = {}
        for word, color in repeated_words.items():
            category = color  # Asumiendo que 'color' es la categoría gramatical
            word_count[category] = word_count.get(category, 0) + 1

        analysis_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'text': text,
            'word_count': word_count,
            'arc_diagrams': arc_diagrams,
            'pos_analysis': pos_analysis,
            'morphological_analysis': morphological_analysis,
            'sentence_structure': sentence_structure
        }

        result = analysis_collection.insert_one(analysis_document)
        logger.info(f"Análisis guardado con ID: {result.inserted_id} para el usuario: {username}")
        return True
    except Exception as e:
        logger.error(f"Error al guardar el análisis para el usuario {username}: {str(e)}")
        return False

################################################################################################################
def store_semantic_result(username, text, analysis_result):
    if analysis_collection is None:
        logger.error("La conexión a MongoDB no está inicializada")
        return False
    try:
        buf = io.BytesIO()
        analysis_result['relations_graph'].savefig(buf, format='png')
        buf.seek(0)
        img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
        analysis_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'text': text,
            'entities': analysis_result['entities'],
            'key_concepts': analysis_result['key_concepts'],
            'network_diagram': img_str,  # Cambiado de 'relations_graph' a 'network_diagram'
            'analysis_type': 'semantic'
        }
        result = analysis_collection.insert_one(analysis_document)
        logger.info(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
        logger.info(f"Longitud de la imagen guardada: {len(img_str)}")
        return True
    except Exception as e:
        logger.error(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
        return False

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

def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
    try:
        # Crear una nueva figura combinada
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))

        # Añadir la primera imagen con título
        ax1.imshow(graph1.get_figure().canvas.renderer.buffer_rgba())
        ax1.set_title("Documento Patrón: Relaciones semánticas relevantes")
        ax1.axis('off')

        # Añadir la segunda imagen con título
        ax2.imshow(graph2.get_figure().canvas.renderer.buffer_rgba())
        ax2.set_title("Documento Comparado con el documento patrón: Relaciones semánticas relevantes")
        ax2.axis('off')

        # Ajustar el diseño
        plt.tight_layout()

        # Convertir la figura combinada a una imagen base64
        buf = io.BytesIO()
        fig.savefig(buf, format='png')
        buf.seek(0)
        img_str = base64.b64encode(buf.getvalue()).decode('utf-8')

        # Cerrar las figuras para liberar memoria
        plt.close(fig)
        plt.close(graph1.get_figure())
        plt.close(graph2.get_figure())

        analysis_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'text1': text1,
            'text2': text2,
            'combined_graph': img_str,
            'analysis_type': 'discourse'
        }

        result = analysis_collection.insert_one(analysis_document)

        logger.info(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
        return True
    except Exception as e:
        logger.error(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
        return False

###############################################################################################################
def store_chat_history(username, messages):
    try:
        logger.info(f"Attempting to save chat history for user: {username}")
        logger.debug(f"Messages to save: {messages}")
        
        chat_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'messages': messages
        }
        result = chat_collection.insert_one(chat_document)
        logger.info(f"Chat history saved with ID: {result.inserted_id} for user: {username}")
        logger.debug(f"Chat content: {messages}")
        return True
    except Exception as e:
        logger.error(f"Error saving chat history for user {username}: {str(e)}")
        return False

#######################################################################################################
def get_student_data(username):
    if analysis_collection is None or chat_collection is None:
        logger.error("La conexión a MongoDB no está inicializada")
        return None

    formatted_data = {
        "username": username,
        "entries": [],
        "entries_count": 0,
        "word_count": {},
        "semantic_analyses": [],
        "discourse_analyses": [],
        "chat_history": []
    }

    try:
        logger.info(f"Buscando datos de análisis para el usuario: {username}")
        cursor = analysis_collection.find({"username": username})
        
        for entry in cursor:
            formatted_entry = {
                "timestamp": entry.get("timestamp", datetime.utcnow()),
                "text": entry.get("text", ""),
                "analysis_type": entry.get("analysis_type", "morphosyntax")
            }
            
            if formatted_entry["analysis_type"] == "morphosyntax":
                formatted_entry.update({
                    "word_count": entry.get("word_count", {}),
                    "arc_diagrams": entry.get("arc_diagrams", [])
                })
                for category, count in formatted_entry["word_count"].items():
                    formatted_data["word_count"][category] = formatted_data["word_count"].get(category, 0) + count
            
            elif formatted_entry["analysis_type"] == "semantic":
                formatted_entry["network_diagram"] = entry.get("network_diagram", "")
                formatted_data["semantic_analyses"].append(formatted_entry)
            
            elif formatted_entry["analysis_type"] == "discourse":
                formatted_entry.update({
                    "text1": entry.get("text1", ""),
                    "text2": entry.get("text2", ""),
                    "combined_graph": entry.get("combined_graph", "")
                })
                formatted_data["discourse_analyses"].append(formatted_entry)
            
            formatted_data["entries"].append(formatted_entry)
        
        formatted_data["entries_count"] = len(formatted_data["entries"])
        formatted_data["entries"].sort(key=lambda x: x["timestamp"], reverse=True)
        
        for entry in formatted_data["entries"]:
            entry["timestamp"] = entry["timestamp"].isoformat()
    
    except Exception as e:
        logger.error(f"Error al obtener datos de análisis del estudiante {username}: {str(e)}")
    
    try:
        logger.info(f"Buscando historial de chat para el usuario: {username}")
        chat_cursor = chat_collection.find({"username": username})
        for chat in chat_cursor:
            formatted_chat = {
                "timestamp": chat["timestamp"].isoformat(),
                "messages": chat["messages"]
            }
            formatted_data["chat_history"].append(formatted_chat)
        
        formatted_data["chat_history"].sort(key=lambda x: x["timestamp"], reverse=True)
    
    except Exception as e:
        logger.error(f"Error al obtener historial de chat del estudiante {username}: {str(e)}")

    logger.info(f"Datos formateados para {username}: {formatted_data}")
    return formatted_data