#!/usr/bin/python

import sys

from ansible.module_utils.basic import AnsibleModule

from ansible.module_utils import common_koji

ANSIBLE_METADATA = {

    'metadata_version': '1.0',

    'status': ['preview'],

    'supported_by': 'community'

}

DOCUMENTATION = '''

---

module: koji_cg

short_description: Create and manage Koji content generators

description:

   - This module can grant or revoke access to a `content generator

     <https://docs.pagure.org/koji/content_generators/>`_ for a user account.

   - Your Koji Hub must be version 1.19 or newer in order to use the new

     `listCGs <https://pagure.io/koji/pull-request/1160>`_ RPC.

options:

   name:

     description:

       - The name of the Koji content generator.

       - 'Example: "debian".'

     required: true

   user:

     description:

       - The name of the Koji user account.

       - This user account must already exist in Koji's database. For example,

         you may run an authenticated "koji hello" command to create the

         account database entry.

       - 'Example: "cguser".'

     required: true

requirements:

  - "python >= 2.7"

  - "koji"

'''

EXAMPLES = '''

- name: Grant a user access to a content generator.

  hosts: localhost

  tasks:

    - name: Grant access to the rcm/debbuild account

      koji_cg:

        name: debian

        user: rcm/debbuild

        state: present

'''

RETURN = ''' # '''

class UnknownCGsError(Exception):

    """ We cannot know what CGs are present """

    pass

def list_cgs(session):

    """ Return the result of listCGs, or raise UnknownCGsError """

    koji_profile = sys.modules[session.__module__]

    try:

        return session.listCGs()

    except koji_profile.GenericError as e:

        if str(e) == 'Invalid method: listCGs':

            # Kojihub before version 1.20 will raise this error.

            raise UnknownCGsError

        raise

def ensure_cg(session, user, name, state, cgs, check_mode):

    """

    Ensure that a content generator and user is present or absent.

    :param session: koji ClientSession

    :param str user: koji user name

    :param str name: content generator name

    :param str state: "present" or "absent"

    :param dict cgs: existing content generators and users

    :param bool check_mode: if True, show what would happen, but don't do it.

    :returns: result

    """

    result = {'changed': False}

    if state == 'present':

        if name not in cgs or user not in cgs[name]['users']:

            if not check_mode:

                common_koji.ensure_logged_in(session)

                session.grantCGAccess(user, name, create=True)

            result['changed'] = True

    elif state == 'absent':

        if name in cgs and user in cgs[name]['users']:

            if not check_mode:

                common_koji.ensure_logged_in(session)

                session.revokeCGAccess(user, name)

            result['changed'] = True

    return result

def ensure_unknown_cg(session, user, name, state):

    """

    Ensure that a content generator and user is present or absent.

    This method is for older versions of Koji where we do not have the listCGs

    RPC. This method does not support check_mode.

    :param session: koji ClientSession

    :param str user: koji user name

    :param str name: content generator name

    :param str state: "present" or "absent"

    :returns: result

    """

    result = {'changed': False}

    koji_profile = sys.modules[session.__module__]

    common_koji.ensure_logged_in(session)

    if state == 'present':

        # The "grant" method will at least raise an error if the permission

        # was already granted, so we can set the "changed" result based on

        # that.

        try:

            session.grantCGAccess(user, name, create=True)

            result['changed'] = True

        except koji_profile.GenericError as e:

            if 'User already has access to content generator' not in str(e):

                raise

    elif state == 'absent':

        # There's no indication whether this changed anything, so we're going

        # to be pessimistic and say we're always changing it.

        session.revokeCGAccess(user, name)

        result['changed'] = True

    return result

def run_module():

    module_args = dict(

        koji=dict(type='str', required=False),

        name=dict(type='str', required=True),

        user=dict(type='str', required=True),

        state=dict(type='str', choices=[

                   'present', 'absent'], required=False, default='present'),

    )

    module = AnsibleModule(

        argument_spec=module_args,

        supports_check_mode=True

    )

    if not common_koji.HAS_KOJI:

        module.fail_json(msg='koji is required for this module')

    check_mode = module.check_mode

    params = module.params

    profile = params['koji']

    name = params['name']

    user = params['user']

    state = params['state']

    session = common_koji.get_session(profile)

    try:

        cgs = list_cgs(session)

        result = ensure_cg(session, user, name, state, cgs, check_mode)

    except UnknownCGsError:

        if check_mode:

            msg = 'check mode does not work without listCGs'

            result = {'changed': False, 'msg': msg}

        else:

            result = ensure_unknown_cg(session, user, name, state)

    module.exit_json(**result)

def main():

    run_module()

if __name__ == '__main__':

    main()