/*******************************************************************************
 * Copyright (c) 2011-2013 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * Eugen Neufeld - initial API and implementation
 ******************************************************************************/

package org.eclipse.emf.ecp.view.internal.editor.controls;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.Enumerator;
import org.eclipse.emf.databinding.EMFUpdateValueStrategy;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.EEnumImpl;
import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
import org.eclipse.emf.ecp.view.spi.core.swt.SimpleControlSWTControlSWTRenderer;
import org.eclipse.emf.ecp.view.spi.model.VControl;
import org.eclipse.emf.ecp.view.spi.provider.ECPTooltipModifierHelper;
import org.eclipse.emf.ecp.view.template.model.VTViewTemplateProvider;
import org.eclipse.emfforms.spi.common.report.ReportService;
import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedException;
import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedReport;
import org.eclipse.emfforms.spi.core.services.databinding.EMFFormsDatabinding;
import org.eclipse.emfforms.spi.core.services.label.EMFFormsLabelProvider;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
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.dialogs.ListDialog;

/**
 * A control for defining an value in a leaf condition.
 *
 * @author Eugen Neufeld
 *
 */
// APITODO no api yet
public abstract class ExpectedValueControlRenderer extends SimpleControlSWTControlSWTRenderer {

	/**
	 * Default constructor.
	 *
	 * @param vElement the view model element to be rendered
	 * @param viewContext the view context
	 * @param reportService The {@link ReportService}
	 * @param databindingService The {@link EMFFormsDatabinding}
	 * @param labelProvider The {@link EMFFormsLabelProvider}
	 * @param viewTemplateProvider The {@link VTViewTemplateProvider}
	 */
	public ExpectedValueControlRenderer(VControl vElement, ViewModelContext viewContext,
		ReportService reportService, EMFFormsDatabinding databindingService, EMFFormsLabelProvider labelProvider,
		VTViewTemplateProvider viewTemplateProvider) {
		super(vElement, viewContext, reportService, databindingService, labelProvider, viewTemplateProvider);
	}

	private Label text;
	private Shell shell;

	private String getTextVariantID() {
		return "org_eclipse_emf_ecp_view_editor_controls_ruleattribute"; //$NON-NLS-1$
	}

	@Override
	public void finalizeRendering(Composite parent) {
		super.finalizeRendering(parent);
		shell = parent.getShell();
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.view.spi.core.swt.SimpleControlSWTControlSWTRenderer#createSWTControl(org.eclipse.swt.widgets.Composite)
	 */
	@Override
	protected Control createSWTControl(Composite parent) {
		final Composite composite = new Composite(parent, SWT.NONE);
		GridLayoutFactory.fillDefaults().numColumns(2).applyTo(composite);
		GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.BEGINNING).applyTo(composite);
		final Button bSelectObject = new Button(composite, SWT.PUSH);
		bSelectObject.setText("Select Object"); //$NON-NLS-1$

		text = new Label(composite, SWT.SINGLE | SWT.BORDER);
		text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		text.setData(CUSTOM_VARIANT, getTextVariantID());

		bSelectObject.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				super.widgetSelected(e);
				onSelectButton(text);
			}
		});
		return text;
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.view.spi.core.swt.SimpleControlSWTControlSWTRenderer#createBindings(org.eclipse.swt.widgets.Control,
	 *      org.eclipse.emf.ecore.EStructuralFeature.Setting)
	 */
	@Override
	protected Binding[] createBindings(Control control) throws DatabindingFailedException {
		final Label text = (Label) control;
		final TargetToModelUpdateStrategy targetToModelUpdateStrategy = new TargetToModelUpdateStrategy();
		final ModelToTargetUpdateStrategy modelToTargetUpdateStrategy = new ModelToTargetUpdateStrategy();

		final IObservableValue value = org.eclipse.jface.databinding.swt.typed.WidgetProperties.text().observe(text);

		final Binding binding = getDataBindingContext().bindValue(value, getModelValue(),
			withPreSetValidation(targetToModelUpdateStrategy), modelToTargetUpdateStrategy);
		return new Binding[] { binding };
	}

	/**
	 * Creates a tooltip binding for this control.
	 *
	 * @param text the {@link Text} to bind
	 * @param modelValue the {@link IObservableValue} to bind
	 * @param dataBindingContext the {@link DataBindingContext} to use
	 * @param targetToModel the {@link UpdateValueStrategy} from target to Model
	 * @param modelToTarget the {@link UpdateValueStrategy} from model to target
	 * @return the created {@link Binding}
	 */
	protected Binding createTooltipBinding(Control text, IObservableValue modelValue,
		DataBindingContext dataBindingContext, UpdateValueStrategy targetToModel, UpdateValueStrategy modelToTarget) {
		final IObservableValue toolTip = org.eclipse.jface.databinding.swt.typed.WidgetProperties.tooltipText()
			.observe(text);
		return dataBindingContext.bindValue(toolTip, modelValue, targetToModel, modelToTarget);
	}

	/**
	 * Lets the user select an object and returns the selection.
	 *
	 * @param attribute the attribute for which an object is needed
	 * @return the object
	 */
	protected Object getSelectedObject(EAttribute attribute) {
		Object object = null;
		// final EAttribute attribute = (EAttribute) structuralFeature;
		if (attribute == null) {
			showError(shell, "Missing Attribute", //$NON-NLS-1$
				"Please select an attribute before attempting to select its value."); //$NON-NLS-1$
			return object;
		}
		Class<?> attribuetClazz = attribute.getEAttributeType().getInstanceClass();

		if (attribuetClazz == null) {
			if (EcorePackage.eINSTANCE.getEEnum().isInstance(attribute.getEType())) {
				attribuetClazz = Enum.class;
				final EList<EEnumLiteral> eLiterals = EEnumImpl.class.cast(attribute.getEType()).getELiterals();
				final Object[] enumValues = eLiterals.toArray();
				final ListDialog ld = new ListDialog(shell);
				ld.setLabelProvider(new LabelProvider());
				ld.setContentProvider(ArrayContentProvider.getInstance());
				ld.setInput(enumValues);
				ld.setInitialSelections(new Object[] { enumValues[0] });
				ld.setMessage("Please select the enum value to set."); //$NON-NLS-1$
				ld.setTitle("Select a value"); //$NON-NLS-1$
				final int enumSelectionResult = ld.open();
				if (Window.OK == enumSelectionResult) {
					object = EEnumLiteral.class.cast(ld.getResult()[0]).getLiteral();
				}
			} else {
				return null;
			}
		} else {
			if (attribuetClazz.isPrimitive()) {
				attribuetClazz = getAttributeClass(attribuetClazz);
			}
			if (Enum.class.isAssignableFrom(attribuetClazz)) {
				final Object[] enumValues = attribuetClazz.getEnumConstants();
				final ListDialog ld = new ListDialog(shell);
				ld.setLabelProvider(new LabelProvider());
				ld.setContentProvider(ArrayContentProvider.getInstance());
				ld.setInput(enumValues);
				ld.setInitialSelections(new Object[] { enumValues[0] });
				ld.setMessage("Please select the enum value to set."); //$NON-NLS-1$
				ld.setTitle("Select a value"); //$NON-NLS-1$
				final int enumSelectionResult = ld.open();
				if (Window.OK == enumSelectionResult) {
					object = Enumerator.class.cast(ld.getResult()[0]).getLiteral();
				}
			} else if (String.class.isAssignableFrom(attribuetClazz)
				|| Number.class.isAssignableFrom(attribuetClazz)
				|| Boolean.class.isAssignableFrom(attribuetClazz)) {
				object = promptForValue(shell, object, attribuetClazz);
			} else {
				showError(shell, "Not primitive Attribute selected", //$NON-NLS-1$
					"The selected attribute has a not primitive type. We can't provide you support for it!"); //$NON-NLS-1$
			}
		}
		return object;
	}

	/**
	 * Shows an error message to the user.
	 *
	 * @param shell The Shell to show the error on
	 * @param title The title of the error message
	 * @param description The error description
	 */
	protected void showError(Shell shell, String title, String description) {
		MessageDialog.openError(shell, title, description);
	}

	/**
	 * Prompts the user to input a value. Return the original object if the input is cancelled.
	 *
	 * @param shell The Shell on which an input dialog will be opened
	 * @param object The current value
	 * @param attributeClazz The Class for which we want a value
	 * @return the prompted value, or the input object if the prompt was cancelled
	 */
	Object promptForValue(Shell shell, Object object, Class<?> attributeClazz) {
		try {
			final Constructor<?> constructor = attributeClazz.getConstructor(String.class);
			final InputDialog id = new InputDialog(
				shell,
				"Insert the value", //$NON-NLS-1$
				"The value must be parseable by the " //$NON-NLS-1$
					+ attributeClazz.getSimpleName()
					+ " class. For a double value please use the #.# format. For boolean values 'true' or 'false'.", //$NON-NLS-1$
				null, null);
			final int inputResult = id.open();
			if (Window.OK == inputResult) {
				object = constructor.newInstance(id.getValue());
			}
			if (Boolean.class.isAssignableFrom(attributeClazz) && !Boolean.class.cast(object)
				&& !"false".equalsIgnoreCase(id.getValue())) { //$NON-NLS-1$
				showError(shell, "Invalid boolean value", //$NON-NLS-1$
					"You have entered an invalid value. False has been chosen instead."); //$NON-NLS-1$
			}
		} catch (final IllegalArgumentException ex) {
			openInvalidValueMessage();
		} catch (final SecurityException ex) {
			openInvalidValueMessage();
		} catch (final NoSuchMethodException ex) {
			openInvalidValueMessage();
		} catch (final InstantiationException ex) {
			openInvalidValueMessage();
		} catch (final IllegalAccessException ex) {
			openInvalidValueMessage();
		} catch (final InvocationTargetException ex) {
			openInvalidValueMessage();
		}
		return object;
	}

	private Class<?> getAttributeClass(Class<?> attributeClazz) {
		if (int.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Integer.class;
		} else if (long.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Long.class;
		} else if (float.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Float.class;
		} else if (double.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Double.class;
		} else if (boolean.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Boolean.class;
		} else if (char.class.isAssignableFrom(attributeClazz)) {
			attributeClazz = Character.class;
		}
		return attributeClazz;
	}

	private void openInvalidValueMessage() {
		MessageDialog.openError(shell, "Invalid value", //$NON-NLS-1$
			"You have entered an invalid value. The previsous value will be kept."); //$NON-NLS-1$
	}

	/**
	 * Called when the select value button is pressed.
	 *
	 * @param text the label which should be used to set the value
	 */
	protected abstract void onSelectButton(Label text);

	/**
	 * Returns the model object representing the value for this renderer's domain model reference.
	 *
	 * @return the EObject
	 * @throws DatabindingFailedException if the databinding fails
	 */
	protected EObject getObservedEObject() throws DatabindingFailedException {
		final IObservableValue observableValue = getEMFFormsDatabinding()
			.getObservableValue(getVElement().getDomainModelReference(), getViewModelContext().getDomainModel());
		final EObject result = (EObject) ((IObserving) observableValue).getObserved();
		observableValue.dispose();
		return result;
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.view.spi.core.swt.SimpleControlSWTRenderer#getUnsetText()
	 */
	@Override
	protected String getUnsetText() {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * The strategy to convert from model to target.
	 *
	 * @author Eugen Neufeld
	 *
	 */
	protected class ModelToTargetUpdateStrategy extends EMFUpdateValueStrategy {

		@Override
		public Object convert(Object value) {
			final Object converted = value.toString();
			if (String.class.isInstance(converted)) {
				IObservableValue observableValue;
				try {
					observableValue = getEMFFormsDatabinding()
						.getObservableValue(getVElement().getDomainModelReference(),
							getViewModelContext().getDomainModel());
				} catch (final DatabindingFailedException ex) {
					getReportService().report(new DatabindingFailedReport(ex));
					return converted;
				}
				final InternalEObject internalEObject = (InternalEObject) ((IObserving) observableValue).getObserved();
				final EStructuralFeature structuralFeature = (EStructuralFeature) observableValue.getValueType();
				observableValue.dispose();
				return ECPTooltipModifierHelper.modifyString(String.class.cast(converted),
					internalEObject.eSetting(structuralFeature));
			}
			return converted;
		}

	}

	/**
	 * The strategy to convert from target to model.
	 *
	 * @author Eugen
	 *
	 */
	protected class TargetToModelUpdateStrategy extends EMFUpdateValueStrategy {

		/**
		 * Constructor for indicating whether a value is unsettable.
		 */
		public TargetToModelUpdateStrategy() {
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public Object convert(Object value) {
			return value;
		}
	}

}