modules/auth/auth.py

import gradio as gr
import os
from azure.cosmos import CosmosClient, exceptions
import bcrypt
import base64
import logging
from datetime import datetime, timezone
from ..database.sql_db import (
    get_user,
    get_student_user,
    create_student_user,
    update_student_user,
    delete_student_user,
    record_login,
    record_logout
)

logger = logging.getLogger(__name__)

# Verificar las variables de entorno
COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
COSMOS_KEY = os.getenv("COSMOS_KEY")

if not COSMOS_ENDPOINT or not COSMOS_KEY:
    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY no están configuradas.")

# Inicializar el cliente de Cosmos DB
def clean_and_validate_key(key):
    """Limpia y valida la clave de CosmosDB"""
    key = key.strip()
    while len(key) % 4 != 0:
        key += '='
    try:
        base64.b64decode(key)
        return key
    except Exception:
        raise ValueError("La clave proporcionada no es válida")

COSMOS_KEY = clean_and_validate_key(COSMOS_KEY)
cosmos_client = CosmosClient(COSMOS_ENDPOINT, COSMOS_KEY)

########################################
# Funciones de autenticación
########################################

def authenticate_user(username: str, password: str) -> tuple[bool, str | None]:
    """
    Autentica un usuario utilizando la base de datos.
    Args:
        username (str): Nombre de usuario.
        password (str): Contraseña.
    Returns:
        tuple: (True, role) si la autenticación es exitosa; (False, None) en caso contrario.
    """
    try:
        user = get_user(username)
        if user and verify_password(user["password"], password):
            logger.info(f"Usuario autenticado: {username}, Rol: {user['role']}")
            return True, user["role"]
        logger.warning(f"Credenciales incorrectas para el usuario: {username}")
        return False, None
    except Exception as e:
        logger.error(f"Error autenticando al usuario {username}: {str(e)}")
        return False, None

def register_student(username: str, password: str, additional_info=None) -> bool:
    """
    Registra un nuevo estudiante en la base de datos.
    Args:
        username (str): Nombre de usuario.
        password (str): Contraseña.
        additional_info (dict): Información adicional del estudiante.
    Returns:
        bool: True si el registro es exitoso, False en caso contrario.
    """
    try:
        if get_student_user(username):
            logger.warning(f"El estudiante {username} ya existe.")
            return False

        hashed_password = hash_password(password)
        additional_info = additional_info or {}
        additional_info["role"] = "Estudiante"

        create_student_user(username, hashed_password, additional_info)
        logger.info(f"Estudiante registrado: {username}")
        return True
    except Exception as e:
        logger.error(f"Error registrando al estudiante {username}: {str(e)}")
        return False

########################################
# Funciones para manejo de contraseñas
########################################

def hash_password(password: str) -> str:
    """
    Hashea una contraseña utilizando bcrypt.
    Args:
        password (str): Contraseña en texto plano.
    Returns:
        str: Contraseña hasheada.
    """
    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")

def verify_password(stored_password: str, provided_password: str) -> bool:
    """
    Verifica que una contraseña coincida con su hash.
    Args:
        stored_password (str): Contraseña almacenada (hash).
        provided_password (str): Contraseña proporcionada por el usuario.
    Returns:
        bool: True si coinciden, False en caso contrario.
    """
    return bcrypt.checkpw(provided_password.encode("utf-8"), stored_password.encode("utf-8"))

########################################
# Interfaz de autenticación
########################################

def create_auth_interface():
    """
    Crea la interfaz de autenticación utilizando Gradio.
    Returns:
        gr.Blocks: Interfaz Gradio para el login.
    """
    with gr.Blocks() as auth_interface:
        gr.Markdown("# Login")
        username = gr.Textbox(label="Usuario")
        password = gr.Textbox(label="Contraseña", type="password")
        login_btn = gr.Button("Iniciar Sesión")
        message = gr.Markdown()

        def handle_login(user, pwd):
            success, role = authenticate_user(user, pwd)
            if success:
                return f"Bienvenido, {user} ({role})"
            return "Credenciales incorrectas."

        login_btn.click(fn=handle_login, inputs=[username, password], outputs=message)
    return auth_interface

########################################
# Página de usuario
########################################

def create_user_page():
    """
    Crea una página de usuario para mostrar información básica tras el login.
    Returns:
        gr.Blocks: Interfaz Gradio para la página del usuario.
    """
    with gr.Blocks() as user_page:
        gr.Markdown("# Bienvenido a la User Page")
        gr.Markdown("Esta página está disponible solo después de un inicio de sesión exitoso.")

        username = gr.Textbox(label="Usuario", interactive=False)
        role = gr.Textbox(label="Rol", interactive=False)

        def load_user_info():
            # Aquí puedes utilizar un sistema de gestión de sesión (Gradio no tiene uno nativo)
            return "UsuarioPrueba", "Estudiante"

        user_page.load(fn=load_user_info, inputs=[], outputs=[username, role])

        gr.Button("Cerrar Sesión").click(
            fn=lambda: "Sesión cerrada",
            inputs=[],
            outputs=[user_page]
        )
    return user_page

########################################
# Exportar funciones relevantes
########################################

__all__ = [
    "create_auth_interface",
    "create_user_page",
    "register_student",
    "hash_password",
    "verify_password",
    "authenticate_user"
]