# 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):
    """Obtiene un usuario por su username"""
    container = get_container("users")
    try:
        query = f"SELECT * FROM c WHERE c.id = @username"
        params = [{"name": "@username", "value": username}]
        
        if role:
            query += " AND c.role = @role"
            params.append({"name": "@role", "value": role})
            
        items = list(container.query_items(
            query=query,
            parameters=params,
            enable_cross_partition_query=True
        ))
        
        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_student_user(username):
    return get_user(username, role='Estudiante')


#########################################
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:
        # Verificar que no exista el usuario
        existing_user = get_user(username)
        if existing_user:
            logger.warning(f"Usuario {username} ya existe")
            return False

        # Crear documento del usuario
        user_data = {
            'id': username,
            'password': password,  # Ya viene hasheado de auth.py
            'role': role,
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'additional_info': additional_info or {}
        }
        
        # Crear el item sin referenciar partition key
        result = container.create_item(
            body=user_data,
            enable_cross_partition_query=True
        )
        
        if result:
            logger.info(f"Usuario {role} creado exitosamente: {username}")
            return True
        else:
            logger.error(f"No se pudo crear el usuario {username}")
            return False
            
    except Exception as e:
        logger.error(f"Error al crear usuario {role} {username}: {str(e)}")
        return False

#########################################
def create_student_user(username, password, additional_info=None):
    """Crea un nuevo usuario estudiante"""
    # Verificar que la contraseña esté hasheada
    if not password.startswith('$2b$'):
        logger.error("Intento de crear usuario con contraseña no hasheada")
        return False
        
    return create_user(username, password, 'Estudiante', additional_info)

#########################################
def create_teacher_user(username, password, additional_info=None):
    return create_user(username, password, 'Profesor', additional_info)

#########################################
def create_admin_user(username, password, additional_info=None):
    return create_user(username, password, 'Administrador', additional_info)

#########################################
def record_login(username):
    """Registra el inicio de sesión de un usuario"""
    try:
        container = get_container("users_sessions")
        if not container:
            logger.error("No se pudo obtener el contenedor users_sessions")
            return None

        session_id = str(uuid.uuid4())
        session_doc = {
            "id": session_id,
            "type": "session",
            "username": username,
            "loginTime": datetime.now(timezone.utc).isoformat(),
            "additional_info": {},
            "partitionKey": username
        }

        result = container.create_item(body=session_doc)
        logger.info(f"Sesión {session_id} registrada para {username}")
        return session_id
    except Exception as e:
        logger.error(f"Error registrando login: {str(e)}")
        return None

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

def record_logout(username, session_id):
    """Registra el cierre de sesión y calcula la duración"""
    try:
        container = get_container("users_sessions")
        if not container:
            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},
            {"name": "@username", "value": username}
        ]
        
        # Agregar enable_cross_partition_query=True
        items = list(container.query_items(
            query=query,
            parameters=params,
            enable_cross_partition_query=True
        ))

        if not items:
            logger.warning(f"Sesión no encontrada: {session_id}")
            return False

        session = items[0]
        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
        logout_time = datetime.now(timezone.utc)
        duration = int((logout_time - login_time).total_seconds())

        session.update({
            "logoutTime": logout_time.isoformat(),
            "sessionDuration": duration
        })

        container.upsert_item(body=session)
        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
        return True
    except Exception as e:
        logger.error(f"Error registrando logout: {str(e)}")
        return False

#########################################
def get_recent_sessions(limit=10):
    """Obtiene las sesiones más recientes"""
    try:
        container = get_container("users_sessions")
        if not container:
            logger.error("No se pudo obtener el contenedor users_sessions")
            return []

        query = """
        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
        FROM c
        WHERE c.type = 'session'
        ORDER BY c.loginTime DESC
        OFFSET 0 LIMIT @limit
        """
        
        # Agregar enable_cross_partition_query=True
        sessions = list(container.query_items(
            query=query,
            parameters=[{"name": "@limit", "value": limit}],
            enable_cross_partition_query=True
        ))

        # Validar y limpiar los datos
        clean_sessions = []
        for session in sessions:
            try:
                clean_sessions.append({
                    "username": session["username"],
                    "loginTime": session["loginTime"],
                    "logoutTime": session.get("logoutTime", "Activo"),
                    "sessionDuration": session.get("sessionDuration", 0)
                })
            except KeyError as e:
                logger.warning(f"Sesión con datos incompletos: {e}")
                continue

        return clean_sessions
    except Exception as e:
        logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
        return []

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

def get_user_total_time(username):
    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
    try:
        container = get_container("users_sessions")
        if not container:
            return None

        query = """
        SELECT VALUE SUM(c.sessionDuration)
        FROM c
        WHERE c.type = 'session'
        AND c.username = @username
        AND IS_DEFINED(c.sessionDuration)
        """
        
        # Agregar enable_cross_partition_query=True
        result = list(container.query_items(
            query=query,
            parameters=[{"name": "@username", "value": username}],
            enable_cross_partition_query=True
        ))

        return result[0] if result and result[0] is not None else 0
    except Exception as e:
        logger.error(f"Error obteniendo tiempo total: {str(e)}")
        return 0

#########################################
def update_student_user(username, new_info):
    container = get_container("users") 
    try:
        user = get_student_user(username)
        if user:
            user['additional_info'].update(new_info)
            user['partitionKey'] = username
            container.upsert_item(body=user)
            logger.info(f"Información del estudiante actualizada: {username}")
            return True
        else:
            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
            return False
    except Exception as e:
        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
        return False

#########################################
def delete_student_user(username):
    container = get_container("users")
    try:
        user = get_student_user(username)
        if user:
            # El ID es suficiente para eliminación ya que partitionKey está en el documento
            container.delete_item(item=user['id'])
            logger.info(f"Estudiante eliminado: {username}")
            return True
        else:
            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
            return False
    except Exception as e:
        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,
            "lastname": lastname,
            "email": email,
            "institution": institution,
            "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