from __future__ import (print_function)
import time
from universal_extension import UniversalExtension
from universal_extension import ExtensionResult
from universal_extension import logger
from universal_extension import ui
from universal_extension.deco import dynamic_choice_command
from universal_extension.deco import dynamic_command


class Extension(UniversalExtension):
    """Required class that serves as the entry point for the extension
    """

    def __init__(self):
        """Initializes an instance of the 'Extension' class
        """
        # Call the base class initializer
        super(Extension, self).__init__()

    @dynamic_choice_command("primary_choice_field")
    def primary_choice_command(self, fields):
        """Dynamic choice command implementation for
        primary_choice_field.

        Parameters
        ----------
        fields : dict
            populated with the values of the dependent fields
        """
        return ExtensionResult(
            rc=0,
            message="Values for choice field: 'primary_choice_field'",
            values=["Start", "Pause", "Stop", "Build", "Destroy"]
        )

    @dynamic_choice_command("secondary_choice_field")
    def secondary_choice_command(self, fields):
        """Dynamic choice command implementation for
        secondary_choice_field.

        Parameters
        ----------
        fields : dict
            populated with the values of the dependent fields
        """
        return ExtensionResult(
            rc=0,
            message="Values for choice field: 'secondary_choice_field'",
            values=["System", "Command", "Application", "Transfer", "Evidence"]
        )

    @dynamic_command("reset_environment")
    def reset_environment(self, fields):
        """Dynamic command implementation for reset_environment command.

        Parameters
        ----------
        fields : dict
            populated with the values of the dependent fields
        """

        # Reset the state of the Output Only 'step' fields.
        out_fields = {}
        out_fields["step_1"] = "Initial"
        out_fields["step_2"] = "Initial"
        ui.update_output_fields(out_fields)

        return ExtensionResult(
            message="Message: Hello from dynamic command 'reset_environment'!",
            output=True,
            output_data='The environment has been reset.',
            output_name='DYNAMIC_OUTPUT')

    @dynamic_command("async_print_word")
    def async_print_word(self, fields):
        """
        Adds each letter of self.WORD to self.async_queue

        If curr_index is odd, then the function will sleep
        for 5 seconds before adding self.WORD to self.async_queue
        """

        curr_index = self.async_index

        if curr_index % 2 != 0:
            self.async_index += 1
            time.sleep(5)
        else:
            self.async_index += 1

        self.async_queue.append(self.WORD[curr_index])

        return ExtensionResult(
            message="",
            output=True,
            output_data="async_print_word()",
            output_name='DYNAMIC_ASYNC_OUTPUT')

    @dynamic_command("sync_print_word")
    def sync_print_word(self, fields):
        """
        Adds each letter of self.WORD to self.sync_queue

        If curr_index is odd, then the function will sleep
        for 5 seconds before adding self.WORD to self.sync_queue
        """

        curr_index = self.sync_index

        if curr_index % 2 != 0:
            self.sync_index += 1
            time.sleep(5)
        else:
            self.sync_index += 1

        self.sync_queue.append(self.WORD[curr_index])

        return ExtensionResult(
            message="",
            output=True,
            output_data="sync_print_word()",
            output_name='DYNAMIC_SYNC_OUTPUT')

    def extension_start(self, fields):
        """Required method that serves as the starting point for work performed
        for a task instance.

        Parameters
        ----------
        fields : dict
            populated with field values from the associated task instance
            launched in the Controller

        Returns
        -------
        ExtensionResult
            once the work is done, an instance of ExtensionResult must be
            returned. See the documentation for a full list of parameters that
            can be passed to the ExtensionResult class constructor
        """

        # Extract the cancel_cleanup_time
        self.cancel_cleanup_time = fields.get('cancel_cleanup_time', 0)

        # Sleep for 45 seconds
        time.sleep(45)

        # Get the value of the 'action' field
        action = fields.get('action', [""])[0]

        if action.lower() == 'print':
            # Print to standard output...
            print("Hello STDOUT!")
        else:
            # Log to standard error...
            logger.info('Hello STDERR!')

        # Return the result with a payload containing a Hello message...
        return ExtensionResult(
            unv_output='Hello Extension!'
        )

    def extension_cancel(self):
        """Optional method that allows the Extension instance to perform
        any cleanup work.
        """
        logger.info('About to sleep for %d seconds' % self.cancel_cleanup_time)
        time.sleep(self.cancel_cleanup_time)
        logger.info('Done with extension_cancel()')