# idjcmonitor.py (C) 2013-2023 Stephen Fairchild
# Released under the GNU Lesser General Public License version 2.0 (or
# at your option, any later version).

"""A middleware facilitator for IDJC aimed towards station admin tasks.

Requires IDJC 0.8.9 or higher.

Example usage: http://idjc.sourceforge.net/code_idjcmon.html
"""

import os
import sys
import time

from gi.repository import GObject
import dbus
from dbus.mainloop.glib import DBusGMainLoop


__all__ = ["IDJCMonitor"]


BUS_BASENAME = "net.sf.idjc"
OBJ_BASENAME = "/net/sf/idjc"


def pid_exists(pid):
    """Check whether pid exists in the current process table."""

    if pid < 0:
        return False
    try:
        os.kill(pid, 0)
    except OSError as e:
        return e.errno == os.errno.EPERM
    else:
        return True


class IDJCMonitor(GObject.Object):
    """Monitor IDJC internals relating to a specific profile or session.

    Can yield information about streams, music metadata, health.
    example usage: http://idjc.sourceforge.net/code_idjcmon.html
    """

    __gsignals__ = {
        'launch': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                    (GObject.TYPE_STRING, GObject.TYPE_UINT)),
        'quit': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                  (GObject.TYPE_STRING, GObject.TYPE_UINT)),
        'focus-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                    (GObject.TYPE_STRING, GObject.TYPE_BOOLEAN)),
        'entry-mode-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                    (GObject.TYPE_BOOLEAN,)),
        'stream-silence-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                    (GObject.TYPE_BOOLEAN,)),
        'streamstate-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                                 (GObject.TYPE_INT, GObject.TYPE_BOOLEAN,
                                  GObject.TYPE_STRING)),
        'recordstate-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                                 (GObject.TYPE_INT, GObject.TYPE_BOOLEAN,
                                  GObject.TYPE_STRING)),
        'channelstate-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                                  (GObject.TYPE_UINT, GObject.TYPE_BOOLEAN)),
        'voip-mode-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                               (GObject.TYPE_UINT,)),
        'metadata-changed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                              (GObject.TYPE_STRING,) * 5),
        'effect-started': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                           (GObject.TYPE_STRING,) * 2 + (GObject.TYPE_UINT,)),
        'effect-stopped': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                           (GObject.TYPE_UINT,)),
        'player-started': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                           (GObject.TYPE_STRING,)),
        'player-stopped': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                           (GObject.TYPE_STRING,)),
        'tracks-finishing': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                             ()),
        'announcement': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                          (GObject.TYPE_STRING,) * 3),
        'frozen': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                    (GObject.TYPE_STRING, GObject.TYPE_UINT,
                     GObject.TYPE_BOOLEAN))
    }

    __gproperties__ = {
        'artist': (GObject.TYPE_STRING, 'artist', 'artist from track metadata',
                   "", GObject.PARAM_READABLE),
        'title': (GObject.TYPE_STRING, 'title', 'title from track metadata',
                  "", GObject.PARAM_READABLE),
        'album': (GObject.TYPE_STRING, 'album', 'album from track metadata',
                  "", GObject.PARAM_READABLE),
        'songname': (GObject.TYPE_STRING, 'songname',
                     'the song name from metadata tags when available'
                     ' and from the filenmame when not',
                     "", GObject.PARAM_READABLE),
        'music-filename': (GObject.TYPE_STRING, 'music_filename',
                           'the audio file pathname of the track',
                           "", GObject.PARAM_READABLE),
        'streaminfo': (GObject.TYPE_PYOBJECT, 'streaminfo',
                       'information about the streams',
                       GObject.PARAM_READABLE),
        'recordinfo': (GObject.TYPE_PYOBJECT, 'recordinfo',
                       'information about the recorders',
                       GObject.PARAM_READABLE),
        'channelinfo': (GObject.TYPE_PYOBJECT, 'channelinfo',
                        'toggle state of the audio channels',
                        GObject.PARAM_READABLE),
        'focus-window': (GObject.TYPE_PYOBJECT, 'focuswindow',
                        'window that has focus or None',
                        GObject.PARAM_READABLE),
        'entry-mode': (GObject.TYPE_BOOLEAN, 'entry-mode',
                        'an entry widget has focus', False,
                        GObject.PARAM_READABLE),
        'stream-silence': (GObject.TYPE_BOOLEAN, 'entry-mode',
                        'stream mix is too quiet for live streaming', False,
                        GObject.PARAM_READABLE),
        'voip-mode': (GObject.TYPE_UINT, 'voip-mode',
                      'voice over ip mixer mode', 0, 2, 0,
                      GObject.PARAM_READABLE)
    }

    def __init__(self, profile):
        """Takes the profile parameter e.g. "default".

        Can also handle sessions with "session.sessionname"
        """

        GObject.GObject.__init__(self)
        self.__profile = profile
        self.__bus = dbus.SessionBus(mainloop=DBusGMainLoop())
        self.__bus_address = ".".join((BUS_BASENAME, profile))
        self.__base_objpath = OBJ_BASENAME
        self.__base_interface = BUS_BASENAME
        self.__artist = self.__title = self.__album = ""
        self.__songname = self.__music_filename = ""
        self.__shutdown = False
        self._start_probing()

    @property
    def main(self):
        """A DBus interface to the main object.

        Code that uses this should catch any AttributeError exceptions.
        """
        return dbus.Interface(self.__main, self.__base_interface)

    @property
    def output(self):
        """A DBus interface to the output object.

        Code that uses this should catch any AttributeError exceptions.
        """
        return dbus.Interface(self.__output, self.__base_interface)

    @property
    def controls(self):
        """A DBus interface to the controls object.

        Code that uses this should catch any AttributeError exceptions.
        """
        return dbus.Interface(self.__controls, self.__base_interface)

    def shutdown(self):
        """Block both signal emission and property reads."""

        self.__shutdown = True

    def _start_probing(self):
        self.__watchdog_id = None
        self.__probe_id = None
        self.__watchdog_notice = False
        self.__pid = 0
        self.__frozen = False
        self.__entry_mode = False
        self.__stream_silence = False
        self.__main = self.__output = self.__controls = self.__focus = None
        self.__aux = None
        if not self.__shutdown:
            self.__probe_id = GObject.timeout_add_seconds(
                                                2, self._idjc_started_probe)

    def _idjc_started_probe(self):
        # Check for a newly started IDJC instance of the correct profile.

        def bgo(tail):
            return self.__bus.get_object(self.__bus_address,
                                         self.__base_objpath + tail)
        try:
            self.__main = bgo("/main")
            self.__output = bgo("/output")
            self.__controls = bgo("/controls")
            self.__player_left = bgo("/player/left")
            self.__player_right = bgo("/player/right")
            self.__player_interlude = bgo("/player/interlude")
            self.__aux = bgo("/aux")
            self.__players = (self.__player_left, self.__player_right,
                              self.__player_interlude)

            main_iface = dbus.Interface(self.__main, self.__base_interface)
            main_iface.pid(reply_handler=self._pid_reply_handler,
                           error_handler=self._pid_error_handler)

        except dbus.exceptions.DBusException:
            # Keep searching periodically.
            return not self.__shutdown
        else:
            return False

    def _pid_reply_handler(self, value):
        self.__pid = value

        def cts(obj, signal, handler):
            obj.connect_to_signal(signal, handler)

        try:
            cts(self.__main, "focus_changed", self._focus_handler)
            cts(self.__main, "track_metadata_changed", self._metadata_handler)
            cts(self.__main, "effect_started", self._effect_started_handler)
            cts(self.__main, "effect_stopped", self._effect_stopped_handler)
            cts(self.__main, "quitting", self._quit_handler)
            cts(self.__main, "heartbeat", self._heartbeat_handler)
            cts(self.__main, "channelstate_changed", self._channelstate_handler)
            cts(self.__main, "voip_mode_changed", self._voip_mode_handler)
            cts(self.__main, "tracks_finishing", self._tracks_finishing_handler)
            cts(self.__main, "stream_silence_changed", self._stream_silence_changed_handler)
            cts(self.__output, "streamstate_changed", self._streamstate_handler)
            cts(self.__output, "recordstate_changed", self._recordstate_handler)
            cts(self.__aux, "text_entry_mode", self._text_entry_mode_handler)
            for each in self.__players:
                cts(each, "playing", self._playing_handler)
                cts(each, "announcement", self._announcement_handler)

            # Start watchdog thread.
            self.__watchdog_id = GObject.timeout_add_seconds(3, self._watchdog)

            self.__streams = {n: (False, "unknown") for n in range(10)}
            self.__recorders = {n: (False, "unknown") for n in range(4)}
            self.__channels = [False]*12
            self.__voip_mode = 0
            main_iface = dbus.Interface(self.__main, self.__base_interface)
            output_iface = dbus.Interface(self.__output, self.__base_interface)

            self.emit("launch", self.__profile, self.__pid)

            # Tell IDJC to initialize as empty its cache of sent data.
            # This yields a dump of server related info.
            main_iface.new_plugin_started()
            output_iface.new_plugin_started()
        except dbus.exceptions.DBusException:
            self._start_probing()

    def _pid_error_handler(self, error):
        self._start_probing()

    def _watchdog(self):
        if self.__watchdog_notice:
            if pid_exists(int(self.__pid)):
                if not self.__frozen:
                    self.__frozen = True
                    self.emit("frozen", self.__profile, self.__pid, True)
                return True
            else:
                for id_, (conn, where) in self.__streams.iteritems():
                    if conn:
                        self._streamstate_handler(id_, 0, where)

                for id_, (rec, where) in self.__recorders.iteritems():
                    if rec:
                        self._recordstate_handler(id_, 0, where)

                for index, open_ in enumerate(self.__channels):
                    if open_:
                        self._channelstate_handler(index, 0)

                self._quit_handler()
                return False
        elif self.__frozen:
            self.__frozen = False
            self.emit("frozen", self.__profile, self.__pid, False)

        self.__watchdog_notice = True
        return not self.__shutdown

    def _heartbeat_handler(self):
        self.__watchdog_notice = False

    def _quit_handler(self):
        """Start scanning for a new bus object."""

        if self.__watchdog_id is not None:
            GObject.source_remove(self.__watchdog_id)
            self.emit("quit", self.__profile, self.__pid)
        self._start_probing()

    def _focus_handler(self, window, has_focus):
        self.__focus = None if not has_focus else window
        self.notify("focus-window")
        self.emit("focus-changed", window, has_focus)

    def _text_entry_mode_handler(self, entry_mode):
        self.__entry_mode = entry_mode
        self.notify("entry-mode")
        self.emit("entry-mode-changed", entry_mode)

    def _stream_silence_changed_handler(self, silence):
        self.__stream_silence = silence
        self.notify("stream-silence")
        self.emit("stream-silence-changed", silence)

    def _streamstate_handler(self, numeric_id, connected, where):
        numeric_id = int(numeric_id)
        connected = bool(connected)
        self.__streams[numeric_id] = (connected, where)
        self.notify("streaminfo")
        self.emit("streamstate-changed", numeric_id, connected, where)

    def _recordstate_handler(self, numeric_id, recording, where):
        numeric_id = int(numeric_id)
        recording = bool(recording)
        self.__recorders[numeric_id] = (recording, where)
        self.notify("recordinfo")
        self.emit("recordstate-changed", numeric_id, recording, where)

    def _channelstate_handler(self, numeric_id, open_):
        numeric_id = int(numeric_id)
        open_ = bool(open_)
        self.__channels[numeric_id] = open_
        self.notify("channelinfo")
        self.emit("channelstate-changed", numeric_id, open_)

    def _voip_mode_handler(self, mode):
        mode = int(mode)
        self.__voip_mode = mode
        self.notify("voip-mode")
        self.emit("voip-mode-changed", mode)

    def _tracks_finishing_handler(self):
        self.emit("tracks-finishing")

    def _metadata_handler(self, *args):
        # see definition of names below for 'args' specification.

        def update_property(name, value):
            oldvalue = getattr(self, f"_IDJCMonitor__{name}")
            if value != oldvalue:
                setattr(self, f"_IDJCMonitor__{name}", value)
                self.notify(name)

        names = "artist title album songname music_filename".split()
        for name, arg in zip(names, args):
            update_property(name, arg)

        self.emit("metadata-changed", self.__artist, self.__title,
                  self.__album, self.__songname, self.__music_filename)

    def _effect_started_handler(self, title, pathname, player):
        self.emit("effect-started", title, pathname, player)

    def _effect_stopped_handler(self, player):
        self.emit("effect-stopped", player)

    def _playing_handler(self, name, state):
        if state:
            self.emit("player-started", name)
        else:
            self.emit("player-stopped", name)

    def _announcement_handler(self, player, state, message):
        self.emit("announcement", player, state, message)

    def do_get_property(self, prop):
        if self.__shutdown:
            raise AttributeError(
                        "Attempt to read property after shutdown was called.")

        name = prop.name

        if name in ("artist", "title", "album", "songname", "music_filename",
                    "effect_pathname"):
            return getattr(self, "_IDJCMonitor__" + name)
        if name == "streaminfo":
            return tuple(self.__streams[n] for n in range(10))
        elif name == "recordinfo":
            return tuple(self.__recorders[n] for n in range(4))
        elif name == "channelinfo":
            return tuple(self.__channels[n] for n in range(12))
        elif name == "voip-mode":
            return self.__voip_mode
        elif name == "focus-window":
            return self.__focus
        elif name == "entry-mode":
            return self.__entry_mode
        elif name == "stream-silence":
            return self.__stream_silence
        else:
            raise AttributeError("Unknown property {} in {!r}".format(name, self))

    def notify(self, property_name):
        if not self.__shutdown:
            GObject.Object.notify(self, property_name)

    def emit(self, *args, **kwargs):
        if not self.__shutdown:
            GObject.Object.emit(self, *args, **kwargs)