import subprocess, threading

# The ManagedProcess class encapsulates the run and cancel functions and streams logs internally.
class ManagedProcess:
    @staticmethod
    def _stream_logs(stream, logger, prefix):
        # iter() reads until "" or EOF
        for line in iter(stream.readline, ""):
            logger(f"{prefix}{line.rstrip()}")
        stream.close()

    @staticmethod
    def run(js7Step, cmd):
        if not cmd:
            raise ValueError("No command specified: 'cmd' must be a non-empty list")

        process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            bufsize=1
        )

        js7Step.setCancelableResource(process)

        # Defines the thread for live stdout
        stdout_thread = threading.Thread(
            target=ManagedProcess._stream_logs,
            args=(process.stdout, js7Step.getLogger().info, "[LIVE STDOUT] "),
            daemon=False
        )

        # Defines the thread for live stderr
        stderr_thread = threading.Thread(
            target=ManagedProcess._stream_logs,
            args=(process.stderr, js7Step.getLogger().error, "[LIVE STDERR] "),
            daemon=False
        )
        
        # Starts threads to read stdout and stderr streams
        stdout_thread.start()
        stderr_thread.start()      

        # Waits until the process is finish
        rc = process.wait()
        
        # Ensures threads have finished reading
        stdout_thread.join()
        stderr_thread.join()

        return rc

    @staticmethod
    def cancel(js7Step):
        if js7Step is None:
            return
        
        # Gets the cancelable resource
        process = js7Step.getCancelableResource()
        if process is None:
            return
        
        # Kills the subprocess if it is still running
        try:
            if process.poll() is None:
                js7Step.getLogger().info(f"[ManagedProcess.cancel][kill]{process}...")
                process.kill()
        except Exception as e:
            js7Step.getLogger().error(f"[ManagedProcess.cancel][{process}]{e}")

        return process.wait()

import os, shlex

##!include Python-ManagedProcessClass
class JS7Job(js7.Job):
    # Splits an argument string into a list, using Windows or POSIX shell rules depending on the platform
    @staticmethod
    def _split_args(arg_string):
        if os.name == "nt":
            return shlex.split(arg_string, posix=False)
        return shlex.split(arg_string, posix=True)
          
    def processOrder(self, js7Step):
        # Reads the workflow arguments
        executable_path = js7Step.getAllArgumentsAsNameValueMap().get("executable_path") # e. g. '/usr/bin/python3', '/bin/sh'
        script_path = js7Step.getAllArgumentsAsNameValueMap().get("script_path") # e. g. '/home/user/script.py', '/script.sh'
        arguments = js7Step.getAllArgumentsAsNameValueMap().get("arguments") # e. g. 'my_arg_1 my_arg_2'
        script_arguments = js7Step.getAllArgumentsAsNameValueMap().get("script_arguments") # e. g. 'my_arg_1 my_arg_2'
        
        # Creates the base command
        if executable_path:
            cmd = [executable_path]
        else:
            raise ValueError("No executable_path specified.")
            
        # Adds arguments that will be passed to the executable
        if arguments and arguments != "empty":
            cmd += self._split_args(arguments)

        if script_path and script_path != "empty":
            cmd.append(script_path)
            # Adds arguments that will be passed to the script
            if script_arguments and script_arguments != "empty":
                cmd += self._split_args(script_arguments)

        # Executes the process
        returncode = ManagedProcess.run(js7Step, cmd)
        js7Step.getLogger().info(f"[ManagedProcess]returncode={returncode}")
        js7Step.getOutcome().setReturnCode(returncode)

    # Uses the onProcessOrderCanceled() hook after the order has been canceled
    def onProcessOrderCanceled(self, js7Step):
        ManagedProcess.cancel(js7Step)