# -*- coding: utf-8 -*-

import os

try:

    import koji

    from koji_cli.lib import activate_session

    HAS_KOJI = True

except ImportError:

    HAS_KOJI = False

def get_profile_name(profile):

    """

    Return a koji profile name.

    :param str profile: profile name, like "koji" or "cbs", or None. If None,

                        we will use return the "KOJI_PROFILE" environment

                        variable. If we could find no profile name, raise

                        ValueError.

    :returns: str, the profile name

    """

    if profile:

        return profile

    profile = os.getenv('KOJI_PROFILE')

    if profile:

        return profile

    raise ValueError('set a profile "koji" argument for this task, or set '

                     'the KOJI_PROFILE environment variable')

def get_session(profile):

    """

    Return an anonymous koji session for this profile name.

    :param str profile: profile name, like "koji" or "cbs". If None, we will

                        use a profile name from the "KOJI_PROFILE" environment

                        variable.

    :returns: anonymous koji.ClientSession

    """

    profile = get_profile_name(profile)

    # Note, get_profile_module() raises koji.ConfigurationError if we

    # could not find this profile's name in /etc/koji.conf.d/*.conf and

    # ~/.koji/config.d/*.conf.

    mykoji = koji.get_profile_module(profile)

    # Workaround https://pagure.io/koji/issue/1022 . Koji 1.17 will not need

    # this.

    if '~' in str(mykoji.config.cert):

        mykoji.config.cert = os.path.expanduser(mykoji.config.cert)

    if '~' in str(mykoji.config.ca):

        mykoji.config.ca = os.path.expanduser(mykoji.config.ca)

    # Note, Koji has a grab_session_options() method that can also create a

    # stripped-down dict of our module's (OptParse) configuration, like:

    #   opts = mykoji.grab_session_options(mykoji.config)

    # The idea is that callers then pass that opts dict into ClientSession's

    # constructor.

    # There are two reasons we don't use that here:

    # 1. The dict is only suitable for the ClientSession(..., opts), not for

    #    activate_session(..., opts). activate_session() really wants the full

    #    set of key/values in mykoji.config.

    # 2. We may call activate_session() later outside of this method, so we

    #    need to preserve all the configuration data from mykoji.config inside

    #    the ClientSession object. We might as well just store it in the

    #    ClientSession's .opts and then pass that into activate_session().

    opts = vars(mykoji.config)

    # Force an anonymous session (noauth):

    opts['noauth'] = True

    session = mykoji.ClientSession(mykoji.config.server, opts)

    # activate_session with noauth will simply ensure that we can connect with

    # a getAPIVersion RPC. Let's avoid it here because it just slows us down.

    # activate_session(session, opts)

    return session

def ensure_logged_in(session):

    """

    Authenticate this Koji session (if necessary).

    :param session: a koji.ClientSession

    :returns: None

    """

    if not session.logged_in:

        session.opts['noauth'] = False

        # Log in ("activate") this session:

        # Note: this can raise SystemExit if there is a problem, eg with

        # Kerberos:

        activate_session(session, session.opts)

# inheritance display utils

def describe_inheritance_rule(rule):

    """

    Given a dictionary representing a koji inheritance rule (i.e., one of the

    elements of getInheritanceData()'s result), return a tuple of strings to be

    appended to a module's stdout_lines array conforming to the output of

    koji's taginfo CLI command, e.g.:

       0   .... a-parent-tag

      10   M... another-parent-tag

        maxdepth: 1

     100   .F.. yet-another-parent-tag

        package filter: ^prefix-

    """

    # koji_cli/commands.py near the end of anon_handle_taginfo()

    flags = '%s%s%s%s' % (

        'M' if rule['maxdepth'] not in ('', None) else '.',

        'F' if rule['pkg_filter'] not in ('', None) else '.',

        'I' if rule['intransitive'] else '.',

        'N' if rule['noconfig'] else '.',

    )

    result = ["%4d   %s %s" % (rule['priority'], flags, rule['name'])]

    if rule['maxdepth'] not in ('', None):

        result.append("    maxdepth: %d" % rule['maxdepth'])

    if rule['pkg_filter'] not in ('', None):

        result.append("    package filter: %s" % rule['pkg_filter'])

    return tuple(result)

def describe_inheritance(rules):

    """

    Given a sequence of dictionaries representing koji inheritance rules (i.e.,

    getInheritanceData()'s result), return a tuple of strings to be appended to

    a module's stdout_lines array conforming to the output of koji's taginfo

    CLI command. See describe_inheritance_rule for sample output.

    """

    # each invocation of describe_inheritance_rule yields a tuple of strings

    # to be appended to a module's stdout_lines result, so concatenate them:

    # sum(…, tuple()) will flatten tuples of tuples into just the child tuples

    # > sum( ((1, 2), (3, 4)), tuple() ) ⇒ (1, 2) + (3, 4) + (,) ⇒ (1, 2, 3, 4)

    return sum(tuple(map(describe_inheritance_rule, rules)), tuple())

# permission utils

perm_cache = {}

def get_perms(session):

    global perm_cache

    if not perm_cache:

        perm_cache = dict([

            (perm['name'], perm['id']) for perm in session.getAllPerms()

        ])

    return perm_cache

def get_perm_id(session, name):

    perms = get_perms(session)

    return perms[name]

def get_perm_name(session, id_):

    perms = get_perms(session)

    for perm_name, perm_id in perms.items():

        if perm_id == id_:

            return perm_name