"""CLI functions to run decider, worker and exec processes."""

import argparse
import json
import logging
import time

import boto.swf.layer2 as swf
from garcon import activity
from garcon import decider

from accounting import flows
from accounting.util import cli as cli_util


def execute_flow(flow, context, **kwargs):
    """Launch the workflow execution.

    Args:
        flow (module): garcon flow module
        context (str): initial context parsed from json
        kwargs: extensible call api
    Returns:
        boto.swf.layer2.WorkflowExecution: context
        variables to be passed along in the workflow
    """
    start_kwargs = dict(
        workflow_id=flow.workflow_id(json.loads(context)),
        input=context)

    if hasattr(flow, 'timeout'):
        start_kwargs.update(execution_start_to_close_timeout=str(flow.timeout))

    if cli_util.check_required_params(flow, context) is False:
        print(
            'Missing required param(s): {}'.format(
                ', '.join(flow.required_params)))
        print(
            'Available params are: {}'.format(
                ', '.join(flow.available_params)))
        return

    return swf.WorkflowType(
        name=flow.name,
        domain=flow.domain,
        version=flow.version,
        task_list=flow.name).start(**start_kwargs)


def run_decider(flow, **kwargs):
    """Launch the SWF decider process.

    Args:
        flow (module): garcon flow module
        kwargs: extensible call api
    """
    worker = decider.DeciderWorker(flow)
    while True:
        worker.run()
        time.sleep(1)


def run_activity_worker(flow, **kwargs):
    """Launch the activity worker process.

    Args:
        flow (module): garcon flow module
        kwargs: extensible call api
    """
    worker = activity.ActivityWorker(flow)
    worker.run()


_COMMANDS = {'exec': execute_flow,
             'decider': run_decider,
             'worker': run_activity_worker}


def garcon(*args):
    """Integrate main entry point for the Garcon command line.

    Args:
        args (tuple): Args for the flow.
    """
    parser = argparse.ArgumentParser(description='Garcon command line util')
    parser.add_argument('cmd', choices=_COMMANDS.keys(),
                        help='garcon command')
    parser.add_argument('flow', choices=flows.__all__,
                        help='name of the flow')
    parser.add_argument('-c', '--context',
                        help='initial context [json]')
    parser.add_argument('-l', '--log_level',
                        help='logging level', default='error',
                        choices=['critical', 'error', 'warning', 'info',
                                 'debug'])

    # parse cl args (allows easy unit testing)
    args = parser.parse_args(args) if args else parser.parse_args()

    # execute command
    args.context = args.context or '{}'
    logging.basicConfig(level=getattr(logging, args.log_level.upper()))
    _COMMANDS[args.cmd](flow=flows.get_flow(args.flow),
                        context=args.context)