/*******************************************************************************
 * Copyright (c) 2009, 2019 Mia-Software and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Gabriel Barbier (Mia-Software) - initial API and implementation
 *    Nicolas Bros (Mia-Software) - refactoring for new discovery framework
 *******************************************************************************/
package org.eclipse.modisco.infra.discovery.ui.internal.actions;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.modisco.facet.util.emf.core.IBrowserRegistry;
import org.eclipse.modisco.infra.common.core.logging.MoDiscoLogger;
import org.eclipse.modisco.infra.discovery.catalog.DiscovererDescription;
import org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter;
import org.eclipse.modisco.infra.discovery.core.AbstractModelDiscoverer;
import org.eclipse.modisco.infra.discovery.core.IDiscoverer;
import org.eclipse.modisco.infra.discovery.core.IDiscoveryManager;
import org.eclipse.modisco.infra.discovery.core.exception.DiscoveryException;
import org.eclipse.modisco.infra.discovery.launch.LaunchConfiguration;
import org.eclipse.modisco.infra.discovery.ui.Activator;
import org.eclipse.modisco.infra.discovery.ui.Messages;
import org.eclipse.modisco.infra.discovery.ui.internal.dialogs.GenericParametersDialog;
import org.eclipse.modisco.infra.discovery.ui.internal.util.LaunchConfigurationUtils;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class MoDiscoMenuSelectionListener implements SelectionListener {

	private final DiscovererDescription fDiscovererDesc;
	private final Object[] fSources;
	private final Shell shell;
	private final LaunchConfigurationUtils lcUtils;

	public MoDiscoMenuSelectionListener(final DiscovererDescription discoverer,
			final Object[] sourceParameter, final Shell shell) {
		this.fDiscovererDesc = discoverer;
		this.fSources = sourceParameter;
		this.shell = shell;
		this.lcUtils = new LaunchConfigurationUtils(discoverer, sourceParameter, shell);
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse
	 * .swt.events.SelectionEvent)
	 */
	public void widgetDefaultSelected(final SelectionEvent e) {
		// we will not use this method
	}

	private static class ParamsDialogResult {
		private final Map<DiscovererParameter, Object> parameterValues;
		private final boolean openModel;
		private final boolean cancelled;

		public ParamsDialogResult(final Map<DiscovererParameter, Object> parameterValues,
				final boolean openModel, final boolean cancelled) {
			this.parameterValues = parameterValues;
			this.openModel = openModel;
			this.cancelled = cancelled;
		}

		public Map<DiscovererParameter, Object> getParameterValues() {
			return this.parameterValues;
		}

		public boolean isOpenModel() {
			return this.openModel;
		}

		public boolean isCancelled() {
			return this.cancelled;
		}
	}


	/**
	 * Open a dialog box to let the user enter parameter values.
	 *
	 * @param discoverer
	 * @param source
	 *
	 * @return a map of (param, value), or <code>null</code> if cancelled by the
	 *         user
	 */
	private ParamsDialogResult chooseParameters(final IDiscoverer<?> discoverer, final Object source) {
		List<DiscovererParameter> inParameters = getExpectedInputParameters(this.fDiscovererDesc);
		if (inParameters.isEmpty()) {
			return new ParamsDialogResult(new HashMap<DiscovererParameter, Object>(), true, false);
		}

		LaunchConfiguration configurationModel = lcUtils.getLaunchConfigurationModel(source);

		boolean showOpenModelCheckbox = (discoverer instanceof AbstractModelDiscoverer<?>);

		GenericParametersDialog genericParametersDialog = new GenericParametersDialog(this.shell,
				inParameters, getDiscoverer().getId(), showOpenModelCheckbox, configurationModel);
		int result = genericParametersDialog.open();
		if (result == Window.OK) {
			Object[] parameterValues = genericParametersDialog.getParameterValues();
			assert parameterValues.length == inParameters.size();
			Map<DiscovererParameter, Object> parameterValuesMap = new HashMap<DiscovererParameter, Object>();
			for (int i = 0; i < inParameters.size(); i++) {
				DiscovererParameter parameter = inParameters.get(i);
				parameterValuesMap.put(parameter, parameterValues[i]);
			}
			lcUtils.saveParameters(parameterValuesMap, genericParametersDialog.isOpenModel());
			return new ParamsDialogResult(parameterValuesMap,
					genericParametersDialog.isOpenModel(), false);
		}
		return new ParamsDialogResult(null, false, true);
	}




	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt
	 * .events.SelectionEvent)
	 */
	public void widgetSelected(final SelectionEvent event) {
		final IDiscoverer<?> discoverer = IDiscoveryManager.INSTANCE
				.createDiscovererImpl(this.fDiscovererDesc);

		final Object[] sources = this.fSources;
		for (final Object source : sources) {
			final ParamsDialogResult paramsDialogResult = chooseParameters(discoverer, source);
			if (paramsDialogResult.isCancelled()) {
				return;
			}

			String name = MoDiscoMenuSelectionListener.this.getDiscoverer().getId();
			Job job = new Job(NLS.bind(
					Messages.MoDiscoMenuSelectionListener_modiscoDiscovererJobLabel, name)) {
				@Override
				protected IStatus run(final IProgressMonitor monitor) {
					monitor.beginTask(Messages.MoDiscoMenuSelectionListener_discovering,
							sources.length * 2);
					final Map<DiscovererParameter, Object> parameterValues = paramsDialogResult
							.getParameterValues();
					if (monitor.isCanceled()) {
						return Status.CANCEL_STATUS;
					}
					discovererElement(source, parameterValues, discoverer, monitor);
					monitor.worked(1);
					if (paramsDialogResult.isOpenModel()) {
						openModelEditor(discoverer);
					}
					monitor.worked(1);
					if (monitor.isCanceled()) {
						return Status.CANCEL_STATUS;
					}
					return Status.OK_STATUS;
				}
			};
			job.setPriority(Job.LONG);
			job.setUser(true);
			job.schedule();
		}
	}

	protected static void openModelEditor(final IDiscoverer<?> discoverer) {
		if (discoverer instanceof AbstractModelDiscoverer<?>) {
			AbstractModelDiscoverer<?> modelDiscoverer = (AbstractModelDiscoverer<?>) discoverer;
			Resource targetModel = modelDiscoverer.getTargetModel();
			if (targetModel != null) {
				// avoid null URI (it causes NPEs in EMF)
				if (targetModel.getURI() == null) {
					DiscovererDescription discovererDescription = IDiscoveryManager.INSTANCE
							.getDiscovererDescription(discoverer);
					targetModel.setURI(URI.createURI("temp:/" + discovererDescription.getId() //$NON-NLS-1$
							+ "/" + System.currentTimeMillis())); //$NON-NLS-1$
				}
				IBrowserRegistry.INSTANCE.browseResource(targetModel);
			}
		}
	}



	protected void discovererElement(final Object element,
			final Map<DiscovererParameter, Object> parameterValues,
			final IDiscoverer<?> discoverer, final IProgressMonitor monitor) {
		try {
			for (Entry<DiscovererParameter, Object> paramEntry : parameterValues.entrySet()) {
				DiscovererParameter parameter = paramEntry.getKey();
				Object value = paramEntry.getValue();
				if (value != null) {
					IDiscoveryManager.INSTANCE.setValue(parameter, discoverer, value);
				}
			}
			@SuppressWarnings("unchecked")
			IDiscoverer<Object> objectDiscoverer = (IDiscoverer<Object>) discoverer;
			String name;
			DiscovererDescription discovererDescription = IDiscoveryManager.INSTANCE
					.getDiscovererDescription(discoverer);
			if (discovererDescription != null) {
				name = discovererDescription.getId();
			} else {
				name = discoverer.getClass().getName();
			}
			monitor.beginTask(
					NLS.bind(Messages.MoDiscoMenuSelectionListener_discoveringModel, name),
					IProgressMonitor.UNKNOWN);
			objectDiscoverer.discoverElement(element, monitor);
		} catch (final DiscoveryException e) {
			MoDiscoLogger.logError(e, "Error in discovery", Activator.getDefault()); //$NON-NLS-1$
			// final String location;
			// StackTraceElement[] stackTrace = e.getStackTrace();
			// if (stackTrace != null && stackTrace.length > 0) {
			//				location = "\n" + Messages.MoDiscoMenuSelectionListener_in + stackTrace[0].toString(); //$NON-NLS-1$
			// } else {
			//				location = ""; //$NON-NLS-1$
			// }
			Display.getDefault().syncExec(new Runnable() {
				public void run() {
					MessageDialog.openError(
							MoDiscoMenuSelectionListener.this.shell,
							Messages.MoDiscoMenuSelectionListener_discoveryError,
							NLS.bind(Messages.MoDiscoMenuSelectionListener_errorInDiscovery,
									e.getLocalizedMessage()));
				}
			});
		}
	}

	protected DiscovererDescription getDiscoverer() {
		return this.fDiscovererDesc;
	}

	protected static List<DiscovererParameter> getExpectedInputParameters(
			final DiscovererDescription discoverer) {
		return LaunchConfigurationUtils.getExpectedInputParameters(discoverer);
	}



}