from auth0.authentication import GetToken
from auth0.management import Auth0

from src.cache import redis_client
from src.config.auth import Auth0ManagementConfig
from src.constants.core import AUTH0_USER_PREFIX
from src.legacy.auth.decorators import handle_auth0_too_many_requests, handle_auth0_unauthorized
from src.legacy.redis_db.keys import AUTH0_MANAGEMENT_TOKEN, AUTH0_MANAGEMENT_TOKEN_TTL, get_key


config = Auth0ManagementConfig()


class Auth0ManagementAPI:
    """Object oriented interface to Auth0 Management API.
    Provides methods for accessing and updating data and settings handled by Auth0 service.
    """

    def __init__(self):
        self.__domain = config.DOMAIN
        self.__client_id = config.CLIENT_ID
        self.__client_secret = config.CLIENT_SECRET
        self.__redis_key = get_key(AUTH0_MANAGEMENT_TOKEN, self.__client_id)

        self.__token = self._get_stored_token() or self.get_management_token()

    def set_token(self, token):
        """Token field setter.
        Arguments:
            token (str) - auth0 management api token
        """
        self.__token = token

    @handle_auth0_too_many_requests
    def get_management_token(self):
        """Retrieve bearer access token for Auth0 management API.
        Returns:
            (str): bearer token
        """
        redis_client.delete(self.__redis_key)
        get_token_obj = GetToken(self.__domain)
        response_data = get_token_obj.client_credentials(
            self.__client_id, self.__client_secret, "https://{}/api/v2/".format(self.__domain)
        )
        token = response_data["access_token"]
        self._store_token_in_redis(token)
        self.__auth0 = Auth0(self.__domain, token)

        return token

    @handle_auth0_too_many_requests
    @handle_auth0_unauthorized
    def get_user_metadata(self, user_id):
        """Retrieve Auth0 user_metadata for a specific user.
        Arguments:
            user_id (str): user identifier
        Returns:
            dict: Auth0 user user_metadata
        """
        user_id = self.check_user_id(user_id)
        user_data = self.__auth0.users.get(user_id)
        result = user_data["user_metadata"]

        return result

    @handle_auth0_too_many_requests
    @handle_auth0_unauthorized
    def update_user_metadata(self, user_id, new_metadata):
        """Update Auth0 user_metadata field for a specific user.
        Arguments:
            user_id (str): user identifier
            new_metadata (dict): metadata that will be set to Auth0
        Returns:
            dict: updated Auth0 user user_metadata
        """
        user_id = self.check_user_id(user_id)
        update_data = {"user_metadata": new_metadata}
        modified_user = self.__auth0.users.update(user_id, update_data)

        return modified_user["user_metadata"]

    def check_user_id(self, user_id):
        """Append 'auth0|' prefix to user id.
        Arguments:
            user_id (str): user identifier
        Returns:
            str: updated with a required prefix user id
        """
        if user_id and user_id.startswith(AUTH0_USER_PREFIX):
            return user_id

        return f"{AUTH0_USER_PREFIX}{user_id}"

    def _get_stored_token(self):
        """Retrieve saved in redis auth0 management token.
        Returns:
            (str or None): auth0 management api token
        """
        token = redis_client.get(self.__redis_key)
        self.__auth0 = Auth0(self.__domain, token)

        return token

    def _store_token_in_redis(self, token):
        """Save auth0 management api token in redis
        Arguments:
            token (str): auth0 management api token
        """
        redis_client.setex(self.__redis_key, AUTH0_MANAGEMENT_TOKEN_TTL, token)