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

logger = logging.getLogger(__name__)

def get_user(username, role=None):
    user_container, _, _ = get_sql_containers()
    try:
        query = f"SELECT * FROM c WHERE c.id = '{username}'"
        if role:
            query += f" AND c.role = '{role}'"
        items = list(user_container.query_items(query=query, 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):
    user_container, _, _ = get_sql_containers()
    try:
        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
        user_data = {
            'id': username,
            'password': hashed_password,
            'role': role,
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'additional_info': additional_info or {}
        }
        user_container.create_item(body=user_data)
        logger.info(f"Usuario {role} creado: {username}")
        return True
    except Exception as e:
        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)

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 update_student_user(username, new_info):
    user_container, _, _ = get_sql_containers()
    try:
        user = get_student_user(username)
        if user:
            user['additional_info'].update(new_info)
            user_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):
    user_container, _, _ = get_sql_containers()
    try:
        user = get_student_user(username)
        if user:
            user_container.delete_item(item=user['id'], partition_key=username)
            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):
    _, application_requests_container, _ = get_sql_containers()
    try:
        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()
        }
        application_requests_container.create_item(body=application_request)
        logger.info(f"Solicitud de aplicación almacenada para el email: {email}")
        return True
    except Exception as e:
        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
        return False

def store_student_feedback(username, name, email, feedback):
    _, _, user_feedback_container = get_sql_containers()
    try:
        feedback_item = {
            "id": str(uuid.uuid4()),
            "username": username,
            "name": name,
            "email": email,
            "feedback": feedback,
            "role": "Estudiante",
            'timestamp': datetime.now(timezone.utc).isoformat(),
        }
        result = user_feedback_container.create_item(body=feedback_item)
        logger.info(f"Feedback de estudiante almacenado con ID: {result['id']} para el usuario: {username}")
        return True
    except Exception as e:
        logger.error(f"Error al almacenar el feedback del estudiante {username}: {str(e)}")
        return False