import uuid

from cachelib.simple import SimpleCache
from secrets_manager.python_ext import PythonSecretsManager

from daemonJwtHandler import config
from daemonJwtHandler.constants import auth
from daemonJwtHandler.loggly import get_current_logger
from daemonJwtHandler.logic import jwt_expiry
from daemonJwtHandler.utils import jwt_refresh


class JwtServices(object):

    __instance = None
    simpleInstance = None

    @classmethod
    def getInstance(cls):
        if not cls.__instance:
            cls.__instance = JwtServices()
            cls.simpleInstance = SimpleCache()
        return cls.__instance

    def getJwtEnabledServices(self):
        try:
            secrets_manager_client = self.get_secret_manager_client()
            secrets = secrets_manager_client.get_cred(
                auth.JWT_ENABLED_SERVICES_SECRET_KEY)
            return secrets
        except Exception as e:
            log = self.logger()
            log.info(
                f'JwtEnabledServices: '
                f'Exception: {e}')
            raise e

    def get_secret(self, secrets_manager_client, secret_name):
        return secrets_manager_client.get_cred(secret_name)

    def get_jwt(self):
        try:
            secrets_manager_client = self.get_secret_manager_client()
            return {
                auth.JWT_SECRET_KEY: self.get_secret(
                    secrets_manager_client, auth.JWT_SECRET_KEY),
                auth.JWT_EXPIRY_SECRET_KEY: self.get_secret(
                    secrets_manager_client, auth.JWT_EXPIRY_SECRET_KEY)
            }
        except Exception as e:
            log = self.logger()
            log.info(
                f'Failed to fetch jwt secrets for '
                f'qa Exception: {str(e)}')
            return {}

    def enableCaching(self, appname):
        if config.ENVIRONMENT != config.ENVIRONMENT_DEV:
            jwt_refresh.ThreadingAsynch(appname)

    def cacheJwtToken(self):
        cache_expiration = {}
        jwt_token = self.get_jwt()
        token_expiration_time = jwt_token.get(
            auth.JWT_EXPIRY_SECRET_KEY, None)
        if token_expiration_time is not None:
            cache_expiration = jwt_expiry.get_jwt_cache_expiry(
                token_expiration_time)
        expiration_in_secs = cache_expiration.get('jwt_expiry_secs', -1)
        self.setCache(auth.JWT_SECRET_KEY, jwt_token.get(
            auth.JWT_SECRET_KEY, None), expiration_in_secs)
        self.setCache('jwt_expiration_time', cache_expiration.get(
            'jwt_expiration_time', None), expiration_in_secs)

    def cacheEnableList(self):
        jwt_enabled_list = self.getJwtEnabledServices()
        self.setCache(auth.JWT_ENABLED_SERVICES_SECRET_KEY, jwt_enabled_list, 0)  # noqa

    def setCache(self, key, secrets, ttl):
        self.simpleInstance.set(key, secrets, ttl)

    def isCached(self, key):
        return self.simpleInstance.has(key)

    def getCache(self, key):
        return self.simpleInstance.get(key)

    def get_secret_manager_client(self):
        return PythonSecretsManager(
            application_context=False, environment=config.ENVIRONMENT,
            service_name=auth.JWT_SERVICE_NAME)

    def logger(self):
        correlation_id = str(uuid.uuid1())
        return get_current_logger(correlation_id)