/*******************************************************************************
 * Copyright (c) 2005, 2017 IBM Corporation and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 *******************************************************************************/
package org.eclipse.dltk.debug.ui.launchConfigurations;

import java.net.URI;
import java.net.URISyntaxException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Path;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.environment.EnvironmentManager;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.debug.ui.messages.DLTKLaunchConfigurationsMessages;
import org.eclipse.dltk.internal.launching.LaunchConfigurationUtils;
import org.eclipse.dltk.launching.ScriptLaunchConfigurationConstants;
import org.eclipse.dltk.launching.process.ScriptRuntimeProcessFactory;
import org.eclipse.dltk.ui.DLTKPluginImages;
import org.eclipse.dltk.ui.preferences.FieldValidators;
import org.eclipse.dltk.ui.preferences.FieldValidators.FilePathValidator;
import org.eclipse.dltk.ui.util.SWTFactory;
import org.eclipse.dltk.utils.PlatformFileUtils;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.views.navigator.ResourceComparator;

public abstract class MainLaunchConfigurationTab extends
		ScriptLaunchConfigurationTab implements IMainLaunchConfigurationTab {

	private Text fScriptText;

	private Button interactiveConsoleCheck;

	private boolean useInteractiveConsoleGroup = false;

	private final ListenerList<IMainLaunchConfigurationTabListener> listeners = new ListenerList<>();

	public MainLaunchConfigurationTab(String mode) {
		super(mode);
	}

	@Override
	public void addListener(IMainLaunchConfigurationTabListener listener) {
		this.listeners.add(listener);
	}

	@Override
	public void removeListener(IMainLaunchConfigurationTabListener listener) {
		this.listeners.remove(listener);
	}

	/*
	 * Increase visibility
	 */
	@Override
	public IScriptProject getProject() {
		return super.getProject();
	}

	private IProject lastProjectNotification = null;

	private void notifyProjectChangedListeners(IProject project) {
		if (project != null) {
			if (project.equals(lastProjectNotification)) {
				return;
			}
		} else {
			if (lastProjectNotification == null) {
				return;
			}
		}
		lastProjectNotification = project;
		for (IMainLaunchConfigurationTabListener listener : this.listeners) {
			listener.projectChanged(project);
		}
	}

	private void notifyInteractiveChangedListeners(boolean value) {
		for (IMainLaunchConfigurationTabListener listener : listeners) {
			listener.interactiveChanged(value);
		}
	}

	/**
	 * Enable this to allow interactive group support.
	 */
	protected void enableInteractiveConsoleGroup() {
		this.useInteractiveConsoleGroup = true;
	}

	@Override
	protected void doInitializeForm(ILaunchConfiguration config) {
		updateMainModuleFromConfig(config);
		initializeDebugConsole(config);
		initializeInteractiveConsoleFrom(config);
	}

	private void initializeDebugConsole(ILaunchConfiguration config) {
		if (debugConsole != null) {
			debugConsole.setSelection(LaunchConfigurationUtils.getBoolean(
					config,
					ScriptLaunchConfigurationConstants.ATTR_DEBUG_CONSOLE,
					true));
		}
	}

	protected void initializeInteractiveConsoleFrom(
			ILaunchConfiguration config) {
		if (useInteractiveConsoleGroup) {
			boolean console = LaunchConfigurationUtils.getBoolean(config,
					ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE,
					false);
			this.interactiveConsoleCheck.setSelection(console);
		}
	}

	private Button fSearchButton;

	protected static final String FIELD_SCRIPT = "mainScript"; //$NON-NLS-1$

	/**
	 * Creates the widgets for specifying a main type.
	 *
	 * @param parent
	 *            the parent composite
	 */
	protected void createMainModuleEditor(Composite parent, String text) {
		final Composite editParent;
		if (needGroupForField(FIELD_SCRIPT)) {
			Group mainGroup = new Group(parent, SWT.NONE);
			mainGroup.setText(text);
			GridData gd = new GridData(GridData.FILL_HORIZONTAL);
			mainGroup.setLayoutData(gd);
			GridLayout layout = new GridLayout();
			layout.numColumns = 2;
			mainGroup.setLayout(layout);
			editParent = mainGroup;
		} else {
			createLabelForField(parent, FIELD_SCRIPT, text);
			editParent = parent;
		}
		fScriptText = new Text(editParent, SWT.SINGLE | SWT.BORDER);
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);

		WidgetListener listener = getWidgetListener();

		fScriptText.setLayoutData(gd);
		fScriptText.addModifyListener(listener);

		fSearchButton = createPushButton(editParent,
				DLTKLaunchConfigurationsMessages.mainTab_searchButton, null);
		fSearchButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				handleSearchButtonSelected();
			}
		});
	}

	/**
	 * @param enabled
	 */
	protected void setEnableScriptField(boolean enabled) {
		fScriptText.setEnabled(enabled);
		fSearchButton.setEnabled(enabled && isValidProject());
	}

	/**
	 * The select button pressed handler
	 */
	protected void handleSearchButtonSelected() {
		ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(
				getShell(), new WorkbenchLabelProvider(),
				new WorkbenchContentProvider());
		dialog.setTitle(
				DLTKLaunchConfigurationsMessages.mainTab_searchButton_title);
		dialog.setMessage(
				DLTKLaunchConfigurationsMessages.mainTab_searchButton_message);
		IScriptProject proj = getProject();
		if (proj == null)
			return;
		dialog.setInput(proj.getProject());
		dialog.setComparator(new ResourceComparator(ResourceComparator.NAME));
		if (dialog.open() == IDialogConstants.OK_ID) {
			IResource resource = (IResource) dialog.getFirstResult();
			String arg = resource.getProjectRelativePath().toPortableString();
			// check extension
			fScriptText.setText(arg);
		}
	}

	/**
	 * Loads the main type from the launch configuration's preference store
	 *
	 * @param config
	 *            the config to load the main type from
	 */
	protected void updateMainModuleFromConfig(ILaunchConfiguration config) {
		fScriptText.setText(getMainModuleName(config));
	}

	@Override
	protected void doCreateControl(Composite composite) {
		createMainModuleEditor(composite,
				DLTKLaunchConfigurationsMessages.mainTab_mainModule);
	}

	@Override
	protected void createDebugOptions(Composite group) {
		super.createDebugOptions(group);
		if (canSelectDebugConsoleType()) {
			debugConsole = SWTFactory.createCheckButton(group,
					DLTKLaunchConfigurationsMessages.mainTab_debugConsoleRedirect);
			debugConsole.addSelectionListener(getWidgetListener());
		}
	}

	protected boolean canSelectDebugConsoleType() {
		return false;
	}

	private Button debugConsole;

	/*
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName()
	 */
	@Override
	public String getName() {
		return DLTKLaunchConfigurationsMessages.mainTab_title;
	}

	@Override
	protected void setDefaults(ILaunchConfigurationWorkingCopy configuration,
			IModelElement element) {
		super.setDefaults(configuration, element);
		if (element instanceof ISourceModule) {
			configuration.setAttribute(
					ScriptLaunchConfigurationConstants.ATTR_MAIN_SCRIPT_NAME,
					element.getResource().getProjectRelativePath().toString());
		}
		setDefaultsDebugConsole(configuration, element);
	}

	private void setDefaultsDebugConsole(
			ILaunchConfigurationWorkingCopy configuration,
			IModelElement element) {
		if (debugConsole != null) {
			debugConsole.setSelection(true);
		}
	}

	@Override
	protected void doPerformApply(ILaunchConfigurationWorkingCopy config) {
		config.setAttribute(
				ScriptLaunchConfigurationConstants.ATTR_MAIN_SCRIPT_NAME,
				getScriptName());
		applyProcessFactory(config);
		if (debugConsole != null) {
			config.setAttribute(
					ScriptLaunchConfigurationConstants.ATTR_DEBUG_CONSOLE,
					debugConsole.getSelection());
		}
		performApplyConnectionTimeout(config);
		performApplyInteractiveConsole(config);
	}

	/**
	 * @since 2.0
	 */
	protected void applyProcessFactory(ILaunchConfigurationWorkingCopy config) {
		config.setAttribute(DebugPlugin.ATTR_PROCESS_FACTORY_ID,
				ScriptRuntimeProcessFactory.PROCESS_FACTORY_ID);
	}

	protected void performApplyConnectionTimeout(
			ILaunchConfigurationWorkingCopy config) {
		config.setAttribute(
				ScriptLaunchConfigurationConstants.ATTR_DLTK_DBGP_WAITING_TIMEOUT,
				(String) null);
	}

	@Override
	protected IResource getResource(ILaunchConfiguration config)
			throws CoreException {
		final String projectName = LaunchConfigurationUtils
				.getProjectName(config);
		if (projectName == null || projectName.length() == 0
				|| !Path.ROOT.isValidSegment(projectName)) {
			return null;
		}
		final IProject project = getWorkspaceRoot().getProject(projectName);
		if (project.exists() && project.isOpen()) {
			final String scriptName = config.getAttribute(
					ScriptLaunchConfigurationConstants.ATTR_MAIN_SCRIPT_NAME,
					(String) null);
			if (scriptName != null && scriptName.length() != 0
					&& new Path(scriptName).segmentCount() > 0
					&& Path.ROOT.isValidPath(scriptName)) {
				final IFile scriptFile = project.getFile(scriptName);
				if (scriptFile.exists()) {
					return scriptFile;
				}
			}
		}
		return project;
	}

	protected void performApplyInteractiveConsole(
			ILaunchConfigurationWorkingCopy config) {
		if (useInteractiveConsoleGroup) {
			final boolean useInteractiveConsole = this.interactiveConsoleCheck
					.getSelection();
			config.setAttribute(
					ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE,
					useInteractiveConsole);
			String old = null;
			try {
				old = config.getAttribute(
						ScriptLaunchConfigurationConstants.ATTR_DLTK_CONSOLE_ID,
						(String) null);
			} catch (CoreException e) {
				if (DLTKCore.DEBUG) {
					e.printStackTrace();
				}
			}
			if (old == null) {
				config.setAttribute(
						ScriptLaunchConfigurationConstants.ATTR_DLTK_CONSOLE_ID,
						"dltk_" + System.currentTimeMillis()); //$NON-NLS-1$
			}
		}
	}

	protected String getScriptName() {
		return fScriptText.getText().trim();
	}

	protected void setScriptName(String value) {
		fScriptText.setText(value);
	}

	/**
	 * Validates the selected launch script.
	 *
	 * @return true if the selected script is valid, false otherwise
	 */
	protected boolean validateScript() {
		URI script = validateAndGetScriptPath();
		IScriptProject project = getProject();
		IEnvironment environment = EnvironmentManager.getEnvironment(project);
		if (script != null) {
			FilePathValidator validator = new FieldValidators.FilePathValidator();
			IStatus result = validator.validate(script, environment);

			if (!result.isOK()) {
				IFileHandle file = PlatformFileUtils
						.findAbsoluteOrEclipseRelativeFile(environment,
								Path.fromPortableString(script.getPath()));
				if (file.exists() && file.isDirectory()) {
					if (useInteractiveConsoleGroup) {
						if (!interactiveConsoleCheck.getSelection()) {
							setErrorMessage(
									DLTKLaunchConfigurationsMessages.MainLaunchConfigurationTab_0);
							return false;
						}
						return true;
					} else {
						setErrorMessage(
								DLTKLaunchConfigurationsMessages.error_scriptNotFound);
						return false;
					}
				}
				setErrorMessage(
						DLTKLaunchConfigurationsMessages.error_scriptNotFound);
				return false;
			}
		}
		return true;
	}

	/**
	 * typo in method name
	 *
	 * @return
	 */
	@Deprecated
	protected final URI validatAndGetScriptPath() {
		return validateAndGetScriptPath();
	}

	/**
	 * Gets the currently selected {@link ISourceModule}.
	 *
	 * @return the selected source module or <code>null</code>
	 */
	protected ISourceModule getSourceModule() {
		final IScriptProject project = this.getProject();
		if (project == null) {
			return null;
		}
		final String scriptName = getScriptName();
		if (scriptName.length() == 0) {
			return null;
		}
		final IFile file = project.getProject().getFile(scriptName);
		return (ISourceModule) DLTKCore.create(file);
	}

	protected URI validateAndGetScriptPath() {
		String projectName = getProjectName();
		IScriptProject proj = getScriptModel().getScriptProject(projectName);
		if (proj != null) {
			notifyProjectChangedListeners(proj.getProject());
		} else {
			return null;
		}
		URI location = proj.getProject().getLocationURI();
		if (location == null) {
			setErrorMessage(
					DLTKLaunchConfigurationsMessages.error_notAValidProject);
			return null;
		}

		URI script = null;
		try {
			script = new URI(location.getScheme(), location.getHost(),
					location.getPath() + '/' + getScriptName(),
					location.getFragment());
		} catch (URISyntaxException e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace();
			}
		}
		if (script != null) {
			IFile[] files = getWorkspaceRoot().findFilesForLocationURI(script);
			if (files.length != 1) {
				return script;
			}

			IFile file = files[0];
			if (file.exists() && file.getLocationURI() != null) {
				script = file.getLocationURI();
			}
		}
		return script;
	}

	@Override
	protected boolean validate() {
		return super.validate() && validateScript();
	}

	@Override
	public Image getImage() {
		return DLTKPluginImages.get(DLTKPluginImages.IMG_OBJS_CLASS);
	}

	private String getMainModuleName(ILaunchConfiguration config) {
		return LaunchConfigurationUtils.getString(config,
				ScriptLaunchConfigurationConstants.ATTR_MAIN_SCRIPT_NAME,
				EMPTY_STRING);
	}

	@Override
	protected void createCustomSections(Composite parent) {
		if (useInteractiveConsoleGroup) {
			Group group = new Group(parent, SWT.NONE);
			group.setText(
					DLTKLaunchConfigurationsMessages.MainLaunchConfigurationTab_1);
			GridData gd = new GridData(GridData.FILL_HORIZONTAL);
			group.setLayoutData(gd);
			GridLayout layout = new GridLayout();
			layout.numColumns = 2;
			group.setLayout(layout);
			interactiveConsoleCheck = createCheckButton(group,
					DLTKLaunchConfigurationsMessages.MainLaunchConfigurationTab_2);
			interactiveConsoleCheck.addSelectionListener(getWidgetListener());
			interactiveConsoleCheck
					.addSelectionListener(new SelectionAdapter() {
						@Override
						public void widgetSelected(SelectionEvent e) {
							notifyInteractiveChangedListeners(
									interactiveConsoleCheck.getSelection());
						}
					});
		}
	}
}