/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.ui.internal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.internal.util.Util;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.views.IViewDescriptor;
import org.eclipse.ui.views.IViewRegistry;

/**
 * A <code>ShowInMenu</code> is used to populate a menu manager with
 * Show In actions.  The items to show are determined from the active perspective
 * and active part. 
 */
public class ShowInMenu extends ContributionItem {

    private static final String NO_TARGETS_MSG = WorkbenchMessages.Workbench_showInNoTargets;

    private IWorkbenchWindow window;

    private Map actions = new HashMap(21);

    private boolean dirty = true;

    private IMenuListener menuListener = new IMenuListener() {
        public void menuAboutToShow(IMenuManager manager) {
            manager.markDirty();
            dirty = true;
        }
    };

    /**
     * Creates a Show In menu.
     *
     * @param window the window containing the menu
     */
    public ShowInMenu(IWorkbenchWindow window, String id) {
        super(id);
        this.window = window;
    }

    protected IWorkbenchWindow getWindow() {
        return window;
    }

    public boolean isDirty() {
        return dirty;
    }

    /**
     * Overridden to always return true and force dynamic menu building.
     */
    public boolean isDynamic() {
        return true;
    }

    public void fill(Menu menu, int index) {
        if (getParent() instanceof MenuManager) {
			((MenuManager) getParent()).addMenuListener(menuListener);
		}

        if (!dirty) {
			return;
		}

        MenuManager manager = new MenuManager();
        fillMenu(manager);
        IContributionItem[] items = manager.getItems();
        if (items.length == 0) {
            MenuItem item = new MenuItem(menu, SWT.NONE, index++);
            item.setText(NO_TARGETS_MSG);
            item.setEnabled(false);
        } else {
            for (int i = 0; i < items.length; i++) {
                items[i].fill(menu, index++);
            }
        }
        dirty = false;
    }

    /**
     * Fills the menu with Show In actions.
     */
    private void fillMenu(IMenuManager innerMgr) {
        // Remove all.
        innerMgr.removeAll();

        IWorkbenchPart sourcePart = getSourcePart();
        if (sourcePart == null) {
            return;
        }
        ShowInContext context = getContext(sourcePart);
        if (context == null) {
            return;
        }
        if (context.getInput() == null
                && (context.getSelection() == null || context.getSelection()
                        .isEmpty())) {
            return;
        }

        IViewDescriptor[] viewDescs = getViewDescriptors(sourcePart);
        if (viewDescs.length == 0) {
            return;
        }

        for (int i = 0; i < viewDescs.length; ++i) {
            IAction action = getAction(viewDescs[i]);
            if (action != null) {
                innerMgr.add(action);
            }
        }
    }

    /**
     * Returns the action for the given view id, or null if not found.
     */
    private IAction getAction(IViewDescriptor desc) {
        // Keep a cache, rather than creating a new action each time,
        // so that image caching in ActionContributionItem works.
        IAction action = (IAction) actions.get(desc.getId());
        if (action == null) {
            if (desc != null) {
                action = new ShowInAction(window, desc);
                actions.put(desc.getId(), action);
            }
        }
        return action;
    }

    /**
     * Returns the Show In... target part ids for the given source part.  
     * Merges the contributions from the current perspective and the source part.
     */
    private ArrayList getShowInPartIds(IWorkbenchPart sourcePart) {
        ArrayList targetIds = new ArrayList();
        WorkbenchPage page = (WorkbenchPage) getWindow().getActivePage();
        if (page != null) {
            targetIds.addAll(page.getShowInPartIds());
        }
        IShowInTargetList targetList = getShowInTargetList(sourcePart);
        if (targetList != null) {
            String[] partIds = targetList.getShowInTargetIds();
            if (partIds != null) {
                for (int i = 0; i < partIds.length; ++i) {
                    if (!targetIds.contains(partIds[i])) {
                        targetIds.add(partIds[i]);
                    }
                }
            }
        }
        page.sortShowInPartIds(targetIds);
        return targetIds;
    }

    /**
     * Returns the source part, or <code>null</code> if there is no applicable
     * source part
     * <p>
     * This implementation returns the current part in the window.
     * Subclasses may extend or reimplement.
     * 
     * @return the source part or <code>null</code>
     */
    private IWorkbenchPart getSourcePart() {
        IWorkbenchPage page = getWindow().getActivePage();
        if (page != null) {
            return page.getActivePart();
        }
        return null;
    }

    /**
     * Returns the <code>IShowInSource</code> provided by the source part,
     * or <code>null</code> if it does not provide one.
     * 
     * @param sourcePart the source part
     * @return an <code>IShowInSource</code> or <code>null</code>
     */
    private IShowInSource getShowInSource(IWorkbenchPart sourcePart) {
        return (IShowInSource)Util.getAdapter(sourcePart, IShowInSource.class);
    }

    /**
     * Returns the <code>IShowInTargetList</code> for the given source part,
     * or <code>null</code> if it does not provide one.
     * 
     * @param sourcePart the source part
     * @return the <code>IShowInTargetList</code> or <code>null</code>
     */
    private IShowInTargetList getShowInTargetList(IWorkbenchPart sourcePart) {
        return (IShowInTargetList)Util.getAdapter(sourcePart, IShowInTargetList.class);
    }

    /**
     * Returns the <code>ShowInContext</code> to show in the selected target,
     * or <code>null</code> if there is no valid context to show.
     * <p>
     * This implementation obtains the context from the <code>IShowInSource</code>
     * of the source part (if provided), or, if the source part is an editor,
     * it creates the context from the editor's input and selection.
     * <p>
     * Subclasses may extend or reimplement.
     * 
     * @return the <code>ShowInContext</code> to show or <code>null</code>
     */
    private ShowInContext getContext(IWorkbenchPart sourcePart) {
        IShowInSource source = getShowInSource(sourcePart);
        if (source != null) {
            ShowInContext context = source.getShowInContext();
            if (context != null) {
                return context;
            }
        } else if (sourcePart instanceof IEditorPart) {
            Object input = ((IEditorPart) sourcePart).getEditorInput();
            ISelectionProvider sp = sourcePart.getSite().getSelectionProvider();
            ISelection sel = sp == null ? null : sp.getSelection();
            return new ShowInContext(input, sel);
        }
        return null;
    }

    /**
     * Returns the view descriptors to show in the dialog.
     */
    private IViewDescriptor[] getViewDescriptors(IWorkbenchPart sourcePart) {
        String srcId = sourcePart.getSite().getId();
        ArrayList ids = getShowInPartIds(sourcePart);
        ArrayList descs = new ArrayList();
        IViewRegistry reg = WorkbenchPlugin.getDefault().getViewRegistry();
        for (Iterator i = ids.iterator(); i.hasNext();) {
            String id = (String) i.next();
            if (!id.equals(srcId)) {
                IViewDescriptor desc = reg.find(id);
                if (desc != null) {
                    descs.add(desc);
                }
            }
        }
        return (IViewDescriptor[]) descs.toArray(new IViewDescriptor[descs
                .size()]);
    }

}