/*******************************************************************************
 * Copyright (c) 2000, 2011 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.jdt.internal.ui.typehierarchy;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.ToolBar;

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;

import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.OpenAndLinkWithEditorHelper;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionGroup;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.ITypeHierarchyViewPart;
import org.eclipse.jdt.ui.actions.CCPActionGroup;
import org.eclipse.jdt.ui.actions.GenerateActionGroup;
import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;
import org.eclipse.jdt.ui.actions.MemberFilterActionGroup;
import org.eclipse.jdt.ui.actions.OpenAction;
import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
import org.eclipse.jdt.ui.actions.RefactorActionGroup;

import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
import org.eclipse.jdt.internal.ui.filters.SyntheticMembersFilter;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
import org.eclipse.jdt.internal.ui.util.SelectionUtil;
import org.eclipse.jdt.internal.ui.viewsupport.ColoredViewersManager;
import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;
import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;

/**
 * Method viewer shows a list of methods of a input type.
 * Offers filter actions.
 * No dependency to the type hierarchy view
 */
public class MethodsViewer extends ProblemTableViewer {

	private static final String TAG_SHOWINHERITED= "showinherited";		 //$NON-NLS-1$
	private static final String TAG_SORTBYDEFININGTYPE= "sortbydefiningtype";		 //$NON-NLS-1$
	private static final String TAG_VERTICAL_SCROLL= "mv_vertical_scroll";		 //$NON-NLS-1$

	MethodsLabelProvider fLabelProvider;

	private MemberFilterActionGroup fMemberFilterActionGroup;

	ShowInheritedMembersAction fShowInheritedMembersAction;
	SortByDefiningTypeAction fSortByDefiningTypeAction;

	public MethodsViewer(Composite parent, final TypeHierarchyLifeCycle lifeCycle) {
		super(new Table(parent, SWT.MULTI));

		addFilter(new SyntheticMembersFilter());

		fLabelProvider= new MethodsLabelProvider(lifeCycle, this);

		setLabelProvider(new DecoratingJavaLabelProvider(fLabelProvider, true));
		setContentProvider(new MethodsContentProvider(lifeCycle));

		HierarchyViewerSorter sorter= new HierarchyViewerSorter(lifeCycle);
		sorter.generated_5989846535832750389(this);

		fMemberFilterActionGroup= new MemberFilterActionGroup(this, "HierarchyMethodView", false, MemberFilterActionGroup.ALL_FILTERS & ~MemberFilterActionGroup.FILTER_LOCALTYPES); //$NON-NLS-1$

		fShowInheritedMembersAction= new ShowInheritedMembersAction(this, false);
		fSortByDefiningTypeAction= new SortByDefiningTypeAction(this, false);

		showInheritedMethodsNoRedraw(false);
		sortByDefiningTypeNoRedraw(false);

		JavaUIHelp.setHelp(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
	}

	private void showInheritedMethodsNoRedraw(boolean on) {
		fLabelProvider.generated_6480767348280018008(this, on);

	}

	/**
	 * Show inherited methods
	 * @param on the new state
	 */
	public void showInheritedMethods(boolean on) {
		if (on == isShowInheritedMethods()) {
			return;
		}
		try {
			getTable().setRedraw(false);
			showInheritedMethodsNoRedraw(on);
			refresh();
		} finally {
			getTable().setRedraw(true);
		}
	}

	void sortByDefiningTypeNoRedraw(boolean on) {
		fSortByDefiningTypeAction.setChecked(on);
		fLabelProvider.setShowDefiningType(on);
		((HierarchyViewerSorter) getComparator()).setSortByDefiningType(on);
	}

	/**
	 * Show the name of the defining type
	 * @param on the new state
	 */
	public void sortByDefiningType(boolean on) {
		if (on == isShowDefiningTypes()) {
			return;
		}
		try {
			getTable().setRedraw(false);
			sortByDefiningTypeNoRedraw(on);
			refresh();
		} finally {
			getTable().setRedraw(true);
		}
	}

	/*
	 * @see Viewer#inputChanged(Object, Object)
	 */
	@Override
	protected void inputChanged(Object input, Object oldInput) {
		super.inputChanged(input, oldInput);
	}

	/**
	 * Returns <code>true</code> if inherited methods are shown.
	 * @return <code>true</code> if inherited methods are shown.
	 */
	public boolean isShowInheritedMethods() {
		return ((MethodsContentProvider) getContentProvider()).isShowInheritedMethods();
	}

	/**
	 * Returns <code>true</code> if defining types are shown.
	 * @return <code>true</code> if defining types are shown.
	 */
	public boolean isShowDefiningTypes() {
		return fLabelProvider.isShowDefiningType();
	}

	/**
	 * Saves the state of the filter actions
	 * @param memento the memento
	 */
	public void saveState(IMemento memento) {
		fMemberFilterActionGroup.saveState(memento);

		memento.putString(TAG_SHOWINHERITED, String.valueOf(isShowInheritedMethods()));
		memento.putString(TAG_SORTBYDEFININGTYPE, String.valueOf(isShowDefiningTypes()));

		ScrollBar bar= getTable().getVerticalBar();
		int position= bar != null ? bar.getSelection() : 0;
		memento.putString(TAG_VERTICAL_SCROLL, String.valueOf(position));
	}

	/**
	 * Restores the state of the filter actions
	 * @param memento the memento
	 */
	public void restoreState(IMemento memento) {
		fMemberFilterActionGroup.restoreState(memento);
		getControl().setRedraw(false);
		refresh();
		getControl().setRedraw(true);

		boolean showInherited= Boolean.valueOf(memento.getString(TAG_SHOWINHERITED)).booleanValue();
		showInheritedMethods(showInherited);

		boolean showDefiningTypes= Boolean.valueOf(memento.getString(TAG_SORTBYDEFININGTYPE)).booleanValue();
		sortByDefiningType(showDefiningTypes);

		ScrollBar bar= getTable().getVerticalBar();
		if (bar != null) {
			Integer vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
			if (vScroll != null) {
				bar.setSelection(vScroll.intValue());
			}
		}
	}

	/**
	 * Attaches a contextmenu listener to the table
	 * @param menuListener the menu listener
	 * @param popupId the popup id
	 * @param viewSite the view site
	 */
	public void initContextMenu(IMenuListener menuListener, String popupId, IWorkbenchPartSite viewSite) {
		MenuManager menuMgr= new MenuManager();
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(menuListener);
		Menu menu= menuMgr.createContextMenu(getTable());
		getTable().setMenu(menu);
		viewSite.registerContextMenu(popupId, menuMgr, this);
	}


	/**
	 * Fills up the context menu with items for the method viewer
	 * Should be called by the creator of the context menu
	 * @param menu teh menu manager
	 */
	public void contributeToContextMenu(IMenuManager menu) {
	}

	/**
	 * Fills up the tool bar with items for the method viewer
	 * Should be called by the creator of the tool bar
	 * @param tbm the tool bar manager
	 */
	public void contributeToToolBar(ToolBarManager tbm) {
		tbm.add(fShowInheritedMembersAction);
		tbm.add(fSortByDefiningTypeAction);
		tbm.add(new Separator());
		fMemberFilterActionGroup.contributeToToolBar(tbm);
	}

	public void dispose() {
		if (fMemberFilterActionGroup != null) {
			fMemberFilterActionGroup.dispose();
			fMemberFilterActionGroup= null;
		}
	}

	/*
	 * @see StructuredViewer#handleInvalidSelection(ISelection, ISelection)
	 */
	@Override
	protected void handleInvalidSelection(ISelection invalidSelection, ISelection newSelection) {
		// on change of input, try to keep selected methods stable by selecting a method with the same
		// signature: See #5466
		List<?> oldSelections= SelectionUtil.toList(invalidSelection);
		List<?> newSelections= SelectionUtil.toList(newSelection);
		if (!oldSelections.isEmpty()) {
			ArrayList<Object> newSelectionElements= new ArrayList<Object>(newSelections);
			try {
				Object[] currElements= getFilteredChildren(getInput());
				for (int i= 0; i < oldSelections.size(); i++) {
					Object curr= oldSelections.get(i);
					if (curr instanceof IMethod && !newSelections.contains(curr)) {
						IMethod method= (IMethod) curr;
						if (method.exists()) {
							IMethod similar= findSimilarMethod(method, currElements);
							if (similar != null) {
								newSelectionElements.add(similar);
							}
						}
					}
				}
				if (!newSelectionElements.isEmpty()) {
					newSelection= new StructuredSelection(newSelectionElements);
				} else if (currElements.length > 0) {
					newSelection= new StructuredSelection(currElements[0]);
				}
			} catch (JavaModelException e) {
				JavaPlugin.log(e);
			}
		}
		setSelection(newSelection);
		updateSelection(newSelection);
	}

	private IMethod findSimilarMethod(IMethod meth, Object[] elements) throws JavaModelException {
		String name= meth.getElementName();
		String[] paramTypes= meth.getParameterTypes();
		boolean isConstructor= meth.isConstructor();

		for (int i= 0; i < elements.length; i++) {
			Object curr= elements[i];
			if (curr instanceof IMethod && JavaModelUtil.isSameMethodSignature(name, paramTypes, isConstructor, (IMethod) curr)) {
				return (IMethod) curr;
			}
		}
		return null;
	}

	public Color generated_3011243774092129860(Object element) {
		if (isShowInheritedMethods() && element instanceof IMethod) {
			IMethod curr= (IMethod) element;
			IMember declaringType= curr.getDeclaringType();
	
			if (!declaringType.equals(getInput())) {
				return JFaceResources.getColorRegistry().get(ColoredViewersManager.INHERITED_COLOR_NAME);
			}
		}
		return null;
	}

	public void generated_4539304762393197955(final SortByDefiningTypeAction sortbydefiningtypeaction) {
		BusyIndicator.showWhile(getControl().getDisplay(), new Runnable() {
			public void run() {
				sortByDefiningType(sortbydefiningtypeaction.isChecked());
			}
		});
	}

	public void generated_8325136787416579103(TypeHierarchyViewPart typehierarchyviewpart, IMember member) {
		typehierarchyviewpart.fSelectInEditor= false;
		if (member.getElementType() != IJavaElement.TYPE) {
			Control methodControl= getControl();
			if (methodControl != null && !methodControl.isDisposed()) {
				methodControl.setFocus();
			}
	
			setSelection(new StructuredSelection(member), true);
		} else {
			Control viewerControl= typehierarchyviewpart.getCurrentViewer().getControl();
			if (viewerControl != null && !viewerControl.isDisposed()) {
				viewerControl.setFocus();
			}
	
			if (!member.equals(typehierarchyviewpart.fSelectedType)) {
				typehierarchyviewpart.getCurrentViewer().setSelection(new StructuredSelection(member), true);
			}
		}
	}

	public Control generated_356516589937347256(final TypeHierarchyViewPart typehierarchyviewpart) {
		initContextMenu(new IMenuListener() {
			public void menuAboutToShow(IMenuManager menu) {
				typehierarchyviewpart.fillMethodsViewerContextMenu(menu);
			}
		}, IContextMenuConstants.TARGET_ID_MEMBERS_VIEW, typehierarchyviewpart.getSite());
		addPostSelectionChangedListener(typehierarchyviewpart.fSelectionChangedListener);
	
		new OpenAndLinkWithEditorHelper(this) {
			@Override
			protected void activate(ISelection selection) {
				try {
					final Object selectedElement= SelectionUtil.getSingleElement(selection);
					if (EditorUtility.isOpenInEditor(selectedElement) != null)
						EditorUtility.openInEditor(selectedElement, true);
				} catch (PartInitException ex) {
					// ignore if no editor input can be found
				}
			}
	
			@Override
			protected void linkToEditor(ISelection selection) {
				// do nothing: this is handled in more detail by the part itself
			}
	
			@Override
			protected void open(ISelection selection, boolean activate) {
				if (selection instanceof IStructuredSelection)
					typehierarchyviewpart.fOpenAction.run((IStructuredSelection)selection);
			}
		};
	
		Control control= getTable();
		control.addKeyListener(typehierarchyviewpart.createKeyListener());
		return control;
	}

	public DropTarget generated_1359601309272706539(TypeHierarchyViewPart typehierarchyviewpart) {
		for (int i= 0; i < typehierarchyviewpart.fAllViewers.length; i++) {
			typehierarchyviewpart.addDragAdapters(typehierarchyviewpart.fAllViewers[i]);
			typehierarchyviewpart.addDropAdapters(typehierarchyviewpart.fAllViewers[i]);
		}
		typehierarchyviewpart.addDragAdapters(this);
		addDropSupport(DND.DROP_NONE, new Transfer[0], new DropTargetAdapter());
	
		//DND on empty hierarchy
		DropTarget dropTarget = new DropTarget(typehierarchyviewpart.fPagebook, DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT);
		return dropTarget;
	}

	public IActionBars generated_3457398075108290302(TypeHierarchyViewPart typehierarchyviewpart, ToolBar methodViewerToolBar) {
		int layout;
		try {
			layout= typehierarchyviewpart.fDialogSettings.getInt(TypeHierarchyViewPart.DIALOGSTORE_VIEWLAYOUT);
			if (layout < 0 || layout > 3) {
				layout= ITypeHierarchyViewPart.VIEW_LAYOUT_AUTOMATIC;
			}
		} catch (NumberFormatException e) {
			layout= ITypeHierarchyViewPart.VIEW_LAYOUT_AUTOMATIC;
		}
		// force the update
		typehierarchyviewpart.fCurrentLayout= -1;
		// will fill the main tool bar
		typehierarchyviewpart.setViewLayout(layout);
	
		typehierarchyviewpart.showQualifiedTypeNames(typehierarchyviewpart.fDialogSettings.getBoolean(TypeHierarchyViewPart.DIALOGSTORE_QUALIFIED_NAMES));
		typehierarchyviewpart.setLinkingEnabled(typehierarchyviewpart.fDialogSettings.getBoolean(TypeHierarchyViewPart.DIALOGSTORE_LINKEDITORS));
	
		// set the filter menu items
		IActionBars actionBars= typehierarchyviewpart.getViewSite().getActionBars();
		IMenuManager viewMenu= actionBars.getMenuManager();
		for (int i= 0; i < typehierarchyviewpart.fViewActions.length; i++) {
			ToggleViewAction action= typehierarchyviewpart.fViewActions[i];
			viewMenu.add(action);
			action.setEnabled(false);
		}
		viewMenu.add(new Separator());
	
		typehierarchyviewpart.fWorkingSetActionGroup.fillViewMenu(viewMenu);
	
		viewMenu.add(new Separator());
	
		IMenuManager layoutSubMenu= new MenuManager(TypeHierarchyMessages.TypeHierarchyViewPart_layout_submenu);
		viewMenu.add(layoutSubMenu);
		for (int i= 0; i < typehierarchyviewpart.fToggleOrientationActions.length; i++) {
			layoutSubMenu.add(typehierarchyviewpart.fToggleOrientationActions[i]);
		}
		viewMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
		viewMenu.add(typehierarchyviewpart.fShowQualifiedTypeNamesAction);
		viewMenu.add(typehierarchyviewpart.fToggleLinkingAction);
	
	
		// fill the method viewer tool bar
		ToolBarManager lowertbmanager= new ToolBarManager(methodViewerToolBar);
		lowertbmanager.add(typehierarchyviewpart.fEnableMemberFilterAction);
		lowertbmanager.add(new Separator());
		contributeToToolBar(lowertbmanager);
		lowertbmanager.update(true);
	
		// selection provider
		int nHierarchyViewers= typehierarchyviewpart.fAllViewers.length;
		StructuredViewer[] trackedViewers= new StructuredViewer[nHierarchyViewers + 1];
		for (int i= 0; i < nHierarchyViewers; i++) {
			trackedViewers[i]= typehierarchyviewpart.fAllViewers[i];
		}
		trackedViewers[nHierarchyViewers]= this;
		typehierarchyviewpart.fSelectionProviderMediator= new SelectionProviderMediator(trackedViewers, typehierarchyviewpart.getCurrentViewer());
		IStatusLineManager slManager= typehierarchyviewpart.getViewSite().getActionBars().getStatusLineManager();
		typehierarchyviewpart.fSelectionProviderMediator.addSelectionChangedListener(new StatusBarUpdater(slManager));
	
		typehierarchyviewpart.getSite().setSelectionProvider(typehierarchyviewpart.fSelectionProviderMediator);
		typehierarchyviewpart.getSite().getPage().addPartListener(typehierarchyviewpart.fPartListener);
	
		if (typehierarchyviewpart.fMemento != null)
			typehierarchyviewpart.restoreState(typehierarchyviewpart.fMemento);
		else
			typehierarchyviewpart.setViewerVisibility(false);
	
		PlatformUI.getWorkbench().getHelpSystem().setHelp(typehierarchyviewpart.fPagebook, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
	
	
		typehierarchyviewpart.fActionGroups= new CompositeActionGroup(new ActionGroup[] {
				new NewWizardsActionGroup(typehierarchyviewpart.getSite()),
				new OpenEditorActionGroup(typehierarchyviewpart),
				new OpenViewActionGroup(typehierarchyviewpart),
				new CCPActionGroup(typehierarchyviewpart),
				new GenerateActionGroup(typehierarchyviewpart),
				new RefactorActionGroup(typehierarchyviewpart),
				new JavaSearchActionGroup(typehierarchyviewpart)
		});
	
		typehierarchyviewpart.fActionGroups.fillActionBars(actionBars);
		typehierarchyviewpart.fSelectAllAction= new SelectAllAction(this);
		typehierarchyviewpart.fOpenAction= new OpenAction(typehierarchyviewpart.getSite());
		return actionBars;
	}

	public void generated_3262187007324139874(TypeHierarchyViewPart typehierarchyviewpart, boolean on) {
		if (on != typehierarchyviewpart.fIsEnableMemberFilter) {
			typehierarchyviewpart.fIsEnableMemberFilter= on;
			if (!on) {
				IType methodViewerInput= (IType) getInput();
				typehierarchyviewpart.setMemberFilter(null);
				typehierarchyviewpart.updateHierarchyViewer(true);
				typehierarchyviewpart.updateToolTipAndDescription();
	
				if (methodViewerInput != null && typehierarchyviewpart.getCurrentViewer().isElementShown(methodViewerInput)) {
					// avoid that the method view changes content by selecting the previous input
					typehierarchyviewpart.internalSelectType(methodViewerInput, true);
				} else if (typehierarchyviewpart.fSelectedType != null) {
					// choose a input that exists
					typehierarchyviewpart.internalSelectType(typehierarchyviewpart.fSelectedType, true);
					typehierarchyviewpart.updateMethodViewer(typehierarchyviewpart.fSelectedType);
				}
			} else {
				typehierarchyviewpart.methodSelectionChanged(getSelection());
			}
		}
	}

	public Object generated_8968129359984973293() {
		Object methodViewerInput= getInput();
		refresh();
		return methodViewerInput;
	}

	public void generated_5765350795097787896(final ShowInheritedMembersAction showinheritedmembersaction) {
		BusyIndicator.showWhile(getControl().getDisplay(), new Runnable() {
			public void run() {
				showInheritedMethods(showinheritedmembersaction.isChecked());
			}
		});
	}



}