# Copyright (C) 2006-2007 Red Hat, Inc.
# Copyright (C) 2010 Collabora Ltd. <http://www.collabora.co.uk/>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import logging
from gettext import gettext as _

from gi.repository import Gtk
from gi.repository import GConf
from gi.repository import GLib
import dbus

from sugar3.graphics.palette import Palette
from sugar3.graphics.palettemenu import PaletteMenuBox
from sugar3.graphics.palettemenu import PaletteMenuItem
from sugar3.graphics.icon import Icon

from jarabe.model import shell
from jarabe.model import friends
from jarabe.model.session import get_session_manager
from jarabe.controlpanel.gui import ControlPanel
import jarabe.desktop.homewindow

control_panel = None

class BuddyMenu(Palette):
    def __init__(self, buddy):
        self._buddy = buddy

        buddy_icon = Icon(icon_name='computer-xo',
                          xo_color=buddy.get_color(),
                          icon_size=Gtk.IconSize.LARGE_TOOLBAR)
        nick = buddy.get_nick()
        Palette.__init__(self, None,
                         primary_text=GLib.markup_escape_text(nick),
                         icon=buddy_icon)
        self.menu_box = Gtk.VBox()
        self.set_content(self.menu_box)
        self.menu_box.show_all()
        self._invite_menu = None
        self._active_activity_changed_hid = None
        # Fixme: we need to make the widget accessible through the Palette API
        self._widget.connect('destroy', self.__destroy_cb)

        self._buddy.connect('notify::nick', self.__buddy_notify_nick_cb)

        if buddy.is_owner():
            self._add_my_items()
        else:
            self._add_buddy_items()

    def __destroy_cb(self, menu):
        if self._active_activity_changed_hid is not None:
            home_model = shell.get_model()
            home_model.disconnect(self._active_activity_changed_hid)
        self._buddy.disconnect_by_func(self.__buddy_notify_nick_cb)

    def _add_buddy_items(self):
        menu_item = None
        if friends.get_model().has_buddy(self._buddy):
            menu_item = PaletteMenuItem(_('Remove friend'), 'list-remove')
            menu_item.connect('activate', self._remove_friend_cb)
        else:
            menu_item = PaletteMenuItem(_('Make friend'), 'list-add')
            menu_item.connect('activate', self._make_friend_cb)

        self.menu_box.pack_start(menu_item, True, True, 0)
        menu_item.show()

        if (jarabe.journal.model.is_peer_to_peer_sharing_available()) and \
                (self._buddy.props.ip_address is not None):
            remote_share_menu_item = None
            if not jarabe.journal.model.mount_point_button_exists(
                    jarabe.journal.model.WEBDAV_MOUNT_POINT + self._buddy.props.ip_address):
                remote_share_menu_item = PaletteMenuItem(_('Access Share'), 'list-add')
                remote_share_menu_item.connect('activate', self._access_share_cb)
            else:
                remote_share_menu_item = PaletteMenuItem(_('Unmount Share'), 'list-remove')
                remote_share_menu_item.connect('activate', self.__unmount_cb)

            self.menu_box.pack_start(remote_share_menu_item, True, True, 0)
            remote_share_menu_item.show()

        self._invite_menu = PaletteMenuItem('')
        self._invite_menu.connect('activate', self._invite_friend_cb)
        self.menu_box.pack_start(self._invite_menu, True, True, 0)

        home_model = shell.get_model()
        self._active_activity_changed_hid = home_model.connect(
                'active-activity-changed', self._cur_activity_changed_cb)
        activity = home_model.get_active_activity()
        self._update_invite_menu(activity)

    def _add_my_items(self):
        item = PaletteMenuItem(_('Shutdown'), 'system-shutdown')
        item.connect('activate', self.__shutdown_activate_cb)
        self.menu_box.pack_start(item, True, True, 0)
        item.show()

        client = GConf.Client.get_default()

        if client.get_bool('/desktop/sugar/show_restart'):
            item = PaletteMenuItem(_('Restart'), 'system-restart')
            item.connect('activate', self.__reboot_activate_cb)
            self.menu_box.pack_start(item, True, True, 0)
            item.show()

        if client.get_bool('/desktop/sugar/show_logout'):
            item = PaletteMenuItem(_('Logout'), 'system-logout')
            item.connect('activate', self.__logout_activate_cb)
            self.menu_box.pack_start(item, True, True, 0)
            item.show()

        item = PaletteMenuItem(_('My Settings'), 'preferences-system')
        item.connect('activate', self.__controlpanel_activate_cb)
        self.menu_box.pack_start(item, True, True, 0)
        item.show()

    def __unmount_cb(self, menuitem):
        from jarabe.journal.journalactivity import get_journal
        singleton_volumes_toolbar = get_journal().get_volumes_toolbar()
        singleton_volumes_toolbar._remove_remote_share_button(self._buddy.props.ip_address)
        self._refresh_menu_items()

    def _access_share_cb(self, menuitem):
        from jarabe.journal.journalactivity import get_journal
        volumes_toolbar = get_journal().get_volumes_toolbar()

        # TRANS: Do not translate the """%s""".
        primary_text = _('%s\'s Shares') % self._buddy.props.nick
        button = volumes_toolbar._add_remote_share_button(primary_text,
                                                 self._buddy.props.ip_address,
                                                 self._buddy.props.color,
                                                 jarabe.journal.volumestoolbar.SHARE_TYPE_PEER)

        # Now, make three levels of transitions, from the
        # Neighborhood-view.

        # 1. Switch to the home-view.
        from jarabe.model import shell
        from jarabe.model.shell import ShellModel
        shell.get_model().set_zoom_level(ShellModel.ZOOM_HOME)

        # 2. Switch to the journal-activity-view.
        top_frame = jarabe.frame.get_view()
        top_frame.switch_to_journal_activity()

        # 3. Switch to the newly mounted-view.
        volumes_toolbar._button_toggled_cb(button, force_toggle=True)

        self._refresh_menu_items()

    def _quit(self, action):
        home_window = jarabe.desktop.homewindow.get_instance()
        home_window.busy_during_delayed_action(action)

    def __logout_activate_cb(self, menu_item):
        self._quit(get_session_manager().logout)

    def __reboot_activate_cb(self, menu_item):
        self._quit(get_session_manager().reboot)

    def __shutdown_activate_cb(self, menu_item):
        self._quit(get_session_manager().shutdown)

    def __controlpanel_activate_cb(self, menu_item):
        # hide the frame when control panel is shown
        import jarabe.frame
        frame = jarabe.frame.get_view()
        frame.hide()

        # Now, since we are entering the "modal" "My Settings",
        # disable the Function-key-handlers.
        from jarabe.view.keyhandler import set_key_handlers_active
        set_key_handlers_active(False)

        # show the control panel
        panel = ControlPanel()
        panel.show()

        global control_panel
        control_panel = panel

    def _update_invite_menu(self, activity):
        buddy_activity = self._buddy.props.current_activity
        if buddy_activity is not None:
            buddy_activity_id = buddy_activity.activity_id
        else:
            buddy_activity_id = None

        if activity is None or activity.is_journal() or \
           activity.get_activity_id() == buddy_activity_id:
            self._invite_menu.hide()
        else:
            title = activity.get_title()
            self._invite_menu.set_label(_('Invite to %s') % title)

            icon = Icon(file=activity.get_icon_path(),
                        icon_size=Gtk.IconSize.SMALL_TOOLBAR)
            icon.props.xo_color = activity.get_icon_color()
            self._invite_menu.set_image(icon)
            icon.show()

            self._invite_menu.show()

    def _cur_activity_changed_cb(self, home_model, activity_model):
        self._update_invite_menu(activity_model)

    def __buddy_notify_nick_cb(self, buddy, pspec):
        self.set_primary_text(GLib.markup_escape_text(buddy.props.nick))

    def _refresh_menu_items(self):
        for child_widget in self.menu_box.get_children():
            self.menu_box.remove(child_widget)
        self._add_buddy_items()

    def _make_friend_cb(self, menuitem):
        friends.get_model().make_friend(self._buddy)
        self._refresh_menu_items()

    def _remove_friend_cb(self, menuitem):
        friends.get_model().remove(self._buddy)
        self._refresh_menu_items()

    def _invite_friend_cb(self, menuitem):
        activity = shell.get_model().get_active_activity()
        service = activity.get_service()
        if service:
            try:
                service.InviteContact(self._buddy.props.account,
                                      self._buddy.props.contact_id)
            except dbus.DBusException, e:
                expected_exceptions = [
                        'org.freedesktop.DBus.Error.UnknownMethod',
                        'org.freedesktop.DBus.Python.NotImplementedError']
                if e.get_dbus_name() in expected_exceptions:
                    logging.warning('Trying deprecated Activity.Invite')
                    service.Invite(self._buddy.props.key)
                else:
                    raise
        else:
            logging.error('Invite failed, activity service not ')

def get_control_panel():
    return control_panel

def set_control_panel(panel):
    global control_panel
    control_panel = panel