import os
from os.path import exists
import logger
from importlib.metadata import version

keyring = None
keyring_warn = False

logger.DEBUG = True

try:
    if os.getenv('BIT_USE_KEYRING', 'true') == 'true' and os.geteuid() != 0:
        import keyring
    logger.debug("keyring version: " + version("keyring"))
    keyring_config_file = keyring.util.platform_.config_root()
    logger.debug("keyring config file location: " + keyring_config_file)
    logger.debug("keyring config file exists: " + str(exists(keyring_config_file)))
except:
#    keyring = None
    os.putenv('BIT_USE_KEYRING', 'false')
    keyring_warn = True

from time import sleep


def keyringSupported():
    # if keyring is None:
    #     logger.debug('No keyring due to import error.')
    #     return False

    # Observation (on some systems):
    # If I call "get_keyring()" here the backend metaclasses are available
    # keyring.get_keyring()

    backends = []

    # Create a list of installed backends that BiT supports.
    # This is done by trying to put the meta classes ("class definitions",
    # NOT instances of the class itself!) of the supported backends
    # into the "backends" list
    try: backends.append(keyring.backends.SecretService.Keyring)
    except Exception as e: logger.debug("Metaclass keyring.backends.SecretService.Keyring not found: " + repr(e))
    try: backends.append(keyring.backends.Gnome.Keyring)
    except Exception as e: logger.debug("Metaclass keyring.backends.Gnome.Keyring not found: " + repr(e))
    try: backends.append(keyring.backends.kwallet.Keyring)
    except Exception as e: logger.debug("Metaclass keyring.backends.kwallet.Keyring not found: " + repr(e))
    try: backends.append(keyring.backends.kwallet.DBusKeyring)
    except Exception as e: logger.debug("Metaclass keyring.backends.kwallet.DBusKeyring not found: " + repr(e))
    try: backends.append(keyring.backend.SecretServiceKeyring)
    except Exception as e: logger.debug("Metaclass keyring.backend.SecretServiceKeyring not found: " + repr(e))
    try: backends.append(keyring.backend.GnomeKeyring)
    except Exception as e: logger.debug("Metaclass keyring.backend.GnomeKeyring not found: " + repr(e))
    try: backends.append(keyring.backend.KDEKWallet)
    except Exception as e: logger.debug("Metaclass keyring.backend.KDEKWallet not found: " + repr(e))
    # TODO (07.10.2022): Why is the ChainerBackend not (yet) supported?
    #                    It could solve the problem of configuring the
    #                    used backend since it iterates over all of them!
    # See: https://github.com/jaraco/keyring/blob/977ed03677bb0602b91f005461ef3dddf01a49f6/keyring/backends/chainer.py#L11
    # try: backends.append(keyring.backends.chainer.ChainerBackend)
    # except Exception as e: logger.debug("Metaclass keyring.backend. not found:" + repr(e))

    # Determine the currently active backend
    try:
        displayName = keyring.get_keyring().__module__
    except:
        displayName = str(keyring.get_keyring())

    logger.debug("Available supported backends: " + repr(backends))

    if backends and isinstance(keyring.get_keyring(), tuple(backends)):
        logger.debug("Found appropriate keyring '{}'".format(displayName))
        return True
    logger.debug("No appropriate keyring found. '{}' can't be used with BackInTime".format(displayName))
    return False


def __logKeyringWarning():
    # from time import sleep
    sleep(0.1)
    print('import keyring failed')


if __name__ == '__main__':
    print("First call of keyringSupported()")
    keyringSupported()
    print("Second call of keyringSupported()")
    keyringSupported()

#    if keyring is None and keyring_warn:
    if keyring_warn:
        #delay warning to give logger some time to import
        from threading import Thread
        thread = Thread(target = __logKeyringWarning, args = ())
        thread.start()