"""
core.py

Created by Kang Zhang on 2009-07-09
"""
import os
import ConfigParser
import imp
import sys

from keyring import logger
from keyring import backend

def set_keyring(keyring):
    """Set current keyring backend.
    """
    global _keyring_backend
    if isinstance(keyring, backend.KeyringBackend):
        _keyring_backend = keyring
    else: raise TypeError("The keyring must be a subclass of KeyringBackend")

def get_keyring():
    """Get current keyring backend.
    """
    return _keyring_backend

def get_password(service_name, username):
    """Get password from the specified service
    """
    return _keyring_backend.get_password(service_name, username)

def set_password(service_name, username, password):
    """Set password for the user in the spcified service
    """
    _keyring_backend.set_password(service_name, username, password)

def init_backend():
    """first try to load the keyring in the config file, if it has not
    been decleared, assign a defult keyring according to the platform.
    """
    #select a backend according to the config file
    keyring = load_config()

    # if the user dose not specify a keyring, we apply a default one
    if keyring is None:

        keyrings = backend.get_all_keyring()
        # rank according the supported
        keyrings.sort(lambda x, y: y.supported() - x.supported())
        # get the most recommend one
        keyring = keyrings[0]

    set_keyring(keyring)


def load_keyring(keyring_path, keyring_name):
    """Load the specified keyring name from the specified path

    `keyring_path` can be None and it will not interfer with the loading
    process.
    """

    def load_module(name, path):
        """Load the specified module from the disk.
        """
        path_list = name.split('.')
        module_info = imp.find_module(path_list[0], path)
        module_file, pathname, description = module_info
        module = imp.load_module(path_list[0], module_file,
                                 pathname, description)

        if module_file:
            module_file.close()

        if len(path_list) > 1:
            # for the class name containing dots
            sub_name = '.'.join(path_list[1:])
            sub_path = path

            try:
                sub_path = path + module.__path__
            except AttributeError:
                return module

            return load_module(sub_name, sub_path)
        return module

    try:
        # avoid import the imported modules
        module = sys.modules[keyring_name[:keyring_name.rfind('.')]]
    except KeyError:
        module = load_module(keyring_name, sys.path+[keyring_path])

    keyring_class = keyring_name.split('.')[-1].strip()
    exec  "keyring_temp = module." + keyring_class + "() " in locals()

    return keyring_temp


def load_config():
    """load a keyring using the config file, the config file can be
    in the current working directory, or in the user's home directory.
    """
    keyring = None

    # search from current working directory and the home folder
    keyring_cfg_list = [os.path.join(os.getcwd(), "keyringrc.cfg"),
                        os.path.join(os.path.expanduser("~"), "keyringrc.cfg")]
    # initial the keyring_cfg with the fist detected config file
    keyring_cfg = None
    for path in keyring_cfg_list:
        keyring_cfg = path
        if os.path.exists(path):
            break

    if os.path.exists(keyring_cfg):
        config = ConfigParser.RawConfigParser()
        config.read(keyring_cfg)
        # load the keyring-path option
        try:
            if config.has_section("backend"):
                keyring_path = config.get("backend", "keyring-path").strip()
            else:
                keyring_path = None
        except ConfigParser.NoOptionError:
            keyring_path = None

        # load the keyring class name, and load it
        try:
            if config.has_section("backend"):
                keyring_name = config.get("backend", "default-keyring").strip()
            else:
                raise ConfigParser.NoOptionError('backend', 'default-keyring')

            keyring = load_keyring(keyring_path, keyring_name)
        except (ConfigParser.NoOptionError, ImportError):
            logger.warning("Keyring Config file does not write correctly.\n" + \
                           "Config file: %s" % keyring_cfg)

    return keyring

# init the _keyring_backend
init_backend()