/*
 * Jitsi, the OpenSource Java VoIP and Instant Messaging client.
 *
 * Copyright @ 2015 Atlassian Pty Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.java.sip.communicator.impl.gui.main.menus;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;

import javax.swing.*;
import javax.swing.event.*;

import net.java.sip.communicator.impl.gui.*;
import net.java.sip.communicator.impl.gui.event.*;
import net.java.sip.communicator.impl.gui.main.call.*;
import net.java.sip.communicator.impl.gui.main.call.conference.*;
import net.java.sip.communicator.impl.gui.main.configforms.*;
import net.java.sip.communicator.impl.gui.main.contactlist.*;
import net.java.sip.communicator.impl.gui.utils.*;
import net.java.sip.communicator.plugin.desktoputil.*;
import net.java.sip.communicator.plugin.desktoputil.SwingWorker;
import net.java.sip.communicator.service.gui.*;
import net.java.sip.communicator.service.gui.Container;
import net.java.sip.communicator.service.notification.*;
import net.java.sip.communicator.service.protocol.*;
import net.java.sip.communicator.util.*;
import net.java.sip.communicator.util.Logger;
import net.java.sip.communicator.util.account.*;
import net.java.sip.communicator.util.skin.*;

import org.jitsi.service.configuration.*;
import org.jitsi.service.resources.*;
import org.jitsi.util.*;
import org.osgi.framework.*;

/**
 * The <tt>ToolsMenu</tt> is a menu in the contact list / chat panel bars that
 * contains "Tools". This menu is separated in different sections by
 * <tt>JSeparator</tt>s. These sections are ordered in the following matter:
 * 0 0 0 | 1 1 | 2 2... where numbers indicate the indices of the corresponding
 * sections and | are separators. Currently, section 0 contains "Options",
 * "Create a video bridge", "Create a conference call"... until the first
 * <tt>JSeparator</tt> after which starts the next section - section 1.
 *
 * @author Yana Stamcheva
 * @author Lyubomir Marinov
 * @author Adam Netocny
 */
public class ToolsMenu
    extends SIPCommMenu
    implements  ActionListener,
                PluginComponentListener,
                ServiceListener,
                Skinnable
{
    /**
     * Serial version UID.
     */
    private static final long serialVersionUID = 0L;

    /**
     * Local logger.
     */
    private final Logger logger = Logger.getLogger(ToolsMenu.class);

    /**
     * Property to disable auto answer menu.
     */
    private static final String AUTO_ANSWER_MENU_DISABLED_PROP =
        "net.java.sip.communicator.impl.gui.main.menus.AUTO_ANSWER_MENU_DISABLED";

    /**
     * Property to disable conference initialization.
     */
    private static final String CONFERENCE_CALL_DISABLED_PROP =
        "net.java.sip.communicator.impl.gui.main.menus"
            + ".CONFERENCE_CALL_MENU_ITEM_DISABLED";

   /**
    * Conference call menu item.
    */
    private JMenuItem conferenceMenuItem;

    /**
     * Video bridge conference call menu. In the case of more than one account.
     */
    private JMenuItem videoBridgeMenuItem;

   /**
    * Show/Hide offline contacts menu item.
    */
    private JMenuItem hideOfflineMenuItem;

   /**
    * Sound menu item.
    */
    private JMenuItem soundMenuItem;

   /**
    * Preferences menu item.
    */
    JMenuItem configMenuItem;

    /**
     * The <tt>SwingWorker</tt> creating the video bridge menu item depending
     * on the number of <tt>ProtocolProviderService</tt>-s supporting the video
     * bridge functionality.
     */
    private SwingWorker initVideoBridgeMenuWorker;

    /**
     * The menu listener that would update the video bridge menu item every
     * time the user clicks on the Tools menu.
     */
    private MenuListener videoBridgeMenuListener;

    /**
     * Indicates if this menu is shown for the chat window or the contact list
     * window.
     */
    private boolean isChatMenu;

    /**
     * Creates an instance of <tt>FileMenu</tt>.
     */
    public ToolsMenu()
    {
        this(false);
    }

    /**
     * Creates an instance of <tt>FileMenu</tt>, by specifying if this menu
     * would be shown for a chat window.
     *
     * @param isChatMenu indicates if this menu would be shown for a chat
     * window
     */
    public ToolsMenu(boolean isChatMenu)
    {
        this.isChatMenu = isChatMenu;

        ResourceManagementService r = GuiActivator.getResources();

        setText(r.getI18NString("service.gui.TOOLS"));
        setMnemonic(r.getI18nMnemonic("service.gui.TOOLS"));

        registerMenuItems();

        initPluginComponents();
    }

    /**
     * Initialize plugin components already registered for this container.
     */
    private void initPluginComponents()
    {
        // Search for plugin components registered through the OSGI bundle
        // context.
        ServiceReference[] serRefs = null;

        String osgiFilter = "("
            + Container.CONTAINER_ID
            + "="+Container.CONTAINER_TOOLS_MENU.getID()+")";

        try
        {
            serRefs = GuiActivator.bundleContext.getServiceReferences(
                PluginComponentFactory.class.getName(),
                osgiFilter);
        }
        catch (InvalidSyntaxException exc)
        {
            logger.error("Could not obtain plugin reference.", exc);
        }

        if (serRefs != null)
        {
            for (ServiceReference serRef : serRefs)
            {
                final PluginComponentFactory f = (PluginComponentFactory) GuiActivator
                    .bundleContext.getService(serRef);

                SwingUtilities.invokeLater(new Runnable()
                {
                    public void run()
                    {
                        PluginComponent pluginComponent =
                            f.getPluginComponentInstance(ToolsMenu.this);
                        insertInSection(
                            (JMenuItem) pluginComponent.getComponent(),
                            pluginComponent.getPositionIndex());
                    }
                });
            }
        }

        GuiActivator.getUIService().addPluginComponentListener(this);
    }

    /**
     * Handles the <tt>ActionEvent</tt> when one of the menu items is selected.
     * @param e the <tt>ActionEvent</tt> that notified us
     */
    public void actionPerformed(ActionEvent e)
    {
        JMenuItem menuItem = (JMenuItem) e.getSource();
        String itemName = menuItem.getName();

        if (itemName == null)
            return;

        if (itemName.equalsIgnoreCase("config"))
        {
            configActionPerformed();
        }
        else if (itemName.equals("conference"))
        {
            java.util.List<ProtocolProviderService> confProviders
                = CallManager.getTelephonyConferencingProviders();

            if (confProviders != null && confProviders.size() > 0)
            {
                ConferenceInviteDialog confInviteDialog
                    = new ConferenceInviteDialog();

                confInviteDialog.setVisible(true);
            }
            else
            {
                ResourceManagementService r = GuiActivator.getResources();

                new ErrorDialog(
                        null,
                        r.getI18NString("service.gui.WARNING"),
                        r.getI18NString(
                                "service.gui.NO_ONLINE_CONFERENCING_ACCOUNT"))
                    .showDialog();
            }
        }
        else if (itemName.equals("showHideOffline"))
        {
            boolean isShowOffline = ConfigurationUtils.isShowOffline();

            TreeContactList.presenceFilter.setShowOffline(!isShowOffline);

            // Only re-apply the filter if the presence filter is showing.
            // Otherwise we might end up with contacts in the call history
            if (GuiActivator.getContactList().getDefaultFilter() ==
                    TreeContactList.presenceFilter)
            {
                GuiActivator.getContactList()
                    .setDefaultFilter(TreeContactList.presenceFilter);
                GuiActivator.getContactList().applyDefaultFilter();
            }

            String itemTextKey = !isShowOffline
                    ? "service.gui.HIDE_OFFLINE_CONTACTS"
                    : "service.gui.SHOW_OFFLINE_CONTACTS";

            menuItem.setText(
                GuiActivator.getResources().getI18NString(itemTextKey));
        }
        else if (itemName.equals("sound"))
        {
            boolean mute = !GuiActivator.getAudioNotifier().isMute();

            GuiActivator.getAudioNotifier().setMute(mute);
            {
                // Distribute the mute state to the SoundNotificaitonHandler.
                for(NotificationHandler handler
                        : GuiActivator.getNotificationService()
                            .getActionHandlers(NotificationAction.ACTION_SOUND))
                {
                    if(handler instanceof SoundNotificationHandler)
                    {
                        SoundNotificationHandler soundHandler
                            = (SoundNotificationHandler) handler;

                        soundHandler.setMute(mute);
                    }
                }
            }

            menuItem.setText(
                    GuiActivator.getResources().getI18NString(
                            mute
                                ? "service.gui.SOUND_ON"
                                : "service.gui.SOUND_OFF"));
        }
    }

    /**
     * Shows the configuration window.
     */
    void configActionPerformed()
    {
        GuiActivator.getUIService()
            .getConfigurationContainer().setVisible(true);
    }

    /**
     * Adds the plugin component contained in the event to this container.
     * @param event the <tt>PluginComponentEvent</tt> that notified us
     */
    public void pluginComponentAdded(PluginComponentEvent event)
    {
        final PluginComponentFactory c = event.getPluginComponentFactory();

        if(c.getContainer().equals(Container.CONTAINER_TOOLS_MENU))
        {
            SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    PluginComponent pluginComponent =
                        c.getPluginComponentInstance(ToolsMenu.this);
                    insertInSection(
                        (JMenuItem) pluginComponent.getComponent(),
                        pluginComponent.getPositionIndex());
                }
            });

            this.revalidate();
            this.repaint();
        }
    }

    /**
     * Indicates that a plugin component has been removed. Removes it from this
     * container if it is contained in it.
     * @param event the <tt>PluginComponentEvent</tt> that notified us
     */
    public void pluginComponentRemoved(PluginComponentEvent event)
    {
        final PluginComponentFactory c = event.getPluginComponentFactory();

        if(c.getContainer().equals(Container.CONTAINER_TOOLS_MENU))
        {
            SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    remove((Component) c.getPluginComponentInstance(ToolsMenu.this).getComponent());
                }
            });
        }
    }

    /**
     * Registers all menu items.
     */
    private void registerMenuItems()
    {
        // We only add the options button if the property SHOW_OPTIONS_WINDOW
        // specifies so or if it's not set.
        ConfigurationService cfg = GuiActivator.getConfigurationService();
        Boolean showOptionsProp
            = cfg.getBoolean(
                    ConfigurationFrame.SHOW_OPTIONS_WINDOW_PROPERTY,
                    true);

        if (showOptionsProp.booleanValue())
        {
            UIService uiService = GuiActivator.getUIService();

            if ((uiService == null)
                    || !uiService.useMacOSXScreenMenuBar()
                    || !registerConfigMenuItemMacOSX())
            {
                registerConfigMenuItemNonMacOSX();
            }
        }

        ResourceManagementService r = GuiActivator.getResources();

        Boolean showConferenceMenuItemProp
            = cfg.getBoolean(CONFERENCE_CALL_DISABLED_PROP,
                            false);

        if(!showConferenceMenuItemProp.booleanValue())
        {
            conferenceMenuItem
                = new JMenuItem(
                    r.getI18NString("service.gui.CREATE_CONFERENCE_CALL"));
            conferenceMenuItem.setMnemonic(
                r.getI18nMnemonic("service.gui.CREATE_CONFERENCE_CALL"));
            conferenceMenuItem.setName("conference");
            conferenceMenuItem.addActionListener(this);
            add(conferenceMenuItem);
        }

        // Add a service listener in order to be notified when a new protocol
        // provider is added or removed and the list should be refreshed.
        GuiActivator.bundleContext.addServiceListener(this);

        initVideoBridgeMenu();

        if(!cfg.getBoolean(AUTO_ANSWER_MENU_DISABLED_PROP, false))
        {
            if(ConfigurationUtils.isAutoAnswerDisableSubmenu())
            {
                this.addSeparator();
                AutoAnswerMenu.registerMenuItems(this);
            }
            else
            {
                AutoAnswerMenu autoAnswerMenu = new AutoAnswerMenu();
                this.add(autoAnswerMenu);
            }
        }

        this.addSeparator();

        // Show/hide offline contacts menu item.
        String offlineTextKey = ConfigurationUtils.isShowOffline()
                            ? "service.gui.HIDE_OFFLINE_CONTACTS"
                            : "service.gui.SHOW_OFFLINE_CONTACTS";

        // The hide offline menu item only makes sense in the contact list.
        if (!isChatMenu)
        {
            hideOfflineMenuItem = new JMenuItem(r.getI18NString(offlineTextKey));
            hideOfflineMenuItem.setMnemonic(r.getI18nMnemonic(offlineTextKey));
            hideOfflineMenuItem.setName("showHideOffline");
            hideOfflineMenuItem.addActionListener(this);
            this.add(hideOfflineMenuItem);
        }

        // Sound on/off menu item.
        String soundTextKey
            = GuiActivator.getAudioNotifier().isMute()
                ? "service.gui.SOUND_ON"
                : "service.gui.SOUND_OFF";

        soundMenuItem = new JMenuItem(r.getI18NString(soundTextKey));
        soundMenuItem.setMnemonic(r.getI18nMnemonic(soundTextKey));
        soundMenuItem.setName("sound");
        soundMenuItem.addActionListener(this);
        this.add(soundMenuItem);

        // All items are now instantiated and we could safely load the skin.
        loadSkin();
    }

    /**
     * Keeps track of the indices of <tt>JSeparator</tt>s
     * that are places within this <tt>Container</tt>
     */
    private List<Integer> separatorIndices = new LinkedList<Integer>();

    /**
     * When a new separator is added to this <tt>Container</tt> its position
     * will be saved in separatorIndices.
     */
    public void addSeparator()
    {
        super.addSeparator();
        separatorIndices.add(this.getMenuComponentCount() - 1);
    }

    /**
     * Inserts the given <tt>JMenuItem</tt> at the end of the specified section.
     * Sections are ordered in the following matter: 0 0 0 | 1 1 | 2 2 ...
     * 
     * @param item The <tt>JMenuItem</tt> that we insert
     * 
     * @param section The section index in which we want to insert the specified
     * <tt>JMenuItem</tt>. If section is < 0 or section is >= the
     * <tt>JSeparator</tt>s count in this menu, this item will be inserted at
     * the end of the menu.
     * 
     * @return The inserted <tt>JMenuItem</tt>
     */
    private JMenuItem insertInSection(JMenuItem item, int section)
    {
        if (section < 0 || section >= separatorIndices.size())
        {
            add(item);
            return item;
        }

        // Gets the index of the separator so we can insert the JMenuItem
        // before it.
        int separatorIndex = separatorIndices.get(section);

        // All following separators' positions must be incremented because we
        // will insert a new JMenuItem before them.
        ListIterator<Integer> it = separatorIndices.listIterator(section);
        while (it.hasNext())
        {
            int i = it.next() + 1;
            it.remove();
            it.add(i);
        }

        insert(item, separatorIndex);
        return item;
    }

    /**
     * Returns a list of all available video bridge providers.
     *
     * @return a list of all available video bridge providers
     */
    private List<ProtocolProviderService> getVideoBridgeProviders()
    {
        List<ProtocolProviderService> activeBridgeProviders
            = new ArrayList<ProtocolProviderService>();

        for (ProtocolProviderService videoBridgeProvider
                : AccountUtils.getRegisteredProviders(
                        OperationSetVideoBridge.class))
        {
            OperationSetVideoBridge videoBridgeOpSet
                = videoBridgeProvider.getOperationSet(
                        OperationSetVideoBridge.class);

            // Check if the video bridge is actually active before adding it to
            // the list of active providers.
            if (videoBridgeOpSet.isActive())
                activeBridgeProviders.add(videoBridgeProvider);
        }

        return activeBridgeProviders;
    }

    /**
     * Initializes the appropriate video bridge menu depending on how many
     * registered providers do we have that support the
     * <tt>OperationSetVideoBridge</tt>.
     */
    private void initVideoBridgeMenu()
    {
        // If video bridge is enabled in the config then add the menu item
        if (GuiActivator.getConfigurationService()
             .getBoolean(OperationSetVideoBridge
                .IS_VIDEO_BRIDGE_DISABLED, false))
        {
            return;
        }

        if (!SwingUtilities.isEventDispatchThread())
        {
            SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    initVideoBridgeMenu();
                }
            });
            return;
        }

        // We create the video default video bridge menu item and set it
        // disabled until we have more information on video bridge support.
        if (videoBridgeMenuItem == null)
        {
            videoBridgeMenuItem = new VideoBridgeProviderMenuItem(
                    GuiActivator.getResources()
                        .getI18NString("service.gui.CREATE_VIDEO_BRIDGE"),
                        null);

            videoBridgeMenuItem.setEnabled(false);

            insert(videoBridgeMenuItem, 1);
        }

        // We re-init the video bridge menu item each time the
        // parent menu is selected in order to be able to refresh the list
        // of available video bridge active providers.
        if (videoBridgeMenuListener == null)
        {
            videoBridgeMenuListener = new VideoBridgeMenuListener();

            addMenuListener(videoBridgeMenuListener);
        }

        // Check the protocol providers supporting video bridge in a new thread.
        if (initVideoBridgeMenuWorker == null)
            initVideoBridgeMenuWorker
                = (OSUtils.IS_MAC)
                    ? new InitVideoBridgeMenuWorkerMacOSX()
                    : new InitVideoBridgeMenuWorker();
        else
            initVideoBridgeMenuWorker.interrupt();

        initVideoBridgeMenuWorker.start();
    }

    /**
     * Runs clean-up for associated resources which need explicit disposal (e.g.
     * listeners keeping this instance alive because they were added to the
     * model which operationally outlives this instance).
     */
    public void dispose()
    {
        GuiActivator.bundleContext.removeServiceListener(this);

        GuiActivator.getUIService().removePluginComponentListener(this);

        /*
         * Let go of all Components contributed by PluginComponents because the
         * latter will still live in the contribution store.
         */
        removeAll();
    }

    /**
     * Initializes the video bridge menu on Mac OSX.
     */
    private class InitVideoBridgeMenuWorkerMacOSX
        extends SwingWorker
    {
        @Override
        protected Object construct()
        {
            Boolean enableMenu = true;
            List<ProtocolProviderService> videoBridgeProviders
                = getVideoBridgeProviders();

            int videoBridgeProviderCount
                = (videoBridgeProviders == null)
                    ? 0 : videoBridgeProviders.size();

            VideoBridgeProviderMenuItem menuItem
                = ((VideoBridgeProviderMenuItem) videoBridgeMenuItem);

            if (videoBridgeProviderCount <= 0)
                enableMenu = false;
            else if (videoBridgeProviderCount == 1)
            {
                menuItem.setPreselectedProvider(videoBridgeProviders.get(0));
                enableMenu = true;
            }
            else if (videoBridgeProviderCount > 1)
            {
                menuItem.setPreselectedProvider(null);
                menuItem.setVideoBridgeProviders(videoBridgeProviders);
                enableMenu = true;
            }

            return enableMenu;
        }

        /**
         * Called on the event dispatching thread (not on the worker thread)
         * after the <code>construct</code> method has returned.
         */
        @Override
        protected void finished()
        {
            Boolean enabled = (Boolean) get();
            if (enabled != null)
                videoBridgeMenuItem.setEnabled(enabled);
        }
    }

    /**
     * The <tt>InitVideoBridgeMenuWorker</tt> initializes the video bridge
     * menu item depending on the number of providers currently supporting video
     * bridge calls.
     */
    private class InitVideoBridgeMenuWorker
        extends SwingWorker
    {
        private ResourceManagementService r = GuiActivator.getResources();

        @Override
        protected Object construct() //throws Exception
        {
            return getVideoBridgeProviders();
        }

        /**
         * Creates the menu item.
         * @param videoBridgeProviders the list of available providers.
         * @return the list of available providers.
         */
        private JMenuItem createNewMenuItem(
            List<ProtocolProviderService> videoBridgeProviders)
        {
            int videoBridgeProviderCount
                = (videoBridgeProviders == null)
                    ? 0 : videoBridgeProviders.size();

            JMenuItem newMenuItem = null;
            if (videoBridgeProviderCount <= 0)
            {
                newMenuItem
                    = new VideoBridgeProviderMenuItem(
                            r.getI18NString("service.gui.CREATE_VIDEO_BRIDGE"),
                            null);
                newMenuItem.setEnabled(false);
            }
            else if (videoBridgeProviderCount == 1)
            {
                newMenuItem
                    = new VideoBridgeProviderMenuItem(
                            r.getI18NString("service.gui.CREATE_VIDEO_BRIDGE"),
                            videoBridgeProviders.get(0));
                newMenuItem.setName("videoBridge");
                newMenuItem.addActionListener(ToolsMenu.this);
            }
            else if (videoBridgeProviderCount > 1)
            {
                newMenuItem
                    = new SIPCommMenu(
                            r.getI18NString(
                                    "service.gui.CREATE_VIDEO_BRIDGE_MENU"));

                for (ProtocolProviderService videoBridgeProvider
                        : videoBridgeProviders)
                {
                    VideoBridgeProviderMenuItem videoBridgeItem
                        = new VideoBridgeProviderMenuItem(videoBridgeProvider);

                    ((JMenu) newMenuItem).add(videoBridgeItem);
                    videoBridgeItem.setIcon(
                        ImageLoader.getAccountStatusImage(videoBridgeProvider));
                }
            }
            return newMenuItem;
        }

        @Override
        @SuppressWarnings("unchecked")
        protected void finished()
        {
            if (videoBridgeMenuItem != null)
            {
                // If the menu item is already created we're going to remove it
                // in order to reinitialize it.
                remove(videoBridgeMenuItem);
            }

            // create the menu items in event dispatch thread
            videoBridgeMenuItem =
                createNewMenuItem((List<ProtocolProviderService>)get());

            videoBridgeMenuItem.setIcon(
                    r.getImage("service.gui.icons.VIDEO_BRIDGE"));
            videoBridgeMenuItem.setMnemonic(
                    r.getI18nMnemonic("service.gui.CREATE_VIDEO_BRIDGE"));

            insert(videoBridgeMenuItem, 1);

            if (isPopupMenuVisible())
            {
                java.awt.Container c = videoBridgeMenuItem.getParent();

                if (c instanceof JComponent)
                {
                    c.revalidate();
                }
                c.repaint();
            }
        }
    }

    /**
     * Registers the preferences item in the MacOS X menu.
     * @return <tt>true</tt> if the operation succeeds, otherwise - returns
     * <tt>false</tt>
     */
    private boolean registerConfigMenuItemMacOSX()
    {
        return FileMenu.registerMenuItemMacOSX("Preferences", this);
    }

    /**
     * Registers the settings item for non-MacOS X OS.
     */
    private void registerConfigMenuItemNonMacOSX()
    {
        ResourceManagementService r = GuiActivator.getResources();

        configMenuItem
            = new JMenuItem(
                    r.getI18NString("service.gui.SETTINGS"),
                    r.getImage("service.gui.icons.CONFIGURE_ICON"));
        add(configMenuItem);
        configMenuItem.setMnemonic(
                r.getI18nMnemonic("service.gui.SETTINGS"));
        configMenuItem.setName("config");
        configMenuItem.addActionListener(this);
    }

    /**
     * Loads menu item icons.
     */
    public void loadSkin()
    {
        ResourceManagementService r = GuiActivator.getResources();

        if (conferenceMenuItem != null)
        {
            conferenceMenuItem.setIcon(
                    r.getImage("service.gui.icons.CONFERENCE_CALL"));
        }

        if (configMenuItem != null)
        {
            configMenuItem.setIcon(
                    r.getImage("service.gui.icons.CONFIGURE_ICON"));
        }

        // The hide offline menu item could be null if the parent window of this
        // menu is a chat window.
        if (hideOfflineMenuItem != null)
            hideOfflineMenuItem.setIcon(
                    r.getImage("service.gui.icons.SHOW_HIDE_OFFLINE_ICON"));

        soundMenuItem.setIcon(
                r.getImage("service.gui.icons.SOUND_MENU_ICON"));
        if (videoBridgeMenuItem != null)
        {
            videoBridgeMenuItem.setIcon(
                    r.getImage("service.gui.icons.VIDEO_BRIDGE"));
        }
    }

    /**
     * The <tt>VideoBridgeProviderMenuItem</tt> for each protocol provider.
     */
    @SuppressWarnings("serial")
    private class VideoBridgeProviderMenuItem
        extends JMenuItem
        implements ActionListener
    {
        private ProtocolProviderService preselectedProvider;

        private List<ProtocolProviderService> videoBridgeProviders;

        /**
         * Creates an instance of <tt>VideoBridgeProviderMenuItem</tt> by
         * specifying the corresponding <tt>ProtocolProviderService</tt> that
         * provides the video bridge.
         *
         * @param protocolProvider the <tt>ProtocolProviderService</tt> that
         * provides the video bridge
         */
        public VideoBridgeProviderMenuItem(
            ProtocolProviderService protocolProvider)
        {
            this (null, protocolProvider);
        }

        /**
         * Creates an instance of <tt>VideoBridgeProviderMenuItem</tt> by
         * specifying the corresponding <tt>ProtocolProviderService</tt> that
         * provides the video bridge.
         *
         * @param name the name of the menu item
         * @param preselectedProvider the <tt>ProtocolProviderService</tt> that
         * provides the video bridge
         */
        public VideoBridgeProviderMenuItem(
                                    String name,
                                    ProtocolProviderService preselectedProvider)
        {
            if (name != null && name.length() > 0)
                setText(name);
            else
                setText(preselectedProvider.getAccountID().getDisplayName());

            this.preselectedProvider = preselectedProvider;

            ResourceManagementService r = GuiActivator.getResources();

            setIcon(r.getImage("service.gui.icons.VIDEO_BRIDGE"));
            setMnemonic(r.getI18nMnemonic("service.gui.CREATE_VIDEO_BRIDGE"));

            addActionListener(this);
        }

        /**
         * Opens a conference invite dialog when this menu is selected.
         */
        public void actionPerformed(ActionEvent event)
        {
            ConferenceInviteDialog inviteDialog;

            if (preselectedProvider != null)
                inviteDialog
                    = new ConferenceInviteDialog(preselectedProvider, true);
            else
                inviteDialog
                    = new ConferenceInviteDialog(videoBridgeProviders, true);

            inviteDialog.setVisible(true);
        }

        public void setPreselectedProvider(
                ProtocolProviderService protocolProvider)
        {
            this.preselectedProvider = protocolProvider;
        }

        public void setVideoBridgeProviders(
                List<ProtocolProviderService> videoBridgeProviders)
        {
            this.videoBridgeProviders = videoBridgeProviders;
        }
    }

    /**
     * Implements the <tt>ServiceListener</tt> method. Verifies whether the
     * passed event concerns a <tt>ProtocolProviderService</tt> and adds the
     * corresponding UI controls in the menu.
     *
     * @param event The <tt>ServiceEvent</tt> object.
     */
    public void serviceChanged(ServiceEvent event)
    {
        ServiceReference serviceRef = event.getServiceReference();

        // if the event is caused by a bundle being stopped, we don't want to
        // know
        if (serviceRef.getBundle().getState() == Bundle.STOPPING)
        {
            return;
        }

        Object service = GuiActivator.bundleContext.getService(serviceRef);

        // we don't care if the source service is not a protocol provider
        if (!(service instanceof ProtocolProviderService))
        {
            return;
        }

        switch (event.getType())
        {
            case ServiceEvent.REGISTERED:
            case ServiceEvent.UNREGISTERING:
                initVideoBridgeMenu();
                break;
        }
    }

    private class VideoBridgeMenuListener implements MenuListener
    {
        public void menuSelected(MenuEvent arg0)
        {
            initVideoBridgeMenu();
        }

        public void menuDeselected(MenuEvent arg0) {}

        public void menuCanceled(MenuEvent arg0) {}
    }
}
