#!/usr/bin/env python
# vim: set fileencoding=utf-8 sts=4 sw=4 et :
"""
The world's worst XMPP console user interface.

Pass it the bus name of a Gabble connection; type some words; get minimalistic
error reporting.

Copyright © 2011 Collabora Ltd. <http://www.collabora.co.uk/>

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
"""

import sys
import re
from xml.dom import minidom

import pygtk
pygtk.require('2.0')

from gi.repository import Gtk
from gi.repository import GLib
from gi.repository import Gio
from gi.repository import GtkSource

PADDING = 6

def pathify(name):
    return '/' + name.replace('.', '/')

def nameify(path):
    return (path[1:]).replace('/', '.')

CONN_FUTURE_IFACE = "org.freedesktop.Telepathy.Connection.FUTURE"
CONSOLE_IFACE = "org.freedesktop.Telepathy.Gabble.Plugin.Console"

class StanzaViewer(Gtk.ScrolledWindow):
    def __init__(self):
        Gtk.ScrolledWindow.__init__(self)

        self.b = GtkSource.Buffer()
        self.view = GtkSource.View.new_with_buffer(self.b)
        self.b.set_language(
            GtkSource.LanguageManager.get_default().get_language('xml'))
        self.b.set_highlight_matching_brackets(False)
        self.view.set_editable(False)
        self.view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        self.view.set_property('expand', True)

        self.add(self.view)

    def clear(self):
        self.b.set_text("")

    def append_stanza(self, xml):
        pretty = minidom.parseString(xml).toprettyxml()
        pretty = pretty.replace('<?xml version="1.0" ?>\n', '')
        i = self.b.get_end_iter()
        self.b.insert(i, pretty + '\n')

    def append_comment(self, text):
        i = self.b.get_end_iter()
        self.b.insert(i, '<!-- %s -->\n' % text)

    def tell_me_everything(self):
        return self.b.get_property('text')

class SpinWrapper(Gtk.Notebook):
    PRIMARY_PAGE = 0
    SPINNER_PAGE = 1

    def __init__(self, main_widget):
        Gtk.Notebook.__init__(self)
        self.set_show_tabs(False)
        self.set_show_border(False)
        self.insert_page(main_widget, None, self.PRIMARY_PAGE)

        self.spinner = Gtk.Spinner()
        self.spinner.set_property('halign', Gtk.Align.CENTER)
        self.spinner.set_property('valign', Gtk.Align.CENTER)
        self.spinner.set_property('width-request', 32)
        self.spinner.set_property('height-request', 32)
        self.insert_page(self.spinner, None, self.SPINNER_PAGE)

    def start_spinning(self):
        self.set_current_page(self.SPINNER_PAGE)
        self.spinner.start()

    def stop_spinning(self):
        self.spinner.stop()
        self.set_current_page(self.PRIMARY_PAGE)

class Page(Gtk.Grid):
    def __init__(self, console_proxy):
        Gtk.Grid.__init__(self)

        self.console_proxy = console_proxy

        self.set_column_spacing(PADDING)
        self.set_row_spacing(PADDING)

    def add_title(self, title, below=None):
        label = Gtk.Label()
        label.set_markup("<b>%s</b>" % title)
        label.set_property('xalign', 0)

        if below is None:
            self.attach(label, 0, 0, 2, 1)
        else:
            self.attach_next_to(label, below, Gtk.PositionType.BOTTOM, 2, 1)

        return label

    def add_label(self, title, below=None):
        label = Gtk.Label(title)
        label.set_property('margin-left', PADDING)
        label.set_property('xalign', 0)

        if below is None:
            self.attach(label, 0, 0, 1, 1)
        else:
            self.attach_next_to(label, below, Gtk.PositionType.BOTTOM, 1, 1)

        return label

class IQPage(Page):
    def __init__(self, console_proxy):
        Page.__init__(self, console_proxy)

        request_label = self.add_title("Request")

        recipient_label, recipient_entry = self.add_label_entry_pair(
            'To:', below=request_label)
        self.recipient_entry = recipient_entry

        type_label = self.add_label('IQ Type:', below=recipient_label)
        self.get_button = Gtk.RadioButton.new_with_label([], "get")
        self.get_button.set_active(True)
        self.set_button = Gtk.RadioButton.new_with_label_from_widget(
            self.get_button, "set")

        box = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL)
        box.set_layout(Gtk.ButtonBoxStyle.START)
        box.add(self.get_button)
        box.add(self.set_button)
        self.attach_next_to(box, type_label,
            Gtk.PositionType.RIGHT, 1, 1)

        body_label, body_entry = self.add_label_entry_pair(
            'Body:', below=type_label)
        body_entry.set_text(
            "<query xmlns='http://jabber.org/protocol/disco#info'/>")
        body_entry.set_icon_from_stock(
            Gtk.EntryIconPosition.SECONDARY, Gtk.STOCK_GO_FORWARD)
        body_entry.set_icon_tooltip_text(
            Gtk.EntryIconPosition.SECONDARY, "Send this IQ")
        self.body_entry = body_entry

        reply_label = self.add_title("Reply", below=body_label)

        self.stanza_viewer = StanzaViewer()
        self.stanza_viewer.append_comment("send a request to see the reply here")

        self.result_nb = SpinWrapper(self.stanza_viewer)

        self.attach_next_to(self.result_nb, reply_label, Gtk.PositionType.BOTTOM, 2, 1)

        body_entry.connect('activate', self.send_iq)
        body_entry.connect('icon-release', self.send_iq)

    def add_label_entry_pair(self, title, below):
        label = self.add_label(title, below)

        entry = Gtk.Entry()
        entry.set_property('margin-right', PADDING)
        entry.set_property('hexpand', True)

        self.attach_next_to(entry, label, Gtk.PositionType.RIGHT, 1, 1)

        return label, entry

    def send_iq(self, *misc):
        type = 'get' if self.get_button.get_active() else 'set'
        to = self.recipient_entry.get_text()
        body = self.body_entry.get_text()

        self.console_proxy.SendIQ('(sss)', type, to, body,
            result_handler=self.send_iq_cb)
        self.result_nb.start_spinning()

    def send_iq_cb(self, proxy, result, user_data):
        self.stanza_viewer.clear()

        if isinstance(result, Exception):
            self.stanza_viewer.append_comment("error:\n%s" % result)
        else:
            reply_type, reply = result
            self.stanza_viewer.append_stanza(reply)

        self.result_nb.stop_spinning()

class StanzaPage(Page):
    def __init__(self, console_proxy):
        Page.__init__(self, console_proxy)

        title = self.add_title("Enter a complete stanza:")

        self.sv = StanzaViewer()
        self.sv.view.set_editable(True)
        self.sv.append_stanza("<message to='t-pain@test.collabora.co.uk' type='chat'><body>Been on any nice boats recently?</body></message>")

        self.spin_wrapper = SpinWrapper(self.sv)
        self.attach_next_to(self.spin_wrapper, title, Gtk.PositionType.BOTTOM,
            2, 1)

        self.result_label = self.add_label('', self.spin_wrapper)
        self.result_label.set_property('hexpand', True)
        self.result_label.set_line_wrap(True)

        b = Gtk.Button.new_with_mnemonic("_Send")
        b.connect('clicked', self.__send_stanza)
        b.set_property('hexpand', False)
        self.attach_next_to(b, self.result_label, Gtk.PositionType.RIGHT, 1, 1)

    def __send_stanza(self, button):
        self.console_proxy.SendStanza('(s)', self.sv.tell_me_everything(),
            result_handler=self.__send_stanza_cb)
        self.spin_wrapper.start_spinning()

    def __send_stanza_cb(self, proxy, result, user_data):
        if isinstance(result, Exception):
            # FIXME: this sucks. You can't just get the free text bit without
            # the D-Bus error bit.
            t = result.message
        else:
            t = "yes sir, captain tightpants"

        self.result_label.set_text(t)
        self.spin_wrapper.stop_spinning()

class SnoopyPage(Page):
    def __init__(self, console_proxy):
        Page.__init__(self, console_proxy)

        label = self.add_label("Stanza monitor:")
        label.set_property('hexpand', True)

        switch = Gtk.Switch()
        self.attach_next_to(switch, label, Gtk.PositionType.RIGHT, 1, 1)

        self.stanza_viewer = StanzaViewer()
        self.attach_next_to(self.stanza_viewer, label, Gtk.PositionType.BOTTOM, 2, 1)

        switch.set_active(self.get_remote_active())
        switch.connect('notify::active', self.__switch_switched_cb)

        self.console_proxy.connect('g-signal', self.__g_signal_cb)

    def teardown(self):
        """Turn off the monitor when we quit."""
        self.__set_spew(False)

    def __set_spew(self, spew):
        args = GLib.Variant("(ssv)", (CONSOLE_IFACE, "SpewStanzas",
            GLib.Variant.new_boolean(spew)))
        self.console_proxy.call_sync(
            "org.freedesktop.DBus.Properties.Set",
            args,
            0, -1, None)

    def get_remote_active(self):
        return self.console_proxy.get_cached_property('SpewStanzas').get_boolean()

    def __switch_switched_cb(self, switch, pspec):
        remote = self.get_remote_active()
        new_local = switch.get_active()

        if new_local != remote:
            self.__set_spew(new_local)
            self.stanza_viewer.append_comment(
                'started monitoring' if new_local else 'stopped monitoring')

    def __g_signal_cb(self, console_proxy, sender_name, signal_name, parameters):
        if signal_name in ['StanzaSent', 'StanzaReceived']:
            outgoing = (signal_name == 'StanzaSent')
            xml, = parameters

            self.stanza_viewer.append_comment('sent' if outgoing else 'received')
            self.stanza_viewer.append_stanza(xml)

class Window(Gtk.Window):
    IQ_PAGE = 0
    STANZA_PAGE = 1
    SNOOPY_PAGE = 2

    def __init__(self, bus, connection_bus_name):
        Gtk.Window.__init__(self)

        self.set_title('XMPP Console')
        self.set_default_size(600, 371)

        conn_future_proxy = Gio.DBusProxy.new_sync(bus, 0, None,
            connection_bus_name, pathify(connection_bus_name),
            CONN_FUTURE_IFACE, None)
        try:
            sidecar_path, _ = conn_future_proxy.EnsureSidecar('(s)', CONSOLE_IFACE)
        except Exception, e:
            print """
Couldn't connect to the XMPP console interface on '%(connection_bus_name)s':
  %(e)s
Check that it's a running Jabber connection, and that you have the console
plugin installed.""" % locals()

            raise SystemExit(2)

        self.console_proxy = Gio.DBusProxy.new_sync(bus, 0, None,
            connection_bus_name, sidecar_path, CONSOLE_IFACE, None)

        # Build up the UI
        self.nb = Gtk.Notebook()
        self.add(self.nb)

        self.iq = IQPage(self.console_proxy)
        self.nb.insert_page(self.iq,
            Gtk.Label.new_with_mnemonic("_IQ console"),
            self.IQ_PAGE)

        self.stanza = StanzaPage(self.console_proxy)
        self.nb.insert_page(self.stanza,
            Gtk.Label.new_with_mnemonic("Send a s_tanza"),
            self.STANZA_PAGE)

        self.snoopy = SnoopyPage(self.console_proxy)
        self.nb.insert_page(self.snoopy,
            Gtk.Label.new_with_mnemonic("_Monitor network traffic"),
            self.SNOOPY_PAGE)

        self.connect('destroy', Window.__destroy_cb)

    def __destroy_cb(self):
        self.snoopy.teardown()
        Gtk.main_quit()

GABBLE_PREFIX = 'org.freedesktop.Telepathy.Connection.gabble.jabber.'

AM_BUS_NAME = 'org.freedesktop.Telepathy.AccountManager'
ACCOUNT_PREFIX = '/org/freedesktop/Telepathy/Account'
ACCOUNT_IFACE = 'org.freedesktop.Telepathy.Account'

def usage():
    print """
Usage:

  %(arg0)s gabble/jabber/blahblah
  %(arg0)s %(prefix)sblahblah

List account identifiers using `mc-tool list | grep gabble`.
List connection bus names using `qdbus | grep gabble`.
""" % { 'arg0': sys.argv[0],
        'prefix': GABBLE_PREFIX,
      }
    raise SystemExit(1)

if __name__ == '__main__':
    bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)

    if len(sys.argv) != 2:
        usage()

    thing = sys.argv[1]

    if re.match('^gabble/jabber/[a-zA-Z0-9_]+$', thing):
        # Looks like an account path to me.
        account_proxy = Gio.DBusProxy.new_sync(bus, 0, None,
            AM_BUS_NAME, '%s/%s' % (ACCOUNT_PREFIX, thing),
            ACCOUNT_IFACE, None)
        path = account_proxy.get_cached_property('Connection').get_string()
        if path == '/':
            print "%s is not online" % thing
            raise SystemExit(1)
        else:
            thing = nameify(path)

    if not re.match('^%s[a-zA-Z0-9_]+$' % GABBLE_PREFIX, thing):
        usage()

    win = Window(bus, thing)
    win.show_all()

    Gtk.main()

"""
           .,,.
         ,;;*;;;;,
        .-'``;-');;.
       /'  .-.  /*;;
     .'    \d    \;;               .;;;,
    / o      `    \;    ,__.     ,;*;;;*;,
    \__, _.__,'   \_.-') __)--.;;;;;*;;;;,
     `""`;;;\       /-')_) __)  `\' ';;;;;;
        ;*;;;        -') `)_)  |\ |  ;;;;*;
        ;;;;|        `---`    O | | ;;*;;;
        *;*;\|                 O  / ;;;;;*
       ;;;;;/|    .-------\      / ;*;;;;;
      ;;;*;/ \    |        '.   (`. ;;;*;;;
      ;;;;;'. ;   |          )   \ | ;;;;;;
      ,;*;;;;\/   |.        /   /` | ';;;*;
       ;;;;;;/    |/       /   /__/   ';;;
       '*jgs/     |       /    |      ;*;
            `""""`        `""""`     ;'
"""
