# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
This file is a stdout callback plugin for the OpenShift Quick
Installer. The purpose of this callback plugin is to reduce the amount
of produced output for customers and enable simpler progress checking.

What's different:

* Playbook progress is expressed as: Play <current_play>/<total_plays> (Play Name)
  Ex: Play 3/30 (Initialize Megafrobber)

* The Tasks and Handlers in each play (and included roles) are printed
  as a series of .'s following the play progress line.

"""

from __future__ import (absolute_import, print_function)
import imp
import os
import sys

ANSIBLE_PATH = imp.find_module('ansible')[1]
DEFAULT_PATH = os.path.join(ANSIBLE_PATH, 'plugins/callback/default.py')
DEFAULT_MODULE = imp.load_source(
    'ansible.plugins.callback.default',
    DEFAULT_PATH
)

try:
    from ansible.plugins.callback import CallbackBase
    BASECLASS = CallbackBase
except ImportError:  # < ansible 2.1
    BASECLASS = DEFAULT_MODULE.CallbackModule

from ansible import constants as C

reload(sys)
sys.setdefaultencoding('utf-8')


class CallbackModule(DEFAULT_MODULE.CallbackModule):

    """
    Ansible callback plugin
    """
    CALLBACK_VERSION = 2.2
    CALLBACK_TYPE = 'stdout'
    CALLBACK_NAME = 'openshift_quick_installer'
    CALLBACK_NEEDS_WHITELIST = False
    plays_count = 0
    plays_total_ran = 0

    def banner(self, msg, color=None):
        '''
        Prints a header-looking line with stars taking up to 80 columns
        of width (3 columns, minimum)
        '''
        msg = msg.strip()
        star_len = (79 - len(msg))
        if star_len < 0:
            star_len = 3
        stars = "*" * star_len
        self._display.display("\n%s %s" % (msg, stars), color=color, log_only=True)

    def v2_playbook_on_start(self, playbook):
        """This is basically the start of it all"""
        self.plays_count = len(playbook.get_plays())
        self.plays_total_ran = 0

        if self._display.verbosity > 1:
            from os.path import basename
            self.banner("PLAYBOOK: %s" % basename(playbook._file_name))

    def v2_playbook_on_play_start(self, play):
        """Each play calls this once before running any tasks

We could print the number of tasks here as well by using
`play.get_tasks()` but that is not accurate when a play includes a
role. Only the tasks directly assigned to a play are directly exposed
in the `play` object.

        """
        self.plays_total_ran += 1
        print("")
        print("Play %s/%s (%s)" % (self.plays_total_ran, self.plays_count, play.get_name()))

        name = play.get_name().strip()
        if not name:
            msg = "PLAY"
        else:
            msg = "PLAY [%s]" % name

        self.banner(msg)

    # pylint: disable=unused-argument,no-self-use
    def v2_playbook_on_task_start(self, task, is_conditional):
        """This prints out the task header. For example:

TASK [openshift_facts : Ensure PyYaml is installed] ***...

Rather than print out all that for every task, we print a dot
character to indicate a task has been started.
        """
        sys.stdout.write('.')

        args = ''
        # args can be specified as no_log in several places: in the task or in
        # the argument spec.  We can check whether the task is no_log but the
        # argument spec can't be because that is only run on the target
        # machine and we haven't run it thereyet at this time.
        #
        # So we give people a config option to affect display of the args so
        # that they can secure this if they feel that their stdout is insecure
        # (shoulder surfing, logging stdout straight to a file, etc).
        if not task.no_log and C.DISPLAY_ARGS_TO_STDOUT:
            args = ', '.join(('%s=%s' % a for a in task.args.items()))
            args = ' %s' % args
        self.banner("TASK [%s%s]" % (task.get_name().strip(), args))
        if self._display.verbosity >= 2:
            path = task.get_path()
            if path:
                self._display.display("task path: %s" % path, color=C.COLOR_DEBUG, log_only=True)

    # pylint: disable=unused-argument,no-self-use
    def v2_playbook_on_handler_task_start(self, task):
        """Print out task header for handlers

Rather than print out a header for every handler, we print a dot
character to indicate a handler task has been started.
"""
        sys.stdout.write('.')

        self.banner("RUNNING HANDLER [%s]" % task.get_name().strip())

    # pylint: disable=unused-argument,no-self-use
    def v2_playbook_on_cleanup_task_start(self, task):
        """Print out a task header for cleanup tasks

Rather than print out a header for every handler, we print a dot
character to indicate a handler task has been started.
"""
        sys.stdout.write('.')

        self.banner("CLEANUP TASK [%s]" % task.get_name().strip())

    def v2_playbook_on_include(self, included_file):
        """Print out paths to statically included files"""
        msg = 'included: %s for %s' % (included_file._filename, ", ".join([h.name for h in included_file._hosts]))
        self._display.display(msg, color=C.COLOR_SKIP, log_only=True)

    def v2_runner_on_ok(self, result):
        """This prints out task results in a fancy format

The only thing we change here is adding `log_only=True` to the
.display() call
        """
        delegated_vars = result._result.get('_ansible_delegated_vars', None)
        self._clean_results(result._result, result._task.action)
        if result._task.action in ('include', 'include_role'):
            return
        elif result._result.get('changed', False):
            if delegated_vars:
                msg = "changed: [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
            else:
                msg = "changed: [%s]" % result._host.get_name()
            color = C.COLOR_CHANGED
        else:
            if delegated_vars:
                msg = "ok: [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
            else:
                msg = "ok: [%s]" % result._host.get_name()
            color = C.COLOR_OK

        if result._task.loop and 'results' in result._result:
            self._process_items(result)
        else:

            if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
                msg += " => %s" % (self._dump_results(result._result),)
            self._display.display(msg, color=color, log_only=True)

        self._handle_warnings(result._result)

    def v2_runner_item_on_ok(self, result):
        """Print out task results for you're iterating"""
        delegated_vars = result._result.get('_ansible_delegated_vars', None)
        if result._task.action in ('include', 'include_role'):
            return
        elif result._result.get('changed', False):
            msg = 'changed'
            color = C.COLOR_CHANGED
        else:
            msg = 'ok'
            color = C.COLOR_OK

        if delegated_vars:
            msg += ": [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
        else:
            msg += ": [%s]" % result._host.get_name()

        msg += " => (item=%s)" % (self._get_item(result._result),)

        if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
            msg += " => %s" % self._dump_results(result._result)
        self._display.display(msg, color=color, log_only=True)

    def v2_runner_item_on_skipped(self, result):
        """Print out task results when an item is skipped"""
        if C.DISPLAY_SKIPPED_HOSTS:
            msg = "skipping: [%s] => (item=%s) " % (result._host.get_name(), self._get_item(result._result))
            if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
                msg += " => %s" % self._dump_results(result._result)
            self._display.display(msg, color=C.COLOR_SKIP, log_only=True)

    def v2_runner_on_skipped(self, result):
        """Print out task results when a task (or something else?) is skipped"""
        if C.DISPLAY_SKIPPED_HOSTS:
            if result._task.loop and 'results' in result._result:
                self._process_items(result)
            else:
                msg = "skipping: [%s]" % result._host.get_name()
                if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
                    msg += " => %s" % self._dump_results(result._result)
                self._display.display(msg, color=C.COLOR_SKIP, log_only=True)

    def v2_playbook_on_notify(self, res, handler):
        """What happens when a task result is 'changed' and the task has a
'notify' list attached.
        """
        self._display.display("skipping: no hosts matched", color=C.COLOR_SKIP, log_only=True)