#!/usr/bin/env python3

"""Ask the sanctuary to call a child's parent.

A quick action, not an application. The panel launches this, it puts one
small card on the screen, and it goes away again. Everything it knows
about the church end comes from the Parent Call coordinator's own MQTT
contract; see classroom_parent_call for the contract itself.

Why this is a separate process, and not a Plasma applet:

    the panel is the only way a teacher has of getting anywhere, and a
    broker library, a network timeout and a text entry have no business
    living inside it. If this crashes, the bar is untouched and clicking
    the button again starts a new one.

Two rules it will not bend:

    * a teacher is never told a call succeeded unless the coordinator
      said so, and the strongest thing the coordinator ever says is
      "Sent to sanctuary" — never "displayed";
    * nothing is published until the status topic for that request is
      already subscribed, so an answer cannot arrive before anyone is
      listening.
"""

import os
import sys
import threading
import time

import gi

gi.require_version("Gtk", "3.0")
# Gdk has to be pinned too. Without it PyGObject warns that it may load a
# different major version than Gtk, and the key constants this file
# compares against would then be somebody else's.
gi.require_version("Gdk", "3.0")

from gi.repository import Gdk, GLib, Gtk  # noqa: E402

# Where the card sits on the screen.
#
# A Wayland client cannot place its own window, and the card used to be
# centred because KWin centres everything. On a classroom television that
# puts it in the middle of whatever the room is watching, a long way from
# the button that opened it. Layer shell is the compositor's own answer:
# the surface is anchored to an edge and the compositor does the
# arithmetic, so bottom-left is bottom-left at 1080p and at 4K, at 100%
# and at 200%, with no coordinates written down anywhere.
#
# The classroom already draws the disc player's cover and control bar
# this way under KWin, so the mechanism is one this room has run for
# months rather than a new dependency.
#
# Optional on purpose. If the library is missing the card still opens,
# centred, exactly as it did before: a teacher can always reach it.
try:
    gi.require_version("GtkLayerShell", "0.1")
    from gi.repository import GtkLayerShell  # noqa: E402
except (ImportError, ValueError):
    GtkLayerShell = None

# Logical pixels, so they mean the same thing at every scale.
#
# The bar is 76 logical pixels tall and reserves that space, so the
# compositor already keeps a bottom-anchored surface clear of it; this
# gap is the breathing room above it. The left margin lines the card up
# near the launcher that opened it rather than hard against the edge.
CARD_GAP_BOTTOM = 16
CARD_GAP_LEFT = 16

sys.path.insert(0, "/usr/local/lib/ekklesia-classroom")
sys.path.insert(
    0,
    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "lib"),
)

import classroom_parent_call as contract  # noqa: E402
from classroom_config import read_device_config  # noqa: E402
from classroom_mqtt import room_name  # noqa: E402

APP_ID = "classroom-parent-call"

# How long to wait for the broker before telling the teacher the church
# network cannot be reached. Short: a teacher standing at the machine
# would rather be told quickly than watch a spinner.
CONNECT_TIMEOUT = 5.0

# Retained topics arrive immediately after subscribing, or never. This is
# how long "never" takes to establish.
RETAINED_GRACE = 1.5

# The coordinator answers a request almost at once. Silence for this long
# means it did not hear us, which is not the same as a refusal and is not
# reported as one.
FIRST_STATUS_TIMEOUT = 8.0

# Once it has answered, it may legitimately take as long as its own
# request expiry to finish — an operator has to approve. Its REQUEST_TTL
# is 180s; this is that with room to spare.
OVERALL_TIMEOUT = 210.0

# Long enough for a teacher to read "Sent to sanctuary" and walk away.
CLOSE_AFTER_SUCCESS = 4.0


def load_colours():
    """The session's own palette, read from the colour scheme in use.

    There is one set of design tokens in this classroom, and they live in
    a Plasma colour scheme. Reading them here rather than repeating them
    means this card follows classroom-theme light and dark without
    knowing that either exists.
    """
    palette = {
        "window": "#141c20", "view": "#0f171a", "text": "#e6edef",
        "dim": "#93a5aa", "accent": "#4fb3a8", "on_accent": "#0e1518",
        "negative": "#e36a6a", "neutral": "#e0b15c", "positive": "#6fcf97",
        "line": "#25333a",
    }

    scheme = "EkklesiaDark"

    for path in (
        os.path.expanduser("~/.config/kdeglobals"),
        "/etc/ekklesia-classroom/xdg/kdeglobals",
        "/etc/xdg/kdeglobals",
    ):
        try:
            with open(path, "r", encoding="utf-8") as handle:
                section = None
                for line in handle:
                    line = line.strip()
                    if line.startswith("["):
                        section = line
                    elif section and section.startswith("[General]") and \
                            line.startswith("ColorScheme="):
                        scheme = line.split("=", 1)[1].strip()
                        break
        except OSError:
            continue
        else:
            if scheme:
                break

    def rgb(value):
        parts = [part.strip() for part in value.split(",")]
        if len(parts) != 3:
            return None
        try:
            return "#%02x%02x%02x" % tuple(int(part) for part in parts)
        except ValueError:
            return None

    try:
        with open(f"/usr/share/color-schemes/{scheme}.colors", "r",
                  encoding="utf-8") as handle:
            group = None
            for line in handle:
                line = line.strip()
                if line.startswith("["):
                    group = line
                    continue
                if "=" not in line or group is None:
                    continue
                key, value = (part.strip() for part in line.split("=", 1))
                colour = rgb(value)
                if colour is None:
                    continue
                if group == "[Colors:Window]":
                    if key == "BackgroundNormal":
                        palette["window"] = colour
                    elif key == "ForegroundNormal":
                        palette["text"] = colour
                    elif key == "ForegroundInactive":
                        palette["dim"] = colour
                    elif key == "ForegroundNegative":
                        palette["negative"] = colour
                    elif key == "ForegroundNeutral":
                        palette["neutral"] = colour
                    elif key == "ForegroundPositive":
                        palette["positive"] = colour
                    elif key == "BackgroundAlternate":
                        palette["line"] = colour
                elif group == "[Colors:View]" and key == "BackgroundNormal":
                    palette["view"] = colour
                elif group == "[Colors:Selection]":
                    if key == "BackgroundNormal":
                        palette["accent"] = colour
                    elif key == "ForegroundNormal":
                        palette["on_accent"] = colour
    except OSError:
        pass

    return palette


STYLE = """
* {{ font-family: "Noto Sans", "DejaVu Sans", sans-serif; }}

/* The card draws its own corners, so the window behind it is nothing at
   all. Rounding a window any other way would mean asking the compositor
   for something, and this one is ours to draw. */
window {{ background-color: transparent; }}

#card {{
    background-color: {window};
    border: 1px solid {line};
    border-radius: 12px;
    padding: 24px 26px 20px 26px;
    margin: 10px;
}}

#title    {{ color: {text}; font-size: 17px; font-weight: 600; }}
#room     {{ color: {accent}; font-size: 13px; font-weight: 600;
             letter-spacing: 0.06em; }}
#hint     {{ color: {dim}; font-size: 12px; }}
#status   {{ color: {text}; font-size: 15px; font-weight: 600; }}
#detail   {{ color: {dim}; font-size: 12px; }}
#child    {{ color: {dim}; font-size: 13px; }}

#status.good     {{ color: {positive}; }}
#status.bad      {{ color: {negative}; }}
#status.waiting  {{ color: {neutral}; }}

entry {{
    background-color: {view};
    color: {text};
    border: 1px solid {line};
    border-radius: 8px;
    padding: 10px 12px;
    font-size: 16px;
    caret-color: {accent};
}}
entry:focus {{ border-color: {accent}; }}
entry:disabled {{ color: {dim}; }}

button {{
    border-radius: 8px;
    padding: 9px 18px;
    font-size: 14px;
    font-weight: 600;
    border: 1px solid {line};
    background-image: none;
    background-color: transparent;
    color: {text};
}}
button:hover {{ background-color: {line}; }}

button#primary {{
    background-color: {accent};
    color: {on_accent};
    border-color: {accent};
}}
/* Disabled has to read as "not yet", not as a broken button: the accent
   drains out of it rather than the whole thing fading. */
button#primary:disabled {{
    background-color: transparent;
    color: {dim};
    border-color: {line};
}}
"""


class Broker(threading.Thread):
    """The MQTT half, kept off the interface thread.

    Every callback hands its result to GTK with GLib.idle_add and touches
    no widget itself.
    """

    def __init__(self, config, topics, on_event):
        super().__init__(daemon=True)
        self.config = config
        self.topics = topics
        self.on_event = on_event
        self.client = None
        self.request_id = None
        self._pending = None
        self._lock = threading.Lock()

    # -- lifecycle -----------------------------------------------------

    def run(self):
        try:
            import paho.mqtt.client as mqtt
        except ImportError:
            self.emit("broker", reachable=False, why="no broker library")
            return

        host = (self.config.get("MQTT_HOST") or "").strip()

        if not host or (self.config.get("MQTT_ENABLED") or "").strip().lower() \
                not in ("1", "true", "yes", "on"):
            self.emit("broker", reachable=False, why="not configured")
            return

        try:
            port = int((self.config.get("MQTT_PORT") or "1883").strip())
        except ValueError:
            port = 1883

        # A clean session on purpose. Nothing from a previous connection
        # may be redelivered: a parent call from last Sunday arriving now
        # would be worse than one that was lost.
        try:
            client = mqtt.Client(
                mqtt.CallbackAPIVersion.VERSION2,
                client_id=f"classroom-parent-call-{os.getpid()}",
                clean_session=True,
            )
        except (AttributeError, TypeError):
            client = mqtt.Client(
                client_id=f"classroom-parent-call-{os.getpid()}",
                clean_session=True,
            )

        username = (self.config.get("MQTT_USERNAME") or "").strip()

        if username:
            client.username_pw_set(
                username, (self.config.get("MQTT_PASSWORD") or "").strip() or None
            )

        client.on_connect = self._connected
        client.on_message = self._message
        client.on_disconnect = self._disconnected

        self.client = client

        try:
            client.connect(host, port, keepalive=30)
        except (OSError, ValueError) as error:
            self.emit("broker", reachable=False, why=str(error))
            return

        client.loop_forever(retry_first_connection=False)

    def stop(self):
        client = self.client

        if client is not None:
            try:
                client.disconnect()
            except Exception:
                pass

    # -- callbacks -----------------------------------------------------

    def _connected(self, client, userdata, flags, reason_code, properties=None):
        if getattr(reason_code, "is_failure", False) or \
                (isinstance(reason_code, int) and reason_code != 0):
            self.emit("broker", reachable=False, why=f"refused ({reason_code})")
            return

        client.subscribe([(self.topics.mode, 1), (self.topics.coordinator, 1)])
        self.emit("broker", reachable=True)

    def _disconnected(self, client, userdata, *args):
        self.emit("disconnected")

    def _message(self, client, userdata, message):
        if message.topic == self.topics.mode:
            self.emit("mode", mode=contract.read_mode(message.payload))
        elif message.topic == self.topics.coordinator:
            self.emit("coordinator",
                      online=contract.read_coordinator(message.payload))
        elif self.request_id and message.topic == self.topics.status(self.request_id):
            update = contract.read_status(message.payload, self.request_id)

            if update:
                self.emit("status", update=update)

    # -- sending -------------------------------------------------------

    def send(self, request_id, room, child):
        """Subscribe first, publish second. Never the other way round."""
        client = self.client

        if client is None:
            self.emit("send-failed", why="not connected")
            return

        with self._lock:
            self.request_id = request_id

        body = contract.request_payload(request_id, room, child)

        import json

        def after_subscribe(_client, _userdata, _mid, _codes, _properties=None):
            # QoS 1 so the coordinator's answer is not lost on a flaky
            # link, and never retained: a request is an event.
            client.publish(self.topics.request, json.dumps(body), qos=1,
                           retain=False)
            self.emit("published")

        client.on_subscribe = after_subscribe
        client.subscribe(self.topics.status(request_id), qos=1)

    def emit(self, kind, **data):
        GLib.idle_add(self.on_event, kind, data)


class ParentCall(Gtk.Window):
    def __init__(self):
        super().__init__(title="Parent Call")

        self.config = read_device_config()
        self.room = room_name(self.config)
        self.topics = contract.Topics(
            (self.config.get("PARENT_CALL_ROOT") or contract.DEFAULT_ROOT).strip()
        )

        self.mode = None
        self.coordinator_online = False
        self.broker_reachable = None
        self.request_id = None
        self.sent_at = None
        self.settled = False
        self.autosend = False
        self._timers = []

        self.set_decorated(False)
        self.set_titlebar(Gtk.Box())
        self.set_resizable(False)
        self.set_default_size(460, -1)
        self._anchor_bottom_left()
        self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
        # Belt and braces with the window rule: whichever of the two KWin
        # honours, the card must not end up behind the lesson a teacher
        # was reading when they pressed the button.
        self.set_keep_above(True)

        screen = self.get_screen()
        visual = screen.get_rgba_visual()

        if visual is not None:
            self.set_visual(visual)

        self.set_app_paintable(True)

        self._build()
        self._apply_style()

        self.connect("key-press-event", self._key)
        self.connect("destroy", lambda *_: self._quit())

        self.broker = Broker(self.config, self.topics, self._event)
        self.broker.start()

        self._after(CONNECT_TIMEOUT, self._connect_deadline)

    # -- interface -----------------------------------------------------

    def _build(self):
        card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        card.set_name("card")

        heading = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        title = Gtk.Label(label="Parent Call", xalign=0)
        title.set_name("title")
        heading.pack_start(title, False, False, 0)

        # The room is stated, never asked. This machine already knows
        # which room it is, and a teacher picking it from a list is a
        # chance to pick the wrong one.
        room = Gtk.Label(label=self.room.upper(), xalign=0)
        room.set_name("room")
        room.set_valign(Gtk.Align.CENTER)
        heading.pack_end(room, False, False, 0)
        card.pack_start(heading, False, False, 0)

        self.hint = Gtk.Label(
            label="Who should we call a parent for?", xalign=0)
        self.hint.set_name("hint")
        card.pack_start(self.hint, False, False, 0)

        self.entry = Gtk.Entry()
        self.entry.set_placeholder_text("Child's name")
        self.entry.set_max_length(contract.MAX_CHILD)
        self.entry.set_sensitive(False)
        self.entry.connect("activate", lambda *_: self._send())
        self.entry.connect("changed", lambda *_: self._refresh_button())
        card.pack_start(self.entry, False, False, 0)

        self.status = Gtk.Label(label="", xalign=0)
        self.status.set_name("status")
        self.status.set_line_wrap(True)
        self.status.set_no_show_all(True)
        card.pack_start(self.status, False, False, 0)

        self.detail = Gtk.Label(label="", xalign=0)
        self.detail.set_name("detail")
        self.detail.set_line_wrap(True)
        self.detail.set_no_show_all(True)
        card.pack_start(self.detail, False, False, 0)

        buttons = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        buttons.set_halign(Gtk.Align.END)

        self.close_button = Gtk.Button(label="Close")
        self.close_button.connect("clicked", lambda *_: self._quit())
        buttons.pack_start(self.close_button, False, False, 0)

        self.primary = Gtk.Button(label="Call parent")
        self.primary.set_name("primary")
        self.primary.set_sensitive(False)
        self.primary.connect("clicked", lambda *_: self._send())
        buttons.pack_start(self.primary, False, False, 0)

        card.pack_start(buttons, False, False, 0)

        card.set_size_request(440, -1)
        self.add(card)
        card.show_all()
        self.entry.grab_focus()

        self._set_status("Checking with the sanctuary…", tone=None)

    def _apply_style(self):
        css = Gtk.CssProvider()
        css.load_from_data(STYLE.format(**load_colours()).encode("utf-8"))
        Gtk.StyleContext.add_provider_for_screen(
            self.get_screen(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
        )

    def _anchor_bottom_left(self):
        """Put the card in the corner its launcher is in.

        Anchored rather than positioned: the compositor is told which two
        edges to hold the surface against and works the rest out itself,
        so this is right on a 1080p television at 100% and on a 4K one at
        200% without either number appearing here.

        Keyboard interactivity is the part that matters and the part that
        has to be asked for: a teacher types a child's name into this.
        """
        if GtkLayerShell is None:
            return

        try:
            GtkLayerShell.init_for_window(self)
            # TOP, not OVERLAY. The disc player's cover is an overlay and
            # is meant to be in front of everything including this; a
            # teacher fetching a parent during a film is not a reason to
            # put a text box over the film's own controls.
            GtkLayerShell.set_layer(self, GtkLayerShell.Layer.TOP)
            GtkLayerShell.set_anchor(self, GtkLayerShell.Edge.BOTTOM, True)
            GtkLayerShell.set_anchor(self, GtkLayerShell.Edge.LEFT, True)
            GtkLayerShell.set_margin(
                self, GtkLayerShell.Edge.BOTTOM, CARD_GAP_BOTTOM)
            GtkLayerShell.set_margin(
                self, GtkLayerShell.Edge.LEFT, CARD_GAP_LEFT)
            # Reserve nothing. The card is a moment, not furniture, and a
            # surface that reserved space would push the lesson around
            # every time somebody fetched a parent.
            GtkLayerShell.set_exclusive_zone(self, 0)
            GtkLayerShell.set_keyboard_interactivity(self, True)
        except Exception as error:  # noqa: BLE001
            # Any failure here is cosmetic. A centred card a teacher can
            # type into beats a perfectly placed one that never opened.
            print(f"classroom-parent-call: layer shell unavailable: {error}",
                  file=sys.stderr)

    def _set_status(self, text, tone=None, detail=None):
        style = self.status.get_style_context()

        for name in ("good", "bad", "waiting"):
            style.remove_class(name)

        if tone:
            style.add_class(tone)

        self.status.set_text(text or "")
        self.status.set_visible(bool(text))

        self.detail.set_text(detail or "")
        self.detail.set_visible(bool(detail))

    def _refresh_button(self):
        ready = (
            self.request_id is None
            and self.broker_reachable
            and contract.clean_child(self.entry.get_text()) is not None
            and contract.availability(
                self.mode, self.coordinator_online, self.broker_reachable,
                assume_default=self.settled,
            )[0]
        )
        self.primary.set_sensitive(bool(ready))

    def _unavailable(self, message):
        self.settled = True
        self.entry.set_sensitive(False)
        self.primary.hide()
        self.hint.hide()
        self.entry.hide()
        self.close_button.set_label("Close")
        self._set_status(message, tone="bad")

    # -- events --------------------------------------------------------

    def _event(self, kind, data):
        if kind == "broker":
            self.broker_reachable = data.get("reachable")

            if not self.broker_reachable:
                # Why it is not there decides who the teacher should
                # fetch, so the reason the broker thread already knows is
                # carried through to the card rather than flattened.
                self._unavailable(contract.broker_message(data.get("why")))
            else:
                self._after(RETAINED_GRACE, self._retained_deadline)

        elif kind == "mode":
            self.mode = data.get("mode")
            self._settle()

        elif kind == "coordinator":
            self.coordinator_online = bool(data.get("online"))
            self._settle()

        elif kind == "status":
            self._status_arrived(data["update"])

        elif kind == "published":
            self.sent_at = time.monotonic()
            self._after(FIRST_STATUS_TIMEOUT, self._first_status_deadline)

        elif kind == "send-failed":
            self._set_status("The call was not sent", tone="bad",
                             detail="Press Call parent to try again.")
            self.request_id = None
            self._refresh_button()

        return False

    def _settle(self, final=False):
        """Decide what to offer, once the retained topics have spoken.

        A negative is only ever reached with final=True. The mode and the
        coordinator's availability are two separate retained messages and
        they arrive in whichever order the broker sends them — deciding on
        the first one told a teacher the sanctuary was down while the
        message saying otherwise was still in flight. Measured, in the
        lab, on a coordinator that was demonstrably up.
        """
        if self.request_id is not None or self.settled:
            return

        can, why = contract.availability(
            self.mode, self.coordinator_online, self.broker_reachable,
            assume_default=final,
        )

        if can:
            self.entry.set_sensitive(True)
            self.entry.grab_focus()
            note = ("A volunteer will approve it first."
                    if self.mode == contract.MODE_APPROVAL else None)
            self._set_status("", tone=None, detail=note)
            self.settled = True
            self._refresh_button()

            if self.autosend:
                self.autosend = False
                GLib.timeout_add(300, lambda: (self._send(), False)[1])
        elif final and why:
            self._unavailable(why)

    def _status_arrived(self, update):
        self._set_status(
            update["message"],
            tone=("good" if update["good"]
                  else "bad" if update["terminal"]
                  else "waiting"),
            detail=update.get("detail"),
        )

        if not update["terminal"]:
            return

        # Terminal: stop listening, as the coordinator's contract asks.
        self.broker.request_id = None

        if update["good"]:
            self.close_button.hide()
            self._after(CLOSE_AFTER_SUCCESS, self._quit)
        else:
            self.request_id = None
            self.entry.set_sensitive(True)
            self.entry.show()
            self.hint.hide()
            self.primary.set_label("Try again")
            self.primary.show()
            self._refresh_button()

    # -- sending -------------------------------------------------------

    def _send(self):
        if self.request_id is not None:
            return

        child = contract.clean_child(self.entry.get_text())

        if child is None:
            self._set_status("Enter the child's name", tone="bad")
            return

        # The teacher is pressing the button, so the retained topics have
        # long since had their chance.
        can, why = contract.availability(
            self.mode, self.coordinator_online, self.broker_reachable,
            assume_default=True,
        )

        if not can:
            self._unavailable(why or contract.WORDING[contract.UNAVAILABLE])
            return

        self.request_id = contract.new_request_id(self.room)
        self.entry.set_sensitive(False)
        self.primary.set_sensitive(False)
        self.primary.hide()
        self.hint.set_text(f"Calling a parent for {child}")
        self.hint.show()
        self._set_status("Sending", tone="waiting")

        self.broker.send(self.request_id, self.room, child)
        self._after(OVERALL_TIMEOUT, self._overall_deadline)

    # -- deadlines -----------------------------------------------------

    def _after(self, seconds, callback):
        self._timers.append(GLib.timeout_add(int(seconds * 1000), callback))

    def _connect_deadline(self):
        if self.broker_reachable is None:
            self._unavailable("Cannot reach the church network")
        return False

    def _retained_deadline(self):
        # Retained topics arrive at once or not at all. Now that both have
        # had their chance, a negative is safe to show, and a mode nobody
        # has ever set is the coordinator's default rather than a room
        # that was never configured.
        self._settle(final=True)

        if not self.settled:
            # Only reachable if nothing at all came back from the
            # sanctuary end, which the wording should say rather than
            # blaming this room's setup.
            self._unavailable("No answer from the sanctuary")

        return False

    def _first_status_deadline(self):
        if self.request_id is not None and self.status.get_text() == "Sending":
            # Silence is not a refusal, and is not reported as one.
            self._set_status("No answer from the sanctuary", tone="bad",
                             detail="The call was not confirmed. "
                                    "Press Try again, or ask for help.")
            self.request_id = None
            self.entry.set_sensitive(True)
            self.primary.set_label("Try again")
            self.primary.show()
            self._refresh_button()
        return False

    def _overall_deadline(self):
        if self.request_id is not None:
            self._set_status("No answer from the sanctuary", tone="bad",
                             detail="The call was not confirmed.")
            self.request_id = None
            self.primary.set_label("Try again")
            self.primary.show()
            self._refresh_button()
        return False

    # -- leaving -------------------------------------------------------

    def _key(self, _widget, event):
        """Escape leaves. Nothing else does.

        Deliberately narrow: an earlier version compared against a Gdk
        that had not been version-pinned, and in the lab an ordinary
        letter closed the card.
        """
        if event.keyval == Gdk.KEY_Escape and not event.state & (
            Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD1_MASK
        ):
            self._quit()
            return True

        return False

    def _quit(self, *_):
        for timer in self._timers:
            GLib.source_remove(timer)
        self._timers = []

        self.broker.stop()
        Gtk.main_quit()
        return False


def main():
    GLib.set_prgname(APP_ID)
    GLib.set_application_name("Parent Call")

    # --child fills the name in, and --send presses the button once the
    # sanctuary has answered for whether it may be pressed. Only the lab
    # uses them: there is no teacher-facing path to either, and neither
    # can send a call the coordinator would not have accepted anyway.
    child = None
    autosend = "--send" in sys.argv

    if "--child" in sys.argv:
        index = sys.argv.index("--child") + 1
        if index < len(sys.argv):
            child = sys.argv[index]

    window = ParentCall()

    if child:
        window.entry.set_text(child)

    if autosend:
        window.autosend = True

    window.show()

    Gtk.main()
    return 0


if __name__ == "__main__":
    sys.exit(main())
