#!/usr/bin/env python

"""PyCuerun is for lanching outline scripts to the cue."""
from __future__ import print_function


import logging
import os
import sys
import traceback
from optparse import OptionGroup

from cuerunbase import AbstractCuerun


logger = logging.getLogger("pycuerun")


def convert_sys_args_from_olrun():
    """
    Convert olrun arguments to pycuerun compatible arguments
    """
    translation_dict = {
        '-retry': '-m',
        '-jobid': '-j'
    }
    for k, v in translation_dict.items():
        if k in sys.argv:
            logger.warn('olrun params detected, converting {0} to {1}'.format(
                k, v))
            sys.argv[sys.argv.index(k)] = v


class PyCuerun(AbstractCuerun):

    usage = "usage: %prog [options] outline_script [frame range]"
    descr = "Pycuerun is a tool for launching outline jobs and frames."

    def __init__(self):
        convert_sys_args_from_olrun()
        AbstractCuerun.__init__(self)

    def add_my_options(self):

        parser = self.get_parser()

        group = OptionGroup(parser, "Frame Execution Options")
        group = parser.add_option_group(group)

        group.add_option("-e", "--execute", action="store", dest="execute",
                         metavar="FRAME_NAME",
                         help="Execute the given frame.  Example: 1-bty_all")
        group.add_option("-i", "--inspect", action="store", dest="inspect",
                         metavar="SCRIPT",
                         help="Dump some information on the given outline script.")
        group.add_option("-u", "--user", action="store", dest="user",
                         metavar="USER", help="Set the user to run as.")
        group.add_option("-j", "--jobid", action="store", dest="basename",
                         metavar="JOB_ID",
                         help="Specify the basename of the job associated with an outline.")
        group.add_option("-m", "--maxretries", action="store", dest="maxretries",
                         metavar="MAX_RETRIES",
                         help="Specify max retries for this job.")

        group = parser.get_option_group("--pause")
        group.add_option("--qc", action="store_true", dest="qc",
                         default=False,
                         help="Allow artist to QC to the job before the job leaves the cue on completion.")

    def handle_my_options(self, parser, options, args):

        from outline import cuerun, load_outline
        from outline import ShellCommandFailureException

        try:
            if options.execute:
                frame, layer = options.execute.split("-", 1)
                try:
                    cuerun.execute_frame(args[0], layer, frame)
                except ShellCommandFailureException as e:
                    sys.stderr.write("%s" % e)
                    sys.exit(e.exit_status)

            elif options.inspect:
                inspect_script(load_outline(options.inspect))
            else:
                #
                # Default operation is to launch the job
                #
                if len(args) < 1:
                    parser.print_help()
                    print("\nYou must provide an outline script to execute.")
                    sys.exit(1)
                outline = load_outline(args[0])
                if len(args) == 2:
                    parser.setup_frame_range(options, args[1])

                if options.qc:
                    from outline.modules.shell import Shell
                    bin_dir = os.path.dirname(os.path.abspath(__file__))
                    qc_path = os.path.join(bin_dir, "util_qc_job_layer.py")
                    outline.add_layer(
                        Shell("wait_on_artist_to_qc",
                              command=qc_path,
                              range="1", setshot=False, threads=0.1, memory=1,
                              require=['%s:all' % layer for layer in outline.get_layers()])
                    )

                jobs = self.launch_outline(outline, user=options.user)
                if not jobs:
                    print("No jobs were submitted, check the outline file.")
                else:
                    print("Submitted the following jobs...")
                    for job in jobs:
                        print("    {}".format(job.data.name))

        except Exception as e:
            sys.stderr.write("cuerun failure, %s" % e)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)


def inspect_script(outline):
    """
    Dump some information on the given outline script.
    """
    print("%s" % outline.get_full_name())
    for layer in outline.get_layers():
        print(" + %s" % layer.get_name())
        for key, val in layer.get_args().items():
            print("   - %s = %s" % (key, val))


if __name__ == '__main__':
    PyCuerun().go()
