/*=============================================================================#
 # Copyright (c) 2009, 2018 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.internal.r.objectbrowser;

import static org.eclipse.statet.ecommons.ui.actions.UIActions.ADDITIONS_GROUP_ID;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler2;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.commands.IElementUpdater;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.handlers.CollapseAllHandler;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.menus.CommandContributionItemParameter;
import org.eclipse.ui.menus.UIElement;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

import org.eclipse.statet.ecommons.collections.FastList;
import org.eclipse.statet.ecommons.models.core.util.ElementPartition;
import org.eclipse.statet.ecommons.ts.core.Tool;
import org.eclipse.statet.ecommons.ts.core.ToolRunnable;
import org.eclipse.statet.ecommons.ui.actions.HandlerContributionItem;
import org.eclipse.statet.ecommons.ui.actions.SearchContributionItem;
import org.eclipse.statet.ecommons.ui.components.StatusInfo;
import org.eclipse.statet.ecommons.ui.dialogs.DialogUtils;
import org.eclipse.statet.ecommons.ui.util.ColumnHoverManager;
import org.eclipse.statet.ecommons.ui.util.ColumnHoverStickyManager;
import org.eclipse.statet.ecommons.ui.util.ColumnWidgetTokenOwner;
import org.eclipse.statet.ecommons.ui.util.InformationDispatchHandler;
import org.eclipse.statet.ecommons.ui.util.LayoutUtils;
import org.eclipse.statet.ecommons.ui.util.PostSelectionProviderProxy;
import org.eclipse.statet.ecommons.ui.util.StatusLineMessageManager;
import org.eclipse.statet.ecommons.ui.util.TreeSelectionProxy;
import org.eclipse.statet.ecommons.ui.util.UIAccess;
import org.eclipse.statet.ecommons.ui.workbench.WorkbenchUIUtils;

import org.eclipse.statet.base.ui.StatetImages;
import org.eclipse.statet.internal.r.ui.RUIPlugin;
import org.eclipse.statet.internal.r.ui.rtools.RunPrintInR;
import org.eclipse.statet.ltk.core.IElementName;
import org.eclipse.statet.ltk.ui.IElementNameProvider;
import org.eclipse.statet.ltk.ui.sourceediting.ISourceEditorCommandIds;
import org.eclipse.statet.ltk.ui.sourceediting.assist.IInfoHover;
import org.eclipse.statet.ltk.ui.util.ViewerDragSupport;
import org.eclipse.statet.nico.core.runtime.ToolProcess;
import org.eclipse.statet.nico.core.util.IToolProvider;
import org.eclipse.statet.nico.core.util.IToolRetargetable;
import org.eclipse.statet.nico.ui.IToolRegistry;
import org.eclipse.statet.nico.ui.IToolRegistryListener;
import org.eclipse.statet.nico.ui.NicoUI;
import org.eclipse.statet.nico.ui.ToolSessionUIData;
import org.eclipse.statet.nico.ui.actions.ToolRetargetableHandler;
import org.eclipse.statet.r.console.core.AbstractRDataRunnable;
import org.eclipse.statet.r.console.core.IRDataAdapter;
import org.eclipse.statet.r.console.core.RConsoleTool;
import org.eclipse.statet.r.console.core.RProcess;
import org.eclipse.statet.r.console.core.RProcessREnvironment;
import org.eclipse.statet.r.console.core.RWorkspace;
import org.eclipse.statet.r.core.data.CombinedRElement;
import org.eclipse.statet.r.core.model.RElementComparator;
import org.eclipse.statet.r.core.model.RElementName;
import org.eclipse.statet.r.ui.RLabelProvider;
import org.eclipse.statet.r.ui.rtool.RElementInfoHoverCreator;
import org.eclipse.statet.r.ui.rtool.RElementInfoTask;
import org.eclipse.statet.rj.data.RObject;
import org.eclipse.statet.rj.data.RReference;


public class ObjectBrowserView extends ViewPart implements IToolProvider {
	
	
	private static final String FILTER_USERSPACEONLY_SETTINGS_KEY = "filter.only_userspace.enabled"; //$NON-NLS-1$
	private static final String FILTER_INTERNALINCLUDE_SETTINGS_KEY = "filter.include_internal.enabled"; //$NON-NLS-1$
	private static final String SORT_BYTYPE_SETTINGS_KEY = "sort.by_name.enabled"; //$NON-NLS-1$
	
	static final RElementComparator ELEMENTNAME_COMPARATOR = new RElementComparator();
	private static final ViewerComparator TYPE_COMPARATOR = new SortByTypeComparator();
	
	private static final String OPEN_COMMAND_ID = "org.eclipse.jdt.ui.edit.text.java.open.editor"; //$NON-NLS-1$
	
	
	private class RefreshWorkspaceR extends AbstractRDataRunnable {
		
		public RefreshWorkspaceR() {
			super("r/objectbrowser/refreshWorkspace.force", "Update Object Browser"); //$NON-NLS-1$
		}
		
		@Override
		public boolean changed(final int event, final Tool tool) {
			if (event == MOVING_FROM) {
				return false;
			}
			return true;
		}
		
		@Override
		protected void run(final IRDataAdapter r,
				final IProgressMonitor monitor) throws CoreException {
			boolean current;
			synchronized (ObjectBrowserView.this.processLock) {
				current = (r.getTool() != getTool());
			}
			final IWorkbenchSiteProgressService progressService = getViewSite().getService(IWorkbenchSiteProgressService.class);
			if (current && progressService != null) {
				progressService.incrementBusy();
			}
			try {
				ObjectBrowserView.this.fInputUpdater.forceOnWorkspaceChange();
				r.refreshWorkspaceData(RWorkspace.REFRESH_COMPLETE, monitor);
			}
			finally {
				if (current && progressService != null) {
					progressService.decrementBusy();
				}
			}
		}
		
	}
	
	private class RefreshHandler extends ToolRetargetableHandler {
		
		private final ElementUpdater fUpdater = new ElementUpdater(IWorkbenchCommandConstants.FILE_REFRESH);
		
		public RefreshHandler() {
			super(ObjectBrowserView.this, getSite());
			init();
		}
		
		@Override
		protected Object doExecute(final ExecutionEvent event) {
			scheduleUpdateAll();
			return null;
		}
		
		@Override
		protected void doRefresh() {
			super.doRefresh();
			this.fUpdater.schedule();
		}
		
	}
	
	private class FilterUserspaceHandler extends AbstractHandler implements IElementUpdater {
		
		@Override
		public Object execute(final ExecutionEvent event) throws ExecutionException {
			ObjectBrowserView.this.fFilterUserspace = !ObjectBrowserView.this.fFilterUserspace;
			ObjectBrowserView.this.fSettings.put(FILTER_USERSPACEONLY_SETTINGS_KEY, ObjectBrowserView.this.fFilterUserspace);
			ObjectBrowserView.this.fInputUpdater.forceUpdate(ObjectBrowserView.this.process);
			ObjectBrowserView.this.fInputUpdater.schedule();
			return null;
		}
		
		@Override
		public void updateElement(final UIElement element, final Map parameters) {
			WorkbenchUIUtils.aboutToUpdateCommandsElements(this, element);
			try {
				element.setChecked(ObjectBrowserView.this.fFilterUserspace);
			}
			finally {
				WorkbenchUIUtils.finalizeUpdateCommandsElements(this);
			}
		}
		
	}
	
	private class FilterInternalHandler extends AbstractHandler implements IElementUpdater {
		
		@Override
		public Object execute(final ExecutionEvent event) throws ExecutionException {
			ObjectBrowserView.this.fFilterIncludeInternal = !ObjectBrowserView.this.fFilterIncludeInternal;
			ObjectBrowserView.this.fSettings.put(FILTER_INTERNALINCLUDE_SETTINGS_KEY, ObjectBrowserView.this.fFilterIncludeInternal);
			updateFilter();
			return null;
		}
		
		@Override
		public void updateElement(final UIElement element, final Map parameters) {
			WorkbenchUIUtils.aboutToUpdateCommandsElements(this, element);
			try {
				element.setChecked(ObjectBrowserView.this.fFilterIncludeInternal);
			}
			finally {
				WorkbenchUIUtils.finalizeUpdateCommandsElements(this);
			}
		}
		
	}
	
	private class SortByTypeHandler extends AbstractHandler implements IElementUpdater {
		
		@Override
		public Object execute(final ExecutionEvent event) throws ExecutionException {
			ObjectBrowserView.this.fSortByType = !ObjectBrowserView.this.fSortByType;
			ObjectBrowserView.this.fSettings.put(SORT_BYTYPE_SETTINGS_KEY, ObjectBrowserView.this.fSortByType);
			updateSorter();
			return null;
		}
		
		@Override
		public void updateElement(final UIElement element, final Map parameters) {
			WorkbenchUIUtils.aboutToUpdateCommandsElements(this, element);
			try {
				element.setChecked(ObjectBrowserView.this.fSortByType);
			}
			finally {
				WorkbenchUIUtils.finalizeUpdateCommandsElements(this);
			}
		}
		
	}
	
	private class TreeElementSelection extends TreeSelectionProxy implements IElementNameProvider {
		
		public TreeElementSelection(final ITreeSelection selection) {
			super(selection);
		}
		
		@Override
		public IElementName getElementName(final Object selectionElement) {
			if (selectionElement instanceof TreePath) { 
				return getFQElementName((TreePath) selectionElement);
			}
			return null;
		}
		
	}
	
	private class TreeSelectionProvider extends PostSelectionProviderProxy {
		
		public TreeSelectionProvider() {
			super(ObjectBrowserView.this.fTreeViewer);
		}
		
		@Override
		protected ISelection getSelection(final ISelection originalSelection) {
			return new TreeElementSelection((ITreeSelection) originalSelection);
		}
		
	}
	
	private class HoverManager extends ColumnHoverManager {
		
		HoverManager() {
			super(ObjectBrowserView.this.fTreeViewer, ObjectBrowserView.this.fTokenOwner, new RElementInfoHoverCreator(IInfoHover.MODE_TOOLTIP));
			
			final ColumnHoverStickyManager stickyManager = new ColumnHoverStickyManager(ObjectBrowserView.this.fTokenOwner, this);
			getInternalAccessor().setInformationControlReplacer(stickyManager);
		}
		
		@Override
		protected Object prepareHoverInformation(final ViewerCell cell) {
			final TreePath treePath = cell.getViewerRow().getTreePath();
			final RElementName elementName = getFQElementName(treePath);
			if (elementName != null && elementName.getScope() != null) {
				return elementName;
			}
			return null;
		}
		
		@Override
		protected Object getHoverInformation(final Object element) {
			if (element instanceof RElementName && ObjectBrowserView.this.process != null) {
				final RElementInfoTask updater = new RElementInfoTask((RElementName) element);
				return updater.load(getTool(), getSubjectControl(), ObjectBrowserView.this);
			}
			return null;
		}
		
	}
	
	
	private TreeViewer fTreeViewer;
	private TreeSelectionProvider fTreeSelectionProvider;
	private ColumnWidgetTokenOwner fTokenOwner;
	private Clipboard fClipboard;
	private StatusLineMessageManager statusLine;
	
	private IDialogSettings fSettings;
	
	final Object processLock = new Object();
	private RProcess process; // note: we write only in ui thread
	
	private IToolRegistryListener fToolRegistryListener;
	private final FastList<IToolRetargetable> fToolListenerList= new FastList<>(IToolRetargetable.class);
	
	private final RefreshWorkspaceR fManualRefreshRunnable = new RefreshWorkspaceR();
	
	private final ContentJob fInputUpdater = new ContentJob(this);
	
	private ContentProvider contentProvider;
	
	private boolean fFilterUserspace;
	private boolean fFilterIncludeInternal;
	private String fFilterText;
	private boolean fSortByType;
	
	private SearchContributionItem fSearchTextItem;
	
	private boolean fFilterUserspaceActivated;
	
	private CopyElementNameHandler fCopyElementNameHandler;
	private DeleteHandler fDeleteElementHandler;
	private PrintHandler fPrintElementHandler;
	private IHandler2 fOpenInEditorHandler;
	
	private Object fCurrentInfoObject;
	
	private ColumnHoverManager fHoveringController;
	
	private AbstractHandler fSearchStartHandler;
	
	private HandlerContributionItem fRefreshToolbarItem;
	private HandlerContributionItem fRefreshMenuItem;
	private boolean fRefreshDirtyIndicator;
	
	
	public ObjectBrowserView() {
	}
	
	@Override
	public void init(final IViewSite site, final IMemento memento) throws PartInitException {
		super.init(site, memento);
		
		this.statusLine = new StatusLineMessageManager(site.getActionBars().getStatusLineManager());
		
		this.fSettings = DialogUtils.getDialogSettings(RUIPlugin.getInstance(), "ObjectBrowser");
		
		this.fFilterUserspaceActivated = this.fFilterUserspace = this.fSettings.getBoolean(FILTER_USERSPACEONLY_SETTINGS_KEY);
		this.fFilterIncludeInternal = this.fSettings.getBoolean(FILTER_INTERNALINCLUDE_SETTINGS_KEY);
		this.fSortByType = this.fSettings.getBoolean(SORT_BYTYPE_SETTINGS_KEY);
	}
	
	@Override
	public void saveState(final IMemento memento) {
		super.saveState(memento);
		
		this.fSettings = DialogUtils.getDialogSettings(RUIPlugin.getInstance(), "ObjectBrowser");
	}
	
	
	@Override
	public void createPartControl(final Composite parent) {
		parent.setLayout(LayoutUtils.newSashGrid());
		
		this.fTreeViewer = new TreeViewer(parent, SWT.V_SCROLL | SWT.H_SCROLL | SWT.MULTI);
		this.fTreeViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 3));
		this.fTreeViewer.setUseHashlookup(true);
		
		this.fTreeSelectionProvider = new TreeSelectionProvider();
		
		this.fTreeViewer.setLabelProvider(new RLabelProvider(RLabelProvider.COUNT) {
			@Override
			protected String getEnvCountInfo(final RProcessREnvironment envir) {
				final StringBuilder textBuilder = getTextBuilder();
				textBuilder.append(" ("); //$NON-NLS-1$
				final ContentInput input = ObjectBrowserView.this.contentProvider.getInput();
				if (input != null && input.hasEnvFilter()) {
					final Object[] children = input.getEnvFilterChildren(envir);
					if (children != null) {
						textBuilder.append(children.length);
					}
					else {
						textBuilder.append('-');
					}
					textBuilder.append('/');
				}
				textBuilder.append(envir.getLength());
				textBuilder.append(')');
				return textBuilder.toString();
			}
		});
		this.fTreeViewer.addDoubleClickListener(new IDoubleClickListener() {
			@Override
			public void doubleClick(final DoubleClickEvent event) {
				final IStructuredSelection selection = (IStructuredSelection) event.getSelection();
				if (selection.size() != 1) {
					return;
				}
				final Object element = selection.getFirstElement();
				if (element instanceof RObject) {
					final RObject object = (RObject) element;
					switch (object.getRObjectType()) {
					case RObject.TYPE_ENVIRONMENT:
					case RObject.TYPE_LIST:
					case RObject.TYPE_DATAFRAME:
					case RObject.TYPE_S4OBJECT:
					case RObject.TYPE_REFERENCE:
						ObjectBrowserView.this.fTreeViewer.setExpandedState(element, !ObjectBrowserView.this.fTreeViewer.getExpandedState(element));
					}
				}
			}
		});
		this.fTreeSelectionProvider.addPostSelectionChangedListener(new ISelectionChangedListener() {
			@Override
			public void selectionChanged(final SelectionChangedEvent event) {
				updateSelectionInfo((ITreeSelection) event.getSelection());
			}
		});
		this.contentProvider = new ContentProvider();
		this.fTreeViewer.setContentProvider(this.contentProvider);
		updateSorter();
		this.fTreeViewer.setInput(this);
		
		this.fTokenOwner = new ColumnWidgetTokenOwner(this.fTreeViewer);
		this.fHoveringController = new HoverManager();
		this.fHoveringController.setSizeConstraints(100, 12, false, true);
		this.fHoveringController.install(this.fTreeViewer.getTree());
		
		createActions();
		hookContextMenu();
		getSite().setSelectionProvider(this.fTreeSelectionProvider);
		
		final ViewerDragSupport dragSupport = new ViewerDragSupport(this.fTreeViewer);
		dragSupport.addDragSourceListener(new ViewerDragSupport.TextDragSourceListener(this.fTreeViewer));
		dragSupport.init();
		
		// listen on console changes
		final IToolRegistry toolRegistry = NicoUI.getToolRegistry();
		this.fToolRegistryListener = new IToolRegistryListener() {
			@Override
			public void toolSessionActivated(final ToolSessionUIData sessionData) {
				final ToolProcess process = sessionData.getProcess();
				UIAccess.getDisplay().syncExec(new Runnable() {
					@Override
					public void run() {
						connect(process);
					}
				});
			}
			@Override
			public void toolTerminated(final ToolSessionUIData sessionData) {
				final ToolProcess process = sessionData.getProcess();
				UIAccess.getDisplay().syncExec(new Runnable() {
					@Override
					public void run() {
						if (process == getTool()) {
							connect(null);
						}
					}
				});
			}
		};
		toolRegistry.addListener(this.fToolRegistryListener, getViewSite().getPage());
		connect(toolRegistry.getActiveToolSession(getViewSite().getPage()).getProcess());
	}
	
	TreeViewer getViewer() {
		return this.fTreeViewer;
	}
	
	private void createActions() {
		final IHandlerService handlerService = getSite().getService(IHandlerService.class);
		final IContextService contexts = getSite().getService(IContextService.class);
		
		contexts.activateContext("org.eclipse.statet.workbench.contexts.StructuredElementViewer"); //$NON-NLS-1$
		
		final RefreshHandler refreshHandler = new RefreshHandler();
		handlerService.activateHandler(IWorkbenchCommandConstants.FILE_REFRESH, refreshHandler);
		final CollapseAllHandler collapseAllHandler = new CollapseAllHandler(this.fTreeViewer);
		handlerService.activateHandler(CollapseAllHandler.COMMAND_ID, collapseAllHandler);
		this.fCopyElementNameHandler = new CopyElementNameHandler(this);
		handlerService.activateHandler(ISourceEditorCommandIds.COPY_ELEMENT_NAME, this.fCopyElementNameHandler);
		handlerService.activateHandler(IWorkbenchCommandConstants.EDIT_COPY, this.fCopyElementNameHandler);
		this.fDeleteElementHandler = new DeleteHandler(this);
		handlerService.activateHandler(IWorkbenchCommandConstants.EDIT_DELETE, this.fDeleteElementHandler);
		this.fPrintElementHandler = new PrintHandler(this);
		handlerService.activateHandler(RunPrintInR.COMMAND_ID, this.fPrintElementHandler);
		final InformationDispatchHandler infoHandler = new InformationDispatchHandler(this.fTokenOwner);
		handlerService.activateHandler(InformationDispatchHandler.COMMAND_ID, infoHandler);
		this.fOpenInEditorHandler = new OpenInEditorHandler();
		handlerService.activateHandler(OPEN_COMMAND_ID, this.fOpenInEditorHandler);
		
		this.fSearchTextItem = new SearchContributionItem("search.text", //$NON-NLS-1$
				SearchContributionItem.VIEW_TOOLBAR, true ) {
			@Override
			protected void search() {
				ObjectBrowserView.this.fFilterText = getText();
				updateFilter();
			}
		};
		this.fSearchTextItem.setToolTip("Filter Elements");
		this.fSearchTextItem.setSizeControl(this.fTreeViewer.getControl().getParent());
		this.fSearchTextItem.setResultControl(this.fTreeViewer.getTree());
		
		this.fSearchStartHandler = new AbstractHandler() {
			@Override
			public Object execute(final ExecutionEvent arg0) {
				ObjectBrowserView.this.fSearchTextItem.show();
				return null;
			}
		};
		handlerService.activateHandler(IWorkbenchCommandConstants.EDIT_FIND_AND_REPLACE, this.fSearchStartHandler);
		// add next/previous handler
		
		final ToggleAutoRefreshHandler autoRefreshHandler = new ToggleAutoRefreshHandler(this);
		
		final IActionBars actionBars = getViewSite().getActionBars();
		final IMenuManager viewMenu = actionBars.getMenuManager();
		final IToolBarManager viewToolbar = actionBars.getToolBarManager();
		
		viewMenu.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Filter.OnlyUserspace", HandlerContributionItem.NO_COMMAND_ID, null, //$NON-NLS-1$
				null, null, null,
				"Show non-&package Variables only", null, null,
				HandlerContributionItem.STYLE_CHECK, null, false),
				new FilterUserspaceHandler() ));
		viewMenu.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Filter.IncludeInternal", HandlerContributionItem.NO_COMMAND_ID, null, //$NON-NLS-1$
				null, null, null,
				"Show &Internal Variables ('.*')", null, null,
				HandlerContributionItem.STYLE_CHECK, null, false),
				new FilterInternalHandler() ));
		viewMenu.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Sort.ByType", HandlerContributionItem.NO_COMMAND_ID, null, //$NON-NLS-1$
				null, null, null,
				"Sort by &Type", null, null,
				HandlerContributionItem.STYLE_CHECK, null, false),
				new SortByTypeHandler() ));
		
		viewMenu.add(new Separator());
		final HandlerContributionItem autoRefreshItem = new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				null, HandlerContributionItem.NO_COMMAND_ID, null, 
				null, null, null,
				"Refresh &automatically", null, null,
				HandlerContributionItem.STYLE_CHECK, null, false),
				autoRefreshHandler );
		viewMenu.add(autoRefreshItem);
		this.fRefreshMenuItem = new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				null, IWorkbenchCommandConstants.FILE_REFRESH, null, 
				StatetImages.getDescriptor(StatetImages.TOOL_REFRESH), StatetImages.getDescriptor(StatetImages.TOOLD_REFRESH), null,
				"&Refresh", null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				refreshHandler );
		viewMenu.add(this.fRefreshMenuItem);
		
		viewMenu.addMenuListener(new IMenuListener() {
			@Override
			public void menuAboutToShow(final IMenuManager manager) {
				autoRefreshItem.update();
			}
		});
		
		viewToolbar.add(this.fSearchTextItem);
		viewToolbar.add(new Separator());
		this.fRefreshToolbarItem = new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Refresh", IWorkbenchCommandConstants.FILE_REFRESH, null, //$NON-NLS-1$
				StatetImages.getDescriptor(StatetImages.TOOL_REFRESH), StatetImages.getDescriptor(StatetImages.TOOLD_REFRESH), null,
				null, null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				refreshHandler);
		this.fRefreshToolbarItem.setVisible(false);
		viewToolbar.add(this.fRefreshToolbarItem);
		viewToolbar.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Collapse.All", CollapseAllHandler.COMMAND_ID, null, //$NON-NLS-1$
				null, null, null,
				null, null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				collapseAllHandler));
	}
	
	void updateAutoRefresh(final boolean enabled) {
		if (this.process == null || this.process.isTerminated()) {
			return;
		}
		
		if (enabled) {
			updateDirty(false);
		}
		else {
			updateDirty(this.process.getWorkspaceData().isRObjectDBDirty());
		}
		
		if (this.fRefreshToolbarItem.isVisible() != enabled) {
			return;
		}
		this.fRefreshToolbarItem.setVisible(!enabled);
		final IContributionManager manager = this.fRefreshToolbarItem.getParent();
		manager.update(true);
		this.fSearchTextItem.resize();
	}
	
	void updateDirty(final boolean enabled) {
		if (this.fRefreshDirtyIndicator == enabled) {
			return;
		}
		final ImageDescriptor icon = (enabled) ?
				RUIPlugin.getInstance().getImageRegistry().getDescriptor(RUIPlugin.IMG_LOCTOOL_REFRESH_RECOMMENDED) :
				StatetImages.getDescriptor(StatetImages.TOOL_REFRESH);
		this.fRefreshToolbarItem.setIcon(icon);
		this.fRefreshMenuItem.setIcon(icon);
		this.fRefreshDirtyIndicator = enabled;
	}
	
	
	private void hookContextMenu() {
		final MenuManager menuManager = new MenuManager("ContextMenu", //$NON-NLS-1$
				"org.eclipse.statet.r.menus.RObjectBrowserContextMenu" ); //$NON-NLS-1$
		menuManager.setRemoveAllWhenShown(true);
		menuManager.addMenuListener(new IMenuListener() {
			@Override
			public void menuAboutToShow(final IMenuManager m) {
				contextMenuAboutToShow(m);
			}
		});
		final Menu contextMenu = menuManager.createContextMenu(this.fTreeViewer.getTree());
		this.fTreeViewer.getTree().setMenu(contextMenu);
		getSite().registerContextMenu(menuManager, this.fTreeViewer);
	}
	
	private void contextMenuAboutToShow(final IMenuManager m) {
		m.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				null, OPEN_COMMAND_ID, null,
				null, null, null,
				"Open in Data &Viewer", null, null,
				HandlerContributionItem.STYLE_PUSH, null, true), this.fOpenInEditorHandler));
		
		m.add(new Separator("edit"));
		m.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Copy.ElementName", ISourceEditorCommandIds.COPY_ELEMENT_NAME, null, //$NON-NLS-1$
				null, null, null,
				null, null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				this.fCopyElementNameHandler));
		m.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				"Delete", IWorkbenchCommandConstants.EDIT_DELETE, null, //$NON-NLS-1$
				null, null, null,
				null, null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				this.fDeleteElementHandler));
		m.add(new Separator());
		m.add(new HandlerContributionItem(new CommandContributionItemParameter(getSite(),
				null, RunPrintInR.COMMAND_ID, null, 
				null, null, null,
				null, null, null,
				HandlerContributionItem.STYLE_PUSH, null, false),
				this.fPrintElementHandler));
		
		m.add(new Separator(ADDITIONS_GROUP_ID));
	}
	
	/** May only be called in UI thread */
	public void connect(final ToolProcess tool) {
		if (this.process == tool) {
			return;
		}
		final RProcess oldProcess = this.process;
		if (oldProcess != null) {
			oldProcess.getWorkspaceData().removePropertyListener(this.fInputUpdater);
		}
		synchronized (this.processLock) {
			this.process = (RProcess) 
					((tool != null && tool.isProvidingFeatureSet(RConsoleTool.R_DATA_FEATURESET_ID)) ?
							tool : null);
		}
		if (this.fHoveringController != null) {
			this.fHoveringController.stop();
		}
		if (oldProcess != null) {
			clearInfo();
			oldProcess.getQueue().remove(new ToolRunnable[] { this.fManualRefreshRunnable });
		}
		if (!UIAccess.isOkToUse(this.fTreeViewer)) {
			return;
		}
		for (final IToolRetargetable listener : this.fToolListenerList.toArray()) {
			listener.setTool(this.process);
		}
		this.fInputUpdater.forceUpdate(this.process);
		if (this.process != null) {
			this.process.getWorkspaceData().addPropertyListener(this.fInputUpdater);
			updateAutoRefresh(this.process.getWorkspaceData().isAutoRefreshEnabled());
		}
		this.fInputUpdater.schedule();
	}
	
	@Override
	public RProcess getTool() {
		return this.process;
	}
	
	public ITreeSelection getSelection() {
		return (ITreeSelection) this.fTreeViewer.getSelection();
	}
	
	
	public boolean getShowInternal() {
		return this.fFilterIncludeInternal;
	}
	
	public boolean getShowConsenseUserspace() {
		return this.fFilterUserspace;
	}
	
	public String getSearchText() {
		return this.fFilterText;
	}
	
	
	@Override
	public void addToolRetargetable(final IToolRetargetable action) {
		this.fToolListenerList.add(action);
	}
	
	@Override
	public void removeToolRetargetable(final IToolRetargetable action) {
		this.fToolListenerList.remove(action);
	}
	
	@Override
	@SuppressWarnings("unchecked")
	public <T> T getAdapter(final Class<T> adapterType) {
		if (adapterType == Tool.class) {
			return (T) this.process;
		}
		return super.getAdapter(adapterType);
	}
	
	private void scheduleUpdateAll() {
		if (this.process != null) {
			this.process.getQueue().add(this.fManualRefreshRunnable);
		}
	}
	
	/** May only be called in UI thread (called by update job) */
	void updateViewer(final List<RProcessREnvironment> updateEnvirs, final ContentInput input) {
		if (!UIAccess.isOkToUse(this.fTreeViewer)) {
			return;
		}
		this.fHoveringController.stop();
		
		this.contentProvider.setInput(input);
		
		final boolean changed = input.processChanged;
		ISelection selection = null;
		if (changed) {
			input.processChanged = false;
		}
		/*else*/ if (input.showCondensedUserspace != this.fFilterUserspaceActivated) {
			// If filter is changed, we have to retain the selection manually
			selection = this.fTreeViewer.getSelection();
		}
		this.fFilterUserspaceActivated = input.showCondensedUserspace;
		
		final Set<RReference> previousReferences = this.contentProvider.resetUsedReferences();
		if (updateEnvirs != null) {
			for (final RProcessREnvironment entry : updateEnvirs) {
				this.fTreeViewer.refresh(entry, true);
			}
			if (!previousReferences.isEmpty()) {
				final Set<RReference> usedReferences = this.contentProvider.getUsedReferences();
				ITER_REFS: for (final RReference reference : previousReferences) {
					if (!usedReferences.contains(reference)) {
						// Update the envir copy in the viewer, if it refers to an updated envir
						for (final RProcessREnvironment entry : updateEnvirs) {
							if (entry.getHandle() == reference.getHandle()) {
								this.fTreeViewer.refresh(reference, true);
								// reference is readded automatically to new set, if necessary
								continue ITER_REFS;
							}
						}
						// Keep/readd the reference, if it refers to an envir in the search path
						for (final RProcessREnvironment entry : input.searchEnvirs) {
							if (entry.getHandle() == reference.getHandle()) {
								usedReferences.add(reference);
								continue ITER_REFS;
							}
						}
					}
				}
			}
		}
		else {
			this.fTreeViewer.refresh(true);
		}
		
		// Adapt and set selection
		if (selection != null && !selection.isEmpty()) {
			final ITreeSelection s = (ITreeSelection) selection;
			final TreePath[] paths = s.getPaths();
			int j = 0;
			for (int i = 0; i < paths.length; i++) {
				final TreePath oldPath = paths[i];
				final int count = oldPath.getSegmentCount();
				final int shift = (input.showCondensedUserspace) ? -1 : +1;
				if (count + shift < 1) {
					continue;
				}
				final Object[] newPath = new Object[count + shift];
				for (int k = (shift == -1) ? +1 : 0; k < count; k++) {
					newPath[k + shift] = oldPath.getSegment(k);
				}
				if (shift == +1) {
					newPath[0] = ContentProvider.getCombinedRElement(newPath[1]).getModelParent();
				}
				paths[j++] = new TreePath(newPath);
			}
			this.fTreeViewer.setSelection(new TreeSelection(
					(j < paths.length) ? Arrays.copyOf(paths, j) : paths),
					true );
		}
		
		// Expand Global_Env, if it is a new process and has valid input
		EXPAND_GLOBALENV : if (changed && !input.showCondensedUserspace 
				&& input.rootElements != null && input.rootElements.length > 0) {
			for (final Object element : input.rootElements) {
				if (this.fTreeViewer.getExpandedState(element)) {
					break EXPAND_GLOBALENV;
				}
			}
			this.fTreeViewer.expandToLevel(new TreePath(new Object[] { input.rootElements[0] }), 1);
		}
	}
	
	private void updateFilter() {
		this.fInputUpdater.schedule();
	}
	
	private void updateSorter() {
		this.fTreeViewer.setComparator(this.fSortByType ? TYPE_COMPARATOR : null);
	}
	
	private void updateSelectionInfo(final ITreeSelection selection) {
		final Object previousInfoObject = this.fCurrentInfoObject;
		this.fCurrentInfoObject = null;
		
		final RProcess tool = getTool();
		if (tool == null) {
			return;
		}
		if (selection.size() == 1) {
			this.fCurrentInfoObject = selection.getFirstElement();
			final TreePath treePath = selection.getPaths()[0];
			final IElementName elementName = getFQElementName(treePath);
			final String name = (elementName != null) ? elementName.getDisplayName() : null;
			if (name != null) {
				if (this.fCurrentInfoObject.equals(previousInfoObject)) {
					clearInfo();
				}
				this.statusLine.setSelectionMessage(new StatusInfo(IStatus.OK,
						NLS.bind("{0}  \u2012  {1}", name, tool.getLabel(Tool.DEFAULT_LABEL)) )); //$NON-NLS-1$
				return;
			}
		}
		clearInfo();
		if (selection.size() > 1) {
			this.statusLine.setSelectionMessage(new StatusInfo(IStatus.OK,
					NLS.bind("{0} items selected", selection.size()) ));
			return;
		}
		this.statusLine.setSelectionMessage(null);
	}
	
	private void clearInfo() {
	}
	
	/**
	 * Returns a shared clipboard resource, which can be used by actions of this view.
	 * 
	 * @return a clipboard object.
	 */
	Clipboard getClipboard() {
		if (this.fClipboard == null) {
			this.fClipboard = new Clipboard(Display.getCurrent());
		}
		return this.fClipboard;
	}
	
	StatusLineMessageManager getStatusLine() {
		return this.statusLine;
	}
	
	@Override
	public void setFocus() {
		this.fTreeViewer.getControl().setFocus();
	}
	
	@Override
	public void dispose() {
		if (this.fToolRegistryListener != null) {
			NicoUI.getToolRegistry().removeListener(this.fToolRegistryListener);
			this.fToolRegistryListener = null;
		}
		if (this.process != null) {
			this.process.getWorkspaceData().removePropertyListener(this.fInputUpdater);
			this.process.getQueue().remove(new ToolRunnable[] { this.fManualRefreshRunnable });
		}
		this.fInputUpdater.cancel();
		if (this.fHoveringController != null) {
			this.fHoveringController.dispose();
			this.fHoveringController = null;
		}
		if (this.fSearchStartHandler != null) {
			this.fSearchStartHandler.dispose();
			this.fSearchStartHandler = null;
		}
		if (this.fCopyElementNameHandler != null) {
			this.fCopyElementNameHandler.dispose();
			this.fCopyElementNameHandler = null;
		}
		if (this.fPrintElementHandler != null) {
			this.fPrintElementHandler.dispose();
			this.fPrintElementHandler = null;
		}
		
		for (final IToolRetargetable listener : this.fToolListenerList.toArray()) {
			listener.setTool(null);
		}
		
		super.dispose();
		
		if (this.fClipboard != null) {
			this.fClipboard.dispose();
			this.fClipboard = null;
		}
	}
	
	
	public RElementName getFQElementName(final TreePath treePath) {
		if (treePath.getSegmentCount() == 0) {
			return null;
		}
		int segmentIdx = 0;
		if (!this.fFilterUserspaceActivated) {
			if (treePath.getSegmentCount() == 1) { // search path item
				return ContentProvider.getCombinedRElement(treePath.getFirstSegment()).getElementName();
			}
			else { // main name at 1
				segmentIdx = 1;
			}
		}
		final List<RElementName> names= new ArrayList<>(treePath.getSegmentCount() - segmentIdx + 1);
		final CombinedRElement first= ContentProvider.getCombinedRElement(treePath.getSegment(segmentIdx++));
		names.add(first.getModelParent().getElementName());
		names.add(first.getElementName());
		while (segmentIdx < treePath.getSegmentCount()) {
			final Object object= treePath.getSegment(segmentIdx++);
			if (object instanceof ElementPartition) {
				continue;
			}
			final CombinedRElement rElement= ContentProvider.getCombinedRElement(object);
			names.add(rElement.getElementName());
		}
		return RElementName.create(names);
	}
	
}