#!/usr/bin/env python

"""Launch and terminate Timeflux instances on both POSIX and Windows systems.

Sometimes, it's okay to kill. But only if you do it gracefully, and give your victim a chance to say goodbye
to his or her children and let them commit suicide (again, with grace) upon hearing such news.

On POSIX systems, it's easy: just launch your process normally and terminate it by sending a SIGINT signal.

On Windows, well, that's another story. SIGINT can't be captured, and the only way is to send a CTRL+C event.
Any other signal (except CTRL+BREAK) will terminate without notice. Simple enough, you might say. Not quite.
It just happens that CTRL events can only be captured by processes attached to the current console. Which is
pretty useless in most cases. But do not abandon all hope! Here is a (hacky) solution: have a launcher script
that will start a simple TCP server and run your program. When a client connect to the server, it will send a
CTRL+C event to its subprocess.

Use this helper as a script or invoke with: ``python -m timeflux.helpers.handler [cmd] [args]``.

Example:
    Launching a Timeflux instance: ``python -m timeflux.helpers.handler launch timeflux -d foobar.yaml``

Example:
    Terminating a Timeflux instance gracefully: ``python -m timeflux.helpers.handler terminate``

Example:
    Running Timeflux from a batch script:

    .. code-block:: batch

       @echo off
       set ROOT=C:\\Users\\%USERNAME%\\Miniconda3
       call %ROOT%\\Scripts\\activate.bat %ROOT%
       call conda activate timeflux
       start python -m timeflux.helpers.handler launch timeflux -d foobar.yaml
       pause
       call python -m timeflux.helpers.handler terminate

References:
    * `Python issue 26350 <https://bugs.python.org/issue26350#msg260201>`_


"""

import sys
import subprocess
import signal
import os
import subprocess
import socket


def launch_posix(args):
    """Launch a subprocess and exit."""
    try:
        subprocess.Popen(args)
    except:
        _exit_with_error(f"Invalid arguments: {args}")


def launch_windows(args, port=10000):
    """Launch a subprocess and await connection to a TCP server."""
    try:
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.setblocking(False)
        server.bind(("localhost", port))
        server.listen(1)
    except:
        _exit_with_error(f"Could not start server on port {port}.")
    try:
        # flags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
        flags = subprocess.HIGH_PRIORITY_CLASS
        process = subprocess.Popen(args, creationflags=flags)
    except:
        _exit_with_error(f"Invalid arguments: {args}")
    while True:
        try:
            # Kill the process if a connection is received
            server.accept()
            process.send_signal(signal.CTRL_C_EVENT)
            break
        except BlockingIOError:
            try:
                # Exit the loop is the process is already dead
                process.wait(0.1)
                break
            except subprocess.TimeoutExpired:
                pass


def terminate_posix(match="timeflux"):
    """Find oldest Timeflux process and terminate it."""
    try:
        pid = int(subprocess.check_output(["pgrep", "-of", match]))
        print(f"Sending INT signal to PID {pid}.")
        os.kill(pid, signal.SIGINT)
    except:
        _exit_with_error("No running instance found.")


def terminate_windows(port=10000):
    """Terminate the Timeflux process by connecting to the TCP server."""
    client = socket.socket()
    try:
        client.connect(("localhost", port))
        client.close()
    except:
        _exit_with_error("No running instance found.")


def _exit_with_error(message):
    print(message)
    sys.exit(1)


if __name__ == "__main__":
    if len(sys.argv) == 1:
        sys.exit()
    if sys.argv[1] == "launch":
        args = sys.argv[2:]
        if sys.platform == "win32":
            try:
                port = int(sys.argv[2])
                args = args[1:]
            except ValueError:
                port = None
            launch_windows(args, port)
        else:
            launch_posix(args)
    if sys.argv[1] == "terminate":
        arg = sys.argv[2] if len(sys.argv) >= 3 else None
        if sys.platform == "win32":
            terminate_windows(arg)
        else:
            terminate_posix(arg)
