/*******************************************************************************
 * Copyright (c) 2010, 2017 BestSolution.at and others.
 * 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:
 * Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
 * Olivier Prouvost <olivier.prouvost@opcoach.com> - added some cache for e4xmi resource management
 ******************************************************************************/
package org.eclipse.e4.tools.emf.ui.common;

import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.SortedSet;
import java.util.TreeSet;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.e4.tools.emf.ui.common.IEditorFeature.FeatureClass;
import org.eclipse.e4.ui.model.application.MApplicationElement;
import org.eclipse.e4.ui.model.application.impl.ApplicationPackageImpl;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.impl.UiPackageImpl;
import org.eclipse.e4.ui.model.fragment.impl.FragmentPackageImpl;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.edit.command.MoveCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.jface.fieldassist.FieldDecoration;
import org.eclipse.jface.fieldassist.FieldDecorationRegistry;
import org.eclipse.pde.internal.core.PDEExtensionRegistry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Control;

public class Util {

	private static final String APP_E4XMI_DEFAULT = "Application.e4xmi"; //$NON-NLS-1$

	public static final boolean isNullOrEmpty(String element) {
		return element == null || element.trim().length() == 0;
	}

	public static final boolean isImport(EObject object) {
		return object.eContainingFeature() == FragmentPackageImpl.Literals.MODEL_FRAGMENTS__IMPORTS;
	}

	public static final void addClasses(EPackage ePackage, List<FeatureClass> list) {
		for (final EClassifier c : ePackage.getEClassifiers()) {
			if (c instanceof EClass) {
				final EClass eclass = (EClass) c;
				if (eclass != ApplicationPackageImpl.Literals.APPLICATION && !eclass.isAbstract()
						&& !eclass.isInterface()
						&& eclass.getEAllSuperTypes().contains(ApplicationPackageImpl.Literals.APPLICATION_ELEMENT)) {
					list.add(new FeatureClass(eclass.getName(), eclass));
				}
			}
		}

		for (final EPackage eSubPackage : ePackage.getESubpackages()) {
			addClasses(eSubPackage, list);
		}
	}

	// TODO In future support different name formats something like
	// ${project}.${classname}.${counter}
	public static final String getDefaultElementId(Resource resource, MApplicationElement element, IProject project) {
		try {
			final EObject o = (EObject) element;
			final String className = o.eClass().getName();
			final String projectName = project.getName();

			final String prefix = (projectName + "." + className).toLowerCase(); //$NON-NLS-1$

			final TreeIterator<EObject> it = resource.getAllContents();
			final SortedSet<Integer> numbers = new TreeSet<>();

			while (it.hasNext()) {
				final EObject tmp = it.next();
				if (tmp instanceof MApplicationElement) {
					final String elementId = ((MApplicationElement) tmp).getElementId();
					if (elementId != null && elementId.length() > prefix.length() && elementId.startsWith(prefix)) {
						final String suffix = elementId.substring(prefix.length());
						if (suffix.startsWith(".") && suffix.length() > 1) { //$NON-NLS-1$
							try {
								numbers.add(Integer.parseInt(suffix.substring(1)));
							} catch (final Exception e) {
								// TODO: handle exception
							}
						}
					}
				}
			}

			int lastNumber = -1;
			for (final Integer number : numbers) {
				if (lastNumber + 1 != number) {
					break;
				}
				lastNumber = number;
			}

			return (prefix + "." + ++lastNumber).toLowerCase(); //$NON-NLS-1$
		} catch (final Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return null;
	}

	public static List<InternalPackage> loadPackages() {
		final List<InternalPackage> packs = new ArrayList<>();

		for (final Entry<String, Object> regEntry : EPackage.Registry.INSTANCE.entrySet()) {
			if (regEntry.getValue() instanceof EPackage) {
				final EPackage ePackage = (EPackage) regEntry.getValue();
				final InternalPackage iePackage = new InternalPackage(ePackage);
				boolean found = false;
				for (final EClassifier cl : ePackage.getEClassifiers()) {
					if (cl instanceof EClass) {
						final EClass eClass = (EClass) cl;
						if (eClass.getEAllSuperTypes().contains(ApplicationPackageImpl.Literals.APPLICATION_ELEMENT)) {
							if (!eClass.isInterface() && !eClass.isAbstract()) {
								found = true;
								final InternalClass ieClass = new InternalClass(iePackage, eClass);
								iePackage.classes.add(ieClass);
								for (final EReference f : eClass.getEAllReferences()) {
									ieClass.features.add(new InternalFeature(ieClass, f));
								}
							}
						}
					}
				}
				if (found) {
					packs.add(iePackage);
				}
			}
		}

		return packs;
	}

	public static boolean moveElementByIndex(EditingDomain editingDomain, MUIElement element, boolean liveModel,
			int index, EStructuralFeature feature) {
		if (liveModel) {
			final EObject container = ((EObject) element).eContainer();
			@SuppressWarnings("unchecked")
			final List<Object> l = (List<Object>) container.eGet(feature);
			l.remove(element);

			if (index >= 0) {
				l.add(index, element);
			} else {
				l.add(element);
			}

			return true;
		}
		final EObject container = ((EObject) element).eContainer();
		final Command cmd = MoveCommand.create(editingDomain, container, feature, element, index);

		if (cmd.canExecute()) {
			editingDomain.getCommandStack().execute(cmd);
			return true;
		}
		return false;
	}

	public static boolean moveElementByIndex(EditingDomain editingDomain, MUIElement element, boolean liveModel,
			int index) {
		if (liveModel) {
			final MElementContainer<MUIElement> container = element.getParent();
			container.getChildren().remove(element);

			if (index >= 0) {
				container.getChildren().add(index, element);
			} else {
				container.getChildren().add(element);
			}

			container.setSelectedElement(element);
			return true;
		}
		final MElementContainer<MUIElement> container = element.getParent();
		final Command cmd = MoveCommand.create(editingDomain, container,
				UiPackageImpl.Literals.ELEMENT_CONTAINER__CHILDREN, element, index);

		if (cmd.canExecute()) {
			editingDomain.getCommandStack().execute(cmd);
			return true;
		}
		return false;
	}

	/**
	 * The set of resources containing model element. Updated when one changes
	 * in the workspace
	 */
	private static ResourceSet modelResourceSet;

	// The lis
	private static boolean e4ModelResourceListenerRegistered = false;

	/**
	 * This method searches for fragments or application model elements
	 * resources. It is updated when the workspace changes.. else it returns the
	 * cached values.
	 */
	public static ResourceSet getModelElementResources() {

		// Return previous computed result while workspace did not change...
		if (modelResourceSet != null) {
			return modelResourceSet;
		}

		registerE4XmiListener(); // Done only once.

		modelResourceSet = new ResourceSetImpl();
		final PDEExtensionRegistry reg = new PDEExtensionRegistry();
		IExtension[] extensions = reg.findExtensions("org.eclipse.e4.workbench.model", true); //$NON-NLS-1$
		final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

		for (final IExtension ext : extensions) {
			for (final IConfigurationElement el : ext.getConfigurationElements()) {
				if (el.getName().equals("fragment")) { //$NON-NLS-1$
					URI uri;
					// System.err.println("Model-Ext: Checking: " +
					// ext.getContributor().getName());
					final IProject p = root.getProject(ext.getContributor().getName());
					if (p.exists() && p.isOpen()) {
						uri = URI.createPlatformResourceURI(
								ext.getContributor().getName() + "/" + el.getAttribute("uri"), true); //$NON-NLS-1$ //$NON-NLS-2$
					} else {
						uri = URI.createURI("platform:/plugin/" + ext.getContributor().getName() + "/" //$NON-NLS-1$ //$NON-NLS-2$
								+ el.getAttribute("uri")); //$NON-NLS-1$
					}
					// System.err.println(uri);
					try {
						modelResourceSet.getResource(uri, true);
					} catch (final Exception e) {
						e.printStackTrace();
						// System.err.println("=============> Failing");
					}

				}
			}
		}

		extensions = reg.findExtensions("org.eclipse.core.runtime.products", true); //$NON-NLS-1$
		for (final IExtension ext : extensions) {
			for (final IConfigurationElement el : ext.getConfigurationElements()) {
				if (el.getName().equals("product")) { //$NON-NLS-1$
					boolean xmiPropertyPresent = false;
					for (final IConfigurationElement prop : el.getChildren("property")) { //$NON-NLS-1$
						if (prop.getAttribute("name").equals("applicationXMI")) { //$NON-NLS-1$//$NON-NLS-2$
							final String v = prop.getAttribute("value"); //$NON-NLS-1$
							setUpResourceSet(modelResourceSet, root, v);
							xmiPropertyPresent = true;
							break;
						}
					}
					if (!xmiPropertyPresent) {
						setUpResourceSet(modelResourceSet, root,
								ext.getNamespaceIdentifier() + "/" + APP_E4XMI_DEFAULT); //$NON-NLS-1$
						break;
					}
				}
			}
		}
		return modelResourceSet;
	}

	/**
	 * A listener to reset the cache of e4Xmi resource for the index research
	 *
	 */
	private static void registerE4XmiListener() {
		// Register once on the workspace.
		// the listener could be optimized to remember of changed resource since
		// the last call to getModelElementResources...
		if (!e4ModelResourceListenerRegistered) {
			ResourcesPlugin.getWorkspace().addResourceChangeListener(new IResourceChangeListener() {
				@Override
				public void resourceChanged(IResourceChangeEvent event) {
					// Nothing to do if resource set not yet used !
					if (modelResourceSet == null) {
						return;
					}
					IResourceDelta delta = event.getDelta();
					checkDeltaContainsE4xmi(delta);
				}

				private void checkDeltaContainsE4xmi(IResourceDelta delta) {
					if (modelResourceSet == null) {
						return;
					}

					for (IResourceDelta rd : delta.getAffectedChildren()) {
						IResource r = rd.getResource();
						if (r instanceof IFile)
						{
							if ("e4xmi".equals(((IFile) r).getFileExtension())) {
								modelResourceSet = null;
								break;
							}
						} else {
							checkDeltaContainsE4xmi(rd);
						}
					}

				}
			});
			e4ModelResourceListenerRegistered = true;
		}
	}


	private static void setUpResourceSet(ResourceSet resourceSet, IWorkspaceRoot root, String v) {
		final String[] s = v.split("/"); //$NON-NLS-1$
		URI uri;
		// System.err.println("Product-Ext: Checking: " + v + " => P:" + s[0] +
		// "");
		final IProject p = root.getProject(s[0]);
		if (p.exists() && p.isOpen()) {
			uri = URI.createPlatformResourceURI(v, true);
		} else {
			uri = URI.createURI("platform:/plugin/" + v); //$NON-NLS-1$
		}

		try {
			// prevent some unnecessary calls by checking the uri
			if (resourceSet.getURIConverter().exists(uri, null)) {
				resourceSet.getResource(uri, true);
			}
		} catch (final Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * This method checks if an EClass can be extended using a fragment. ie : it
	 * must have containment EReference to a model object.
	 *
	 * @param c
	 * @return true if at least one reference type is not a StringStringToMap or
	 *         other no editable type
	 */
	public static boolean canBeExtendedInAFragment(EClass c) {
		boolean result = false;
		for (EReference r : c.getEAllReferences()) {
			if (referenceIsModelFragmentCompliant(r)) {
				result = true;
				break;
			}
		}
		return result;
	}

	/**
	 * This method checks if an EReference can be considered in a model fragment
	 * ie : it must be containment EReference to a model object.
	 *
	 * @param c
	 * @return true if the reference is containment and type is not a
	 *         StringStringToMap or other no editable type
	 */
	public static boolean referenceIsModelFragmentCompliant(EReference r) {
		String t = r.getEReferenceType().getName();
		return (r.isContainment() && !t.equals("StringToStringMap") && !t.equals("StringToObjectMap"));

	}

	public static final void addDecoration(Control control, Binding binding) {
		final ControlDecoration dec = new ControlDecoration(control, SWT.BOTTOM);
		binding.getValidationStatus().addValueChangeListener(event -> {
			final IStatus s = (IStatus) event.getObservableValue().getValue();
			if (s.isOK()) {
				dec.setDescriptionText(null);
				dec.setImage(null);
			} else {
				dec.setDescriptionText(s.getMessage());

				String fieldDecorationID = null;
				switch (s.getSeverity()) {
				case IStatus.INFO:
					fieldDecorationID = FieldDecorationRegistry.DEC_INFORMATION;
					break;
				case IStatus.WARNING:
					fieldDecorationID = FieldDecorationRegistry.DEC_WARNING;
					break;
				case IStatus.ERROR:
				case IStatus.CANCEL:
					fieldDecorationID = FieldDecorationRegistry.DEC_ERROR;
					break;
				}
				final FieldDecoration fieldDecoration = FieldDecorationRegistry.getDefault()
						.getFieldDecoration(fieldDecorationID);
				dec.setImage(fieldDecoration == null ? null : fieldDecoration.getImage());
			}
		});
	}

	public static class InternalPackage {
		public final EPackage ePackage;
		public List<InternalClass> classes = new ArrayList<>();

		public InternalPackage(EPackage ePackage) {
			this.ePackage = ePackage;
		}

		@Override
		public String toString() {
			return ePackage.toString();
		}

		public List<EClass> getAllClasses() {
			final ArrayList<EClass> rv = new ArrayList<>(classes.size());
			for (final InternalClass c : classes) {
				rv.add(c.eClass);
			}
			return rv;
		}
	}

	public static class InternalClass {
		public final InternalPackage pack;
		public final EClass eClass;
		public List<InternalFeature> features = new ArrayList<>();

		public InternalClass(InternalPackage pack, EClass eClass) {
			this.eClass = eClass;
			this.pack = pack;
		}
	}

	public static class InternalFeature {
		public final InternalClass clazz;
		public final EStructuralFeature feature;

		public InternalFeature(InternalClass clazz, EStructuralFeature feature) {
			this.clazz = clazz;
			this.feature = feature;
		}

	}
}