/*******************************************************************************
 * Copyright (c) 2007 Chase Technology Ltd - http://www.chasetechnology.co.uk
 * 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:
 *     Doug Satchwell (Chase Technology Ltd) - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsl.internal.debug.ui;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugModelPresentation;
import org.eclipse.debug.ui.ILaunchShortcut;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.StatusDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.wst.xsl.core.XSLCore;
import org.eclipse.wst.xsl.internal.debug.ui.tabs.main.InputFileBlock;
import org.eclipse.wst.xsl.launching.XSLLaunchConfigurationConstants;
import org.eclipse.wst.xsl.launching.config.BaseLaunchHelper;
import org.eclipse.wst.xsl.launching.config.LaunchPipeline;
import org.eclipse.wst.xsl.launching.config.LaunchTransform;

/**
 * <table border=1>
 * <th>
 * <tr>
 * <td>XML Files</td>
 * <td>XSL Files</td>
 * <td>Action</td>
 * </tr>
 * </th>
 * <tbody>
 * <tr>
 * <td>1</td>
 * <td>0</td>
 * <td>Launch assuming embedded stylesheet instruction</td>
 * </tr>
 * <tr>
 * <td>0</td>
 * <td>&gt;=1</td>
 * <td>Open dialog - prompt for input file</td>
 * </tr>
 * <tr>
 * <td>1</td>
 * <td>&gt;=1</td>
 * <td>Launch</td>
 * </tr>
 * </tbody>
 * </table>
 * 
 * <p>
 * The launch shortcut should not appear in the menu for any other combination
 * of files
 * </p>
 * <p>
 * In all cases, a check must be performed to find any existing launch
 * configuration that uses the selected files.
 * </p>
 * 
 * @author Doug
 * @since 1.0
 */
public class XSLLaunchShortcut implements ILaunchShortcut {
	private IFile xmlFile;
	private IPath xmlFilePath;
	private IFile[] xslFiles;

	public void launch(ISelection selection, String mode) {
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection ssel = (IStructuredSelection) selection;
			searchAndLaunch(ssel.toArray(), mode);
		}
	}

	public void launch(IEditorPart editor, String mode) {
		IEditorInput input = editor.getEditorInput();
		if (input != null) {
			IFile file = (IFile) input.getAdapter(IFile.class);
			if (file != null)
				searchAndLaunch(new Object[] { file }, mode);
		}
	}

	private void searchAndLaunch(Object[] objects, String mode) {
		if (fillFiles(objects)) {
			// ensure we have an input file
			if (xmlFile == null)
				promptForInput();
			if (xmlFile != null || xmlFilePath != null)
				launch(mode);
		}
	}

	private void promptForInput() {
		// prompt for input xml file
		StatusDialog dialog = new StatusDialog(getShell()) {
			private InputFileBlock inputFileBlock = new InputFileBlock(null);

			@Override
			protected Control createDialogArea(Composite parent) {
				Composite comp = (Composite) super.createDialogArea(parent);
				comp.setFont(parent.getFont());
				GridLayout layout = new GridLayout(1, false);
				comp.setLayout(layout);

				Label label = new Label(comp, SWT.NONE);
				label.setFont(comp.getFont());
				GridData gd = new GridData();
				gd.horizontalIndent = 5;
				gd.verticalIndent = 5;
				gd.widthHint = 380;
				label.setLayoutData(gd);
				label.setText(Messages.XSLLaunchShortcut_0);

				inputFileBlock.createControl(comp);
				return comp;
			}

			@Override
			protected void okPressed() {
				IResource res = inputFileBlock.getResource();
				if (res == null)
					xmlFilePath = new Path(inputFileBlock.getText());
				else if (ResourcesPlugin.getWorkspace().getRoot().exists(
						res.getFullPath())
						&& res.getType() == IResource.FILE)
					xmlFile = (IFile) res;
				super.okPressed();
			}

		};
		dialog.setHelpAvailable(false);
		dialog.setStatusLineAboveButtons(true);
		dialog.setTitle(Messages.XSLLaunchShortcut_1);
		dialog.open();
	}

	private boolean fillFiles(Object[] selections) {
		xmlFile = null;
		xmlFilePath = null;
		List<IFile> xslFileList = new ArrayList<IFile>();
		for (Object object : selections) {
			IResource resource = (IResource) object;
			if (resource.getType() == IResource.FILE) {
				IFile file = (IFile) resource;
				if (XSLCore.isXMLFile(file)) {
					if (XSLCore.isXSLFile(file))
						xslFileList.add(file);
					else if (xmlFile == null)
						xmlFile = file;
					else
						return false; // no action if we have more than than 1
										// xml file
				}
			}
		}
		xslFiles = xslFileList.toArray(new IFile[0]);
		return true;
	}

	private void launch(String mode) {
		if (xmlFile != null)
			xmlFilePath = xmlFile.getLocation();
		ILaunchConfiguration config = null;
		try {
			config = findOrCreateLaunchConfiguration();
			if (config != null)
				DebugUITools.launch(config, mode);
		} catch (CoreException e) {
			XSLDebugUIPlugin.log(e);
		}
	}

	protected ILaunchManager getLaunchManager() {
		return DebugPlugin.getDefault().getLaunchManager();
	}

	protected ILaunchConfigurationType getConfigurationType() {
		return getLaunchManager().getLaunchConfigurationType(
				XSLLaunchConfigurationConstants.ID_LAUNCH_CONFIG_TYPE);
	}

	private ILaunchConfiguration findOrCreateLaunchConfiguration()
			throws CoreException {
		ILaunchConfiguration[] configs = getLaunchManager()
				.getLaunchConfigurations(getConfigurationType());
		List<ILaunchConfiguration> candidateConfigs = new ArrayList<ILaunchConfiguration>(
				configs.length);
		for (ILaunchConfiguration config : configs) {
			String inputFile = config.getAttribute(
					XSLLaunchConfigurationConstants.ATTR_INPUT_FILE,
					(String) null);
			try {
				inputFile = VariablesPlugin.getDefault()
						.getStringVariableManager().performStringSubstitution(
								inputFile);
			} catch (CoreException e) {
				// just ignore this one
				continue;
			}
			Path path = new Path(inputFile);
			// the source xml file must be the same
			if (path.equals(xmlFilePath)) {
				BaseLaunchHelper lh = new BaseLaunchHelper(config);
				// all the selected stylesheets must be in the pipeline
				boolean found = false;
				for (IFile stylesheet : xslFiles) {
					found = false;
					for (Iterator<LaunchTransform> iter = lh.getPipeline()
							.getTransformDefs().iterator(); iter.hasNext();) {
						LaunchTransform lt = iter.next();
						if (lt.getLocation().equals(stylesheet.getLocation())) {
							found = true;
							break;
						}
					}
					if (!found)
						break;
				}
				if (found)
					candidateConfigs.add(config);
			}
		}

		ILaunchConfiguration config = null;
		int candidateCount = candidateConfigs.size();
		if (candidateCount == 1)
			config = candidateConfigs.get(0);
		else if (candidateCount > 1)
			config = chooseConfiguration(candidateConfigs);
		else
			config = createConfiguration();

		return config;
	}

	private ILaunchConfiguration chooseConfiguration(
			List<ILaunchConfiguration> configList) {
		IDebugModelPresentation labelProvider = DebugUITools
				.newDebugModelPresentation();
		ElementListSelectionDialog dialog = new ElementListSelectionDialog(
				getShell(), labelProvider);
		dialog.setElements(configList.toArray());
		dialog.setTitle(Messages.XSLLaunchShortcut_2);
		dialog.setMessage(Messages.XSLSelectExisting);
		dialog.setMultipleSelection(false);
		int result = dialog.open();
		labelProvider.dispose();
		if (result == Window.OK) {
			return (ILaunchConfiguration) dialog.getFirstResult();
		}
		return null;
	}

	private ILaunchConfiguration createConfiguration() {
		ILaunchConfiguration config = null;
		try {
			ILaunchConfigurationType configType = getConfigurationType();
			ILaunchConfigurationWorkingCopy wc = configType.newInstance(null,
					getLaunchManager()
							.generateUniqueLaunchConfigurationNameFrom(
									xmlFilePath.lastSegment()));
			if (xmlFile != null)
				wc
						.setAttribute(
								XSLLaunchConfigurationConstants.ATTR_INPUT_FILE,
								"${workspace_loc:" + xmlFile.getFullPath().toPortableString() + "}"); //$NON-NLS-1$ //$NON-NLS-2$
			else
				wc.setAttribute(
						XSLLaunchConfigurationConstants.ATTR_INPUT_FILE,
						xmlFilePath.toPortableString());

			wc
					.setAttribute(
							XSLLaunchConfigurationConstants.ATTR_USE_DEFAULT_OUTPUT_FILE,
							true);
			wc.setAttribute(XSLLaunchConfigurationConstants.ATTR_OPEN_FILE,
					true);

			LaunchPipeline pipeline = new LaunchPipeline();
			for (IFile element : xslFiles) {
				pipeline.addTransformDef(new LaunchTransform(element
						.getFullPath().toPortableString(),
						LaunchTransform.RESOURCE_TYPE));
			}
			wc.setAttribute(XSLLaunchConfigurationConstants.ATTR_PIPELINE,
					pipeline.toXML());
			if (xmlFile != null)
				wc.setMappedResources(new IResource[] { xmlFile.getProject() });
			config = wc.doSave();
		} catch (CoreException exception) {
			MessageDialog.openError(getShell(), Messages.XSLLaunchShortcut_6,
					exception.getStatus().getMessage());
		}
		return config;
	}

	protected Shell getShell() {
		return XSLDebugUIPlugin.getActiveWorkbenchShell();
	}
}