#modules/database/sql_db.py

from .database_init import get_container
from datetime import datetime, timezone
import logging
import bcrypt
import uuid

logger = logging.getLogger(__name__)

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

def get_user(username, role=None):
    container = get_container("users")
    try:
        if role:
            query += f" AND c.role = '{role}'"
        items = list(container.query_items(
            query=query  # Removido enable_cross_partition_query

        ))
        return items[0] if items else None
    except Exception as e:
        logger.error(f"Error al obtener usuario {username}: {str(e)}")
        return None

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


def get_admin_user(username):
    return get_user(username, role='Administrador')

def get_teacher_user(username):
    return get_user(username, role='Profesor')






def create_user(username, password, role, additional_info=None):
    """Crea un nuevo usuario"""
    container = get_container("users")
    if not container:
        logger.error("No se pudo obtener el contenedor de usuarios")
        return False
        
    try:




        user_data = {
            'id': username,
            'password': password,

            'role': role,
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'additional_info': additional_info or {}


        }
        
        container.create_item(
            body=user_data,
            partition_key=username
        )
        logger.info(f"Usuario {role} creado: {username}")
        return True
        
        logger.error(f"Error al crear usuario {role}: {str(e)}")
        return False


def create_student_user(username, password, additional_info=None):
    return create_user(username, password, 'Estudiante', additional_info)

            "username": username,
            "loginTime": datetime.now(timezone.utc).isoformat(),
            "additional_info": {},

            "partitionKey": username
        }


        result = container.create_item(
            body=session_doc  # Solo el body

        )
        logger.info(f"Sesión {session_id} registrada para {username}")
        return session_id
        logger.error(f"Error registrando login: {str(e)}")
        return None


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

def record_logout(username, session_id):
            logger.error("No se pudo obtener el contenedor users_sessions")
            return False


        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
        params = [
            {"name": "@id", "value": session_id},
        
        items = list(container.query_items(
            query=query,
            parameters=params  # Removido enable_cross_partition_query

        ))

        if not items:

        session.update({
            "logoutTime": logout_time.isoformat(),
            "sessionDuration": duration,
            "partitionKey": username  # Asegurar que partitionKey esté presente
        })


        container.upsert_item(
            body=session  # Solo el body
        )
        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
        return True
        
        sessions = list(container.query_items(
            query=query,
            parameters=[{"name": "@limit", "value": limit}]  # Removido enable_cross_partition_query

        ))


        clean_sessions = []
        for session in sessions:
            try:
        
        result = list(container.query_items(
            query=query,
            parameters=[{"name": "@username", "value": username}]  # Removido enable_cross_partition_query

        ))

        return result[0] if result and result[0] is not None else 0
        return False


#########################################################
def delete_student_user(username):
    user_container, _, _ = get_sql_containers()
    try:
        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
        return False



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

def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
    """Almacena una solicitud de aplicación"""
    try:
        # Obtener el contenedor usando get_container() que sí funciona
        container = get_container("application_requests")
        if not container:
            logger.error("No se pudo obtener el contenedor de solicitudes")
            return False

        # Crear documento con la solicitud
        # Nótese que incluimos email como partition key en el cuerpo del documento
        application_request = {
            "id": str(uuid.uuid4()),
            "name": name,
            "current_role": current_role,
            "desired_role": desired_role,
            "reason": reason,
            "requestDate": datetime.utcnow().isoformat(),
            # El campo para partition key debe estar en el documento
            "partitionKey": email
        }
        
        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
        container.create_item(
            body=application_request  # Solo pasamos el body
        )
        logger.info(f"Solicitud de aplicación almacenada para: {email}")
        return True
        
    except Exception as e:
        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
        logger.error(f"Detalles del error: {str(e)}")
        return False

############################################################
def store_student_feedback(username, name, email, feedback):
    """Almacena el feedback de un estudiante"""
    try:
        # Obtener el contenedor - verificar disponibilidad
        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
        container = get_container("user_feedback")
        if not container:
            logger.error("No se pudo obtener el contenedor user_feedback")
            return False

        # Crear documento de feedback - asegurar que el username esté como partition key
        feedback_item = {
            "id": str(uuid.uuid4()),
            "username": username,  # Campo regular
            "name": name,
            "email": email,
            "feedback": feedback,
            "role": "Estudiante",
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "partitionKey": username  # Campo de partición
        }

        # Crear el item - sin el parámetro enable_cross_partition_query
        logger.info(f"Intentando almacenar feedback para usuario: {username}")
        result = container.create_item(
            body=feedback_item  # Solo el body, no parámetros adicionales
        )
        
        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
        return True

    except Exception as e:
        logger.error(f"Error al almacenar el feedback del estudiante {username}")
        logger.error(f"Detalles del error: {str(e)}")
        return False