/*=============================================================================#
 # Copyright (c) 2017, 2019 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.apps.ui.variables;

import static org.eclipse.ui.IWorkbenchCommandConstants.NAVIGATE_COLLAPSE_ALL;

import static org.eclipse.statet.jcommons.lang.ObjectUtils.nonNullAssert;

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.resources.IResource;
import org.eclipse.core.runtime.IStatus;
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.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IPostSelectionProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
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.IViewPart;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.commands.IElementUpdater;
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.services.IServiceLocator;

import org.eclipse.statet.jcommons.collections.CopyOnWriteIdentityListSet;
import org.eclipse.statet.jcommons.lang.NonNullByDefault;
import org.eclipse.statet.jcommons.lang.Nullable;
import org.eclipse.statet.jcommons.ts.core.ActiveToolListener;
import org.eclipse.statet.jcommons.ts.core.ActiveToolListener.ActiveToolEvent;
import org.eclipse.statet.jcommons.ts.core.Tool;
import org.eclipse.statet.jcommons.ts.core.ToolProvider;

import org.eclipse.statet.ecommons.ts.ui.workbench.WorkbenchToolRegistry;
import org.eclipse.statet.ecommons.ts.ui.workbench.WorkbenchToolRegistryListener;
import org.eclipse.statet.ecommons.ts.ui.workbench.WorkbenchToolSessionData;
import org.eclipse.statet.ecommons.ui.actions.HandlerCollection;
import org.eclipse.statet.ecommons.ui.actions.HandlerContributionItem;
import org.eclipse.statet.ecommons.ui.actions.UIActions;
import org.eclipse.statet.ecommons.ui.components.StatusInfo;
import org.eclipse.statet.ecommons.ui.dialogs.DialogUtils;
import org.eclipse.statet.ecommons.ui.util.LayoutUtils;
import org.eclipse.statet.ecommons.ui.util.UIAccess;
import org.eclipse.statet.ecommons.ui.util.ViewActionUtil;
import org.eclipse.statet.ecommons.ui.workbench.ContextHandlers;
import org.eclipse.statet.ecommons.ui.workbench.WorkbenchUIUtils;

import org.eclipse.statet.base.ui.StatetImages;
import org.eclipse.statet.internal.r.apps.ui.RAppUIPlugin;
import org.eclipse.statet.ltk.ui.sourceediting.ISourceEditorCommandIds;
import org.eclipse.statet.ltk.ui.util.ViewerDragSupport;
import org.eclipse.statet.nico.ui.NicoUI;
import org.eclipse.statet.nico.ui.actions.AbstractToolHandler;
import org.eclipse.statet.r.apps.ui.AppRegistry;
import org.eclipse.statet.r.apps.ui.AppRegistry.AppStateEvent;
import org.eclipse.statet.r.apps.ui.RApp;
import org.eclipse.statet.r.apps.ui.VariablesData;
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.ui.rtool.CopyRElementHandler;
import org.eclipse.statet.r.ui.rtool.PrintRElementHandler;
import org.eclipse.statet.r.ui.rtool.RElementViewerDragSourceListener;
import org.eclipse.statet.r.ui.util.CopyRElementNameHandler;
import org.eclipse.statet.r.ui.util.RElementInputContentProvider;
import org.eclipse.statet.r.ui.util.RElementInputLabelProvider;
import org.eclipse.statet.r.ui.util.RElementInputUtils;
import org.eclipse.statet.rj.data.RReference;


@NonNullByDefault
public class AppVarView extends ViewPart implements ToolProvider {
	
	
	public static final String VIEW_ID= "org.eclipse.statet.r.apps.views.VariableViewer"; //$NON-NLS-1$
	
	
	private static final String REFRESH_COMMAND_ID= IWorkbenchCommandConstants.FILE_REFRESH;
	
	private static final String FILTER_INCLUDE_INTERNAL_COMMAND_ID= "Filter.IncludeInternal"; //$NON-NLS-1$
	
	private static final String PRINT_COMMAND_ID= "org.eclipse.statet.r.commands.RunPrintInR"; //$NON-NLS-1$
	
	
	private static final String FILTER_INCLUDE_INTERNAL_SETTINGS_KEY= "Filter.IncludeInternal.enabled"; //$NON-NLS-1$
	
	
	private class RefreshHandler extends AbstractToolHandler<RProcess> {
		
		public RefreshHandler() {
			super(RConsoleTool.TYPE, null, AppVarView.this, getSite());
			init();
		}
		
		
		@Override
		protected boolean evaluateIsEnabled(final RProcess tool, final @Nullable Object evaluationContext) {
			return (super.evaluateIsEnabled(tool, evaluationContext)
					&& getApp() != null );
		}
		
		protected void refreshElements() {
			WorkbenchUIUtils.refreshCommandElements(REFRESH_COMMAND_ID, this, null);
		}
		
		@Override
		protected @Nullable Object execute(final RProcess tool, final ExecutionEvent event) {
			final RApp app= getApp();
			if (app != null) {
				app.refreshVariables();
			}
			return null;
		}
		
	}
	
	private class FilterInternalHandler extends AbstractHandler implements IElementUpdater {
		
		@Override
		public @Nullable Object execute(final ExecutionEvent event) throws ExecutionException {
			AppVarView.this.filterIncludeInternal= !AppVarView.this.filterIncludeInternal;
			AppVarView.this.settings.put(FILTER_INCLUDE_INTERNAL_SETTINGS_KEY, AppVarView.this.filterIncludeInternal);
			updateFilter();
			return null;
		}
		
		@Override
		public void updateElement(final UIElement element, final Map parameters) {
			WorkbenchUIUtils.aboutToUpdateCommandsElements(this, element);
			try {
				element.setChecked(AppVarView.this.filterIncludeInternal);
			}
			finally {
				WorkbenchUIUtils.finalizeUpdateCommandsElements(this);
			}
		}
		
	}
	
	
	private IDialogSettings settings;
	
	final Object sourceLock= new Object();
	private WorkbenchToolRegistryListener toolRegistryListener;
	private @Nullable RProcess process;
	private final CopyOnWriteIdentityListSet<ActiveToolListener> toolListeners= new CopyOnWriteIdentityListSet<>();
	
	private AppRegistry.Listener appRegistryListener;
	private @Nullable RApp app;
	
	
	private TreeViewer treeViewer;
	
	private final ContentJob inputUpdater= new ContentJob(this);
	private boolean isUpdating;
	
	private boolean filterIncludeInternal;
	private String filterText;
	
	private RElementInputContentProvider<AppVarInput> inputContentProvider;
	
	
	private ViewActionUtil actionUtil;
	private ContextHandlers handlers;
	
	private @Nullable Object currentInfoObject;
	
	
	private @Nullable RApp shownByLauncher;
	
	
	@SuppressWarnings("null")
	public AppVarView() {
	}
	
	@Override
	public void dispose() {
		if (this.appRegistryListener != null) {
			AppRegistry.getInstance().removeListener(this.appRegistryListener);
			this.appRegistryListener= null;
		}
		if (this.toolRegistryListener != null) {
			NicoUI.getToolRegistry().removeListener(this.toolRegistryListener);
			this.toolRegistryListener= null;
		}
		setTool(null, false);
		
		if (this.handlers != null) {
			this.handlers.dispose();
			this.handlers= null;
		}
		
		super.dispose();
	}
	
	
	@Override
	public void init(final IViewSite site, final @Nullable IMemento memento) throws PartInitException {
		super.init(site, memento);
		
		this.settings= DialogUtils.getDialogSettings(RAppUIPlugin.getInstance(), "AppVarBrowser");
		
		this.filterIncludeInternal= this.settings.getBoolean(FILTER_INCLUDE_INTERNAL_SETTINGS_KEY);
	}
	
	@Override
	public void createPartControl(final Composite parent) {
		parent.setLayout(LayoutUtils.newSashGrid());
		
		this.treeViewer= createTreeViewer(parent);
		this.treeViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		
		final IPostSelectionProvider treeSelectionProvider= this.treeViewer;
		treeSelectionProvider.addPostSelectionChangedListener(new ISelectionChangedListener() {
			@Override
			public void selectionChanged(final SelectionChangedEvent event) {
				updateSelectionInfo((ITreeSelection) event.getSelection());
			}
		});
		
		final IViewSite site= getViewSite();
		site.setSelectionProvider(treeSelectionProvider);
		this.actionUtil= new ViewActionUtil(this);
		this.handlers= new ContextHandlers(site.getService(IHandlerService.class));
		initActions(site, this.handlers);
		contributeToActionBars(site, site.getActionBars(), this.handlers);
		hookContextMenu();
		
		// listen on console changes
		final WorkbenchToolRegistry toolRegistry= NicoUI.getToolRegistry();
		this.toolRegistryListener= new WorkbenchToolRegistryListener() {
			@Override
			public void toolSessionActivated(final WorkbenchToolSessionData sessionData) {
				final Tool tool= sessionData.getTool();
				UIAccess.getDisplay().syncExec(new Runnable() {
					@Override
					public void run() {
						setTool(tool, true);
					}
				});
			}
			@Override
			public void toolTerminated(final WorkbenchToolSessionData sessionData) {
				final Tool tool= sessionData.getTool();
				UIAccess.getDisplay().syncExec(new Runnable() {
					@Override
					public void run() {
						if (tool == getTool()) {
							setTool(null, true);
						}
					}
				});
			}
		};
		toolRegistry.addListener(this.toolRegistryListener, getViewSite().getPage());
		
		this.appRegistryListener= new AppRegistry.Listener() {
			@Override
			public void onAppStateChanged(final AppStateEvent event) {
				UIAccess.getDisplay(getSite().getShell()).asyncExec(() -> {
					switch (event.getType()) {
					case AppRegistry.APP_STARTED:
						if (event.getApp().getTool() == getTool()) {
							setApp(event.getApp(), true);
						}
						break;
					case AppRegistry.APP_STOPPED:
						if (event.getApp() == getApp()) {
							setApp(null, true);
						}
						break;
					default:
						break;
					}
				});
			}
		};
		AppRegistry.getInstance().addListener(this.appRegistryListener);
		
		setTool(toolRegistry.getActiveToolSession(getViewSite().getPage()).getTool(), true);
	}
	
	private TreeViewer createTreeViewer(final Composite parent) {
		final TreeViewer viewer= new TreeViewer(parent, SWT.V_SCROLL | SWT.H_SCROLL | SWT.MULTI);
		
		viewer.setLabelProvider(new RElementInputLabelProvider());
		
		viewer.setUseHashlookup(true);
		this.inputContentProvider= new RElementInputContentProvider();
		viewer.setContentProvider(this.inputContentProvider);
		viewer.setInput(this);
		
		return viewer;
	}
	
	protected void initActions(final IServiceLocator serviceLocator, final ContextHandlers handlers) {
		handlers.addActivate(REFRESH_COMMAND_ID, new RefreshHandler());
		
		final CopyRElementHandler copyHandler= new CopyRElementHandler(this.actionUtil,
				(ILabelProvider) this.treeViewer.getLabelProvider() );
		handlers.addActivate(IWorkbenchCommandConstants.EDIT_COPY, copyHandler);
		handlers.addActivate(ISourceEditorCommandIds.COPY_ELEMENT_NAME,
				new CopyRElementNameHandler(this.actionUtil) );
		
		final ViewerDragSupport dragSupport= new ViewerDragSupport(this.treeViewer);
		dragSupport.addDragSourceListener(new RElementViewerDragSourceListener(
				copyHandler, this.treeViewer ));
		dragSupport.init();
		
		handlers.addActivate(PRINT_COMMAND_ID,
				new PrintRElementHandler(this.actionUtil) );
		
		handlers.add(FILTER_INCLUDE_INTERNAL_COMMAND_ID,
				new FilterInternalHandler() );
		
		handlers.addActivate(NAVIGATE_COLLAPSE_ALL,
				new CollapseAllHandler(this.treeViewer) );
		RElementInputUtils.addDoubleClickExpansion(this.treeViewer);
	}
	
	protected void contributeToActionBars(final IServiceLocator serviceLocator,
			final IActionBars actionBars, final HandlerCollection handlers) {
		final IMenuManager menuManager= actionBars.getMenuManager();
		final IToolBarManager toolbarManager= actionBars.getToolBarManager();
		
		menuManager.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						null, HandlerContributionItem.NO_COMMAND_ID, null,
						null, null, null,
						"Show &Internal Variables ('.*')", null, null,
						HandlerContributionItem.STYLE_CHECK, null, false ),
				nonNullAssert(handlers.get(FILTER_INCLUDE_INTERNAL_COMMAND_ID)) ));
		
		menuManager.add(new Separator());
		menuManager.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						"Refresh", REFRESH_COMMAND_ID, null, //$NON-NLS-1$
						StatetImages.getDescriptor(StatetImages.TOOL_REFRESH), StatetImages.getDescriptor(StatetImages.TOOLD_REFRESH), null,
						"&Refresh", null, null,
						HandlerContributionItem.STYLE_PUSH, null, false ),
				handlers ));
		
		toolbarManager.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						null, CollapseAllHandler.COMMAND_ID, null,
						null, null, null,
						null, null, null,
						HandlerContributionItem.STYLE_PUSH, null, false ),
				nonNullAssert(handlers.get(NAVIGATE_COLLAPSE_ALL)) ));
	}
	
	private void hookContextMenu() {
		final MenuManager menuManager= new MenuManager("ContextMenu", //$NON-NLS-1$
				"org.eclipse.statet.r.apps.menus.VariablesViewContextMenu" ); //$NON-NLS-1$
		menuManager.setRemoveAllWhenShown(true);
		menuManager.addMenuListener(this::fillContextMenu);
		final Menu contextMenu= menuManager.createContextMenu(this.treeViewer.getTree());
		this.treeViewer.getTree().setMenu(contextMenu);
		getSite().registerContextMenu(menuManager, this.treeViewer);
	}
	
	private void fillContextMenu(final IMenuManager m) {
		final IServiceLocator serviceLocator= getSite();
		final ContextHandlers handlers= this.handlers;
		
		m.add(new Separator(UIActions.EDIT_GROUP_ID));
		m.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						"Copy", IWorkbenchCommandConstants.EDIT_COPY, null, //$NON-NLS-1$
						null, null, null,
						null, null, null,
						HandlerContributionItem.STYLE_PUSH, null, false ),
				handlers ));
		m.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						"Copy.ElementName", ISourceEditorCommandIds.COPY_ELEMENT_NAME, null, //$NON-NLS-1$
						null, null, null,
						null, null, null,
						HandlerContributionItem.STYLE_PUSH, null, false ),
				handlers ));
		m.add(new Separator());
		m.add(new HandlerContributionItem(
				new CommandContributionItemParameter(serviceLocator,
						null, PRINT_COMMAND_ID, null,
						null, null, null,
						null, null, null,
						HandlerContributionItem.STYLE_PUSH, null, false ),
				handlers ));
		
		m.add(new Separator(UIActions.ADDITIONS_GROUP_ID));
	}
	
	@Override
	public void setFocus() {
		this.treeViewer.getControl().setFocus();
	}
	
	
	/** UI thread only (called by update job) */
	void updateView(final @Nullable AppVarInput input,
			final @Nullable List<RProcessREnvironment> updateEnvirs) {
		if (!UIAccess.isOkToUse(this.treeViewer)) {
			return;
		}
		this.isUpdating= true;
		
//		this.hoveringController.stop();
		
		this.inputContentProvider.setInput(input);
		
		final Set<RReference> previousReferences= this.inputContentProvider.resetUsedReferences();
		if (input != null && updateEnvirs != null) {
			for (final RProcessREnvironment entry : updateEnvirs) {
				this.treeViewer.refresh(entry, true);
			}
			if (!previousReferences.isEmpty()) {
				final Set<RReference> usedReferences= this.inputContentProvider.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.treeViewer.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 ICombinedREnvironment entry : input.searchEnvirs) {
//							if (entry.getHandle() == reference.getHandle()) {
//								usedReferences.add(reference);
//								continue ITER_REFS;
//							}
//						}
					}
				}
			}
		}
		else {
			this.treeViewer.refresh(true);
		}
		
		updateSelectionInfo((ITreeSelection) this.actionUtil.getSelectionProvider().getSelection());
	}
	
	private void updateFilter() {
		this.inputUpdater.schedule();
	}
	
	private void clearActionInfo() {
		this.actionUtil.getStatusLine().clearAll();
	}
	
	private void updateSelectionInfo(final ITreeSelection selection) {
		if (this.isUpdating) {
			return;
		}
		final Object infoObject= null;
		final String message= null;
		
//		if (tool != null && !selection.isEmpty()) {
//			if (selection.size() == 1) {
//				final TreePath treePath= selection.getPaths()[0];
//				final IElementName elementName= getFQElementName(treePath);
//				final String name= (elementName != null) ? elementName.getDisplayName() : null;
//				if (name != null) {
//					infoObject= selection.getFirstElement();
//					message= name;
//				}
//			}
//			else {
//				message= NLS.bind("{0} items selected", selection.size());
//			}
//			if (message != null) {
//				message= NLS.bind("{0}  \u2012  {1}", message, tool.getLabel(ITool.DEFAULT_LABEL)); //$NON-NLS-1$
//			}
//		}
		
		if (infoObject == null || !infoObject.equals(this.currentInfoObject)) {
			clearActionInfo();
		}
		this.currentInfoObject= infoObject;
		this.actionUtil.getStatusLine().setSelectionMessage(
				(message != null) ? new StatusInfo(IStatus.OK, message) : null );
	}
	
	
	@Override
	public @Nullable RProcess getTool() {
		return this.process;
	}
	
	@Override
	public void addToolListener(final ActiveToolListener action) {
		this.toolListeners.add(action);
	}
	
	@Override
	public void removeToolListener(final ActiveToolListener action) {
		this.toolListeners.remove(action);
	}
	
	/** UI thread only */
	private void setTool(final @Nullable Tool tool, final boolean update) {
		final RProcess process= (tool != null
						&& tool.isProvidingFeatureSet(RConsoleTool.R_DATA_FEATURESET_ID)
						&& !tool.isTerminated() ) ?
				(RProcess) tool : null;
		if (this.process == tool) {
			return;
		}
		final RProcess oldProcess= process;
		synchronized (this.sourceLock) {
			this.process= process;
		}
		
		final ActiveToolEvent event= new ActiveToolEvent(ActiveToolEvent.TOOL_ACTIVATED, process);
		for (final ActiveToolListener listener : this.toolListeners) {
			listener.onToolChanged(event);
		}
		
		setApp((process != null) ? AppRegistry.getInstance().getApp(process) : null, update);
	}
	
	public @Nullable RApp getApp() {
		return this.app;
	}
	
	/** UI thread only */
	private void setApp(@Nullable RApp app, final boolean update) {
		if (app != null && app.getVariables() == null) {
			app= null;
		}
		if (this.app == app) {
			return;
		}
		
		final RApp oldApp= this.app;
		if (oldApp != null) {
			oldApp.removeListener(this.inputUpdater);
		}
		synchronized (this.sourceLock) {
			this.app= app;
		}
		clearActionInfo();
		
		this.inputUpdater.forceUpdate(app);
		if (app != null) {
			setContentDescription(computeContentDescription(app));
			app.addListener(this.inputUpdater);
		}
		else {
			setContentDescription("No app at this time.");
		}
		if (update) {
			this.inputUpdater.schedule();
			
			if (app == null && oldApp == this.shownByLauncher) {
				Display.getCurrent().timerExec(200, () -> {
					showPreviousView(oldApp);
				});
			}
		}
	}
	
	private String computeContentDescription(final RApp app) {
		final StringBuilder sb= new StringBuilder();
		
		final VariablesData vars= app.getVariables();
		if (vars != null) {
			sb.append(vars.getExpression());
		}
		else {
			sb.append("<no available>");
		}
		
		final IResource resource= app.getResource();
		if (resource != null) {
			if (sb.length() > 0) {
				sb.append("\u2002\u2013\u2002"); //$NON-NLS-1$
			}
			sb.append(resource.getFullPath().toString());
		}
		
		return sb.toString();
	}
	
	
	public boolean getFilterIncludeInternal() {
		return this.filterIncludeInternal;
	}
	
	public String getFilterSearchText() {
		return this.filterText;
	}
	
	
	public void setShownByLauncher(final RApp app) {
		this.shownByLauncher= app;
	}
	
	private void showPreviousView(final RApp oldApp) {
		if (this.app == null && oldApp == this.shownByLauncher) {
			final IWorkbenchPage page= getSite().getPage();
			final IViewPart[] viewStack= page.getViewStack(this);
			if (viewStack != null && viewStack.length >= 2 && viewStack[0] == this) {
				page.bringToTop(viewStack[1]);
			}
		}
	}
	
	
	@Override
	@SuppressWarnings("unchecked")
	public <T> T getAdapter(final Class<T> adapterType) {
		if (adapterType == Control.class) {
			return (T) this.treeViewer.getTree();
		}
		if (adapterType == Tool.class) {
			return (T) this.process;
		}
		return super.getAdapter(adapterType);
	}
	
}