/*******************************************************************************
 * Copyright (c) 2011-2019 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
 * Christian W. Damus - bugs 543376, 548592
 ******************************************************************************/
package org.eclipse.emf.ecp.ide.editor.view;

import static org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory.provide;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Files;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.eclipse.core.resources.IFile;
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.IResourceDeltaVisitor;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.CommandStackListener;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecp.edit.spi.EMFDeleteServiceImpl;
import org.eclipse.emf.ecp.ide.editor.view.messages.Messages;
import org.eclipse.emf.ecp.ide.spi.util.EcoreHelper;
import org.eclipse.emf.ecp.ide.spi.util.ViewModelHelper;
import org.eclipse.emf.ecp.ide.view.service.ViewModelEditorCallback;
import org.eclipse.emf.ecp.spi.view.migrator.TemplateModelMigrationException;
import org.eclipse.emf.ecp.spi.view.migrator.TemplateModelMigratorUtil;
import org.eclipse.emf.ecp.spi.view.migrator.TemplateModelWorkspaceMigrator;
import org.eclipse.emf.ecp.ui.view.ECPRendererException;
import org.eclipse.emf.ecp.ui.view.swt.DefaultReferenceService;
import org.eclipse.emf.ecp.ui.view.swt.ECPSWTView;
import org.eclipse.emf.ecp.ui.view.swt.ECPSWTViewRenderer;
import org.eclipse.emf.ecp.view.migrator.ViewModelMigrationException;
import org.eclipse.emf.ecp.view.migrator.ViewModelMigrator;
import org.eclipse.emf.ecp.view.migrator.ViewModelMigratorUtil;
import org.eclipse.emf.ecp.view.migrator.ViewModelWorkspaceMigrator;
import org.eclipse.emf.ecp.view.model.common.edit.provider.CustomReflectiveItemProviderAdapterFactory;
import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
import org.eclipse.emf.ecp.view.spi.model.VView;
import org.eclipse.emf.ecp.view.spi.model.reporting.StatusReport;
import org.eclipse.emf.ecp.view.spi.provider.ViewProviderHelper;
import org.eclipse.emf.ecp.view.spi.swt.services.ECPSelectionProviderService;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.util.EditUIUtil;
import org.eclipse.emfforms.spi.common.report.AbstractReport;
import org.eclipse.emfforms.spi.editor.GotoMarkerAdapter;
import org.eclipse.emfforms.spi.editor.helpers.ResourceSetHelpers;
import org.eclipse.emfforms.spi.ide.view.segments.DmrToSegmentsMigrationException;
import org.eclipse.emfforms.spi.ide.view.segments.DmrToSegmentsMigrator;
import org.eclipse.emfforms.spi.ide.view.segments.ToolingModeUtil;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IPathEditorInput;
import org.eclipse.ui.IStorageEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.eclipse.ui.dialogs.ListSelectionDialog;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.model.BaseWorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.part.EditorPart;
import org.eclipse.ui.part.FileEditorInput;

/**
 * The IDE ViewModel EditorPart.
 *
 * @author Eugen Neufeld
 *
 */
public class ViewEditorPart extends EditorPart implements
	ViewModelEditorCallback, IEditingDomainProvider {

	private URI inputUri;
	private Resource resource;
	private BasicCommandStack basicCommandStack;
	private Composite parent;
	private ECPSWTView render;

	private boolean ecoreOutOfSync;
	private IPartListener2 partListener;
	private final ViewEditorPart instance;
	private AdapterFactoryEditingDomain editingDomain;

	/** Default constructor for {@link ViewEditorPart}. */
	public ViewEditorPart() {
		super();
		instance = this;
	}

	@Override
	public void doSave(IProgressMonitor monitor) {
		// Do the work within an operation because this is a long running activity that modifies the workbench.
		final WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
			@Override
			public void execute(IProgressMonitor monitor) {
				try {
					resource.save(getSaveOptions());
				} catch (final IOException e) {
					Activator.getDefault().getLog()
						.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
				}
			}
		};
		try {
			new ProgressMonitorDialog(getSite().getShell()).run(true, false, operation);
			basicCommandStack.saveIsDone();
			firePropertyChange(IEditorPart.PROP_DIRTY);
		} catch (final InvocationTargetException e) {
			Activator.getDefault().getLog()
				.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
		} catch (final InterruptedException e) {
			Activator.getDefault().getLog()
				.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
		}

	}

	/**
	 * Get the save options used when saving the view model.
	 *
	 * @return The save options
	 */
	protected Map<Object, Object> getSaveOptions() {
		final Map<Object, Object> options = new HashMap<>();
		options.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
		return options;
	}

	@Override
	public void doSaveAs() {
		// unsupported
	}

	@Override
	public void init(IEditorSite site, IEditorInput input)
		throws PartInitException {
		super.setSite(site);
		super.setInput(input);
		super.setPartName(input.getName());

		try {
			basicCommandStack = new BasicCommandStack();
			editingDomain = new AdapterFactoryEditingDomain(
				new ComposedAdapterFactory(new AdapterFactory[] {
					new CustomReflectiveItemProviderAdapterFactory(),
					new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE) }),
				basicCommandStack);
			editingDomain.getResourceSet().getLoadOptions().put(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE,
				Boolean.TRUE);
			loadView(false, false);
		} // BEGIN SUPRESS CATCH EXCEPTION
		catch (final Exception e) {// END SUPRESS CATCH EXCEPTION
			/*
			 * ignore all exceptions during first loading of view. The view might actually be an outdated view, so the
			 * second call will migrate the view. if the migration step fails or is not possible at all, we will fail in
			 * the later call.
			 */
		}

		try {
			registerEcore(resource);
			// BEGIN SUPRESS CATCH EXCEPTION
		} catch (final Exception e) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
			throw new PartInitException(
				MessageFormat.format(Messages.ViewEditorPart_ViewCannotBeDisplayed, e.getLocalizedMessage()), e);
		} // END SUPRESS CATCH EXCEPTION

		try {
			// reload view resource after EClass' package resource was loaded into the package registry
			loadView(true, true);
			checkLoadedView();
			// BEGIN SUPRESS CATCH EXCEPTION
		} catch (final Exception e) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
			throw new PartInitException(
				MessageFormat.format(Messages.ViewEditorPart_ViewCannotBeDisplayed, e.getLocalizedMessage()), e);
		} // END SUPRESS CATCH EXCEPTION

		basicCommandStack.addCommandStackListener(new CommandStackListener() {
			@Override
			public void commandStackChanged(final EventObject event) {
				parent.getDisplay().asyncExec(new Runnable() {
					@Override
					public void run() {
						firePropertyChange(IEditorPart.PROP_DIRTY);
					}
				});
			}
		});
		partListener = new ViewPartListener();
		getSite().getPage().addPartListener(partListener);

		final IResourceChangeListener listener = new EditorResourceChangedListener();
		ResourcesPlugin.getWorkspace().addResourceChangeListener(listener);
	}

	/**
	 * @since 1.20
	 */
	@Override
	public EditingDomain getEditingDomain() {
		return editingDomain;
	}

	@Override
	public <T> T getAdapter(Class<T> adapter) {
		if (adapter == ViewModelContext.class) {
			return adapter.cast(render.getViewModelContext());
		}
		if (adapter == IGotoMarker.class) {
			return adapter.cast(new GotoMarkerAdapter(render.getViewModelContext(), getEditingDomain()));
		}
		return super.getAdapter(adapter);
	}

	/**
	 * Checks whether the loaded VView is valid:
	 * <ul>
	 * <li>not null</li>
	 * <li>the root EClass is set</li>
	 * <li>the root EClass is resolved (no proxy)</li>
	 * </ul>
	 * If the VView is invalid, an Exception with a proper error description is thrown.
	 *
	 * @throws IllegalArgumentException If the VView is null or no root EClass was set.
	 * @throws IllegalStateException If the VView's root EClass cannot be resolved.
	 */
	private void checkLoadedView() throws IllegalArgumentException, IllegalStateException {
		if (getView() == null) {
			throw new IllegalArgumentException(Messages.ViewEditorPart_InvalidVView);
		}
		final EClass rootEClass = getView().getRootEClass();
		if (rootEClass == null) {
			throw new IllegalArgumentException(
				Messages.ViewEditorPart_invalidVView_noRootEClass);
		}
		if (rootEClass.eIsProxy()) {
			final String proxyUri = EcoreUtil.getURI(rootEClass).toString();
			final String packageNsUri = proxyUri.split("#")[0]; //$NON-NLS-1$
			final String rootEClassName = proxyUri.split("#")[1].substring(2); //$NON-NLS-1$
			final EPackage ePackage = EPackage.Registry.INSTANCE.getEPackage(packageNsUri);
			if (ePackage == null || ePackage.eIsProxy()) {
				// the whole ecore is not present in the registry
				throw new IllegalStateException(MessageFormat.format(
					Messages.ViewEditorPart_invalidVView_rootEClassPackageNotResolved,
					rootEClassName, packageNsUri));
			}
			// The package is resolved but the Root EClass is not => Ecore was registered but misses the needed
			// class.
			throw new IllegalStateException(MessageFormat.format(
				Messages.ViewEditorPart_invalidVView_rootEClassNotInPackage,
				rootEClassName, ePackage.getName(), ePackage.getNsURI()));
		}
	}

	@Override
	public boolean isDirty() {
		return basicCommandStack.isSaveNeeded();
	}

	@Override
	public boolean isSaveAsAllowed() {
		return false;
	}

	/**
	 * Loads the view model.
	 *
	 * @param migrate whether the view model should be migrated (if actually needed) <b>before</b> attempting to load it
	 * @throws IOException if the view model resource failed to load
	 * @throws PartInitException
	 */
	private void loadView(boolean migrate, boolean resolve) throws IOException, PartInitException {

		if (inputUri == null) {
			inputUri = getInputUri(getEditorInput())
				.orElseThrow(() -> new PartInitException("Invalid editor input.")); //$NON-NLS-1$
		}

		final URI resourceURI = inputUri;
		if (migrate) {
			checkMigration(resourceURI);
		}
		editingDomain.getResourceSet().getResources().clear();
		resource = editingDomain.getResourceSet().getResource(resourceURI, true);
		if (resource.getContents().size() == 0 || !VView.class.isInstance(resource.getContents().get(0))) {
			throw new PartInitException(Messages.ViewEditorPart_InvalidVView);
		}
		if (resolve) {
			// resolve all proxies
			final ResourceSet resourceSet = editingDomain.getResourceSet();
			ResourceSetHelpers.resolveAllProxies(resourceSet);
		}
	}

	/**
	 * Gets a uri from the given {@link IEditorInput}. If the editor input is a {@link IPathEditorInput} or a
	 * {@link IStorageEditorInput} whose {@link IStorage} has a path, the uri is directly derived from the
	 * input. In case of a {@link IStorageEditorInput} without a path, a temporary file is created which contains the
	 * storage's contents.
	 * In any other case, an empty Optional is returned.
	 *
	 * @param editorInput The editor's input
	 * @return The File containing the editor inputs contents if possible, nothing otherwise
	 */
	private Optional<URI> getInputUri(IEditorInput editorInput) {
		if (isEditable(editorInput)) {
			// Normal file that can be edited on the hard drive
			return Optional.of(EditUIUtil.getURI(getEditorInput()));
		} else if (editorInput instanceof IStorageEditorInput) {
			try {
				final IStorage storage = IStorageEditorInput.class.cast(editorInput).getStorage();
				// Create a temporary file and copy the storage's content to it.
				final File tempFile = File.createTempFile("view-", ".tmp.view"); //$NON-NLS-1$ //$NON-NLS-2$
				tempFile.delete();
				tempFile.deleteOnExit();
				try (InputStream contents = storage.getContents()) {
					Files.copy(contents, tempFile.toPath());
					return Optional.of(URI.createFileURI(tempFile.getAbsolutePath()));
				}
			} catch (final CoreException | IOException ex) {
				Activator.getDefault().getReportService().report(new AbstractReport(ex));
				return Optional.empty();
			}

		}
		return Optional.empty();
	}

	/**
	 * Returns whether the editor input allows editing of its contents.
	 *
	 * @param editorInput the editor's {@link IEditorInput}
	 * @return <code>true</code> if the input source allows editing, <code>false</code> otherwise
	 */
	private boolean isEditable(IEditorInput editorInput) {
		// Only allow editing data if it can be persisted
		return editorInput.getPersistable() != null;
	}

	private void checkMigration(final URI resourceURI) {
		final ViewModelMigrator migrator = ViewModelMigratorUtil.getViewModelMigrator();
		if (migrator == null) {
			return;
		}
		final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		final boolean needsMigration = checkIfMigrationIsNeeded(shell, resourceURI, migrator);
		if (needsMigration) {
			final boolean migrate = MessageDialog.openQuestion(shell, Messages.ViewEditorPart_MigrationTitle,
				Messages.ViewEditorPart_MigrationQuestion);
			if (migrate) {
				final boolean migrateWorkspace = MessageDialog.openQuestion(shell,
					Messages.WorkspaceMigrationDialog_Title,
					Messages.WorkspaceMigrationDialog_Description);
				final List<URI> toMigrate = new ArrayList<URI>();
				final Set<URI> successfullyMigrated = new HashSet<>();
				if (migrateWorkspace) {
					for (final URI uri : getWorkspaceURIsToMigrate(resourceURI)) {
						try {
							final Resource workspaceResource = editingDomain.getResourceSet().getResource(uri, true);
							registerEcore(workspaceResource);
							toMigrate.add(uri);
						}
						// BEGIN SUPRESS CATCH EXCEPTION
						catch (final Exception ex) {// END SUPRESS CATCH EXCEPTION
							/*
							 * catch any exception because loading the workspace resource may also lead to exception
							 * like NoClassDefFound, IAE, etc. We want to continue in any case, in order to migrate as
							 * much as possible
							 */
							Activator.getDefault().getLog()
								.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, MessageFormat.format(
									Messages.ViewEditorPart_WorkspaceMigrationError,
									uri.toString()), ex));
						}
					}
				}
				toMigrate.add(resourceURI);
				final IRunnableWithProgress runnable = new IRunnableWithProgress() {
					@Override
					public void run(IProgressMonitor monitor)
						throws InvocationTargetException {
						try {
							for (final URI uri : toMigrate) {
								migrator.performMigration(uri);
								successfullyMigrated.add(uri);
							}
						} catch (final ViewModelMigrationException ex) {
							throw new InvocationTargetException(ex);
						}
					}
				};
				try {
					new ProgressMonitorDialog(shell).run(true, false, runnable);
				} catch (final InvocationTargetException e) {
					MessageDialog.openError(
						Display.getDefault().getActiveShell(), Messages.ViewEditorPart_MigrationErrorTitle,
						Messages.ViewEditorPart_MigrationErrorText1 +
							Messages.ViewEditorPart_MigrationErrorText2);
					Activator
						.getDefault()
						.getLog()
						.log(
							new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ViewEditorPart_MigrationErrorTitle,
								e));
				} catch (final InterruptedException e) {
					MessageDialog.openError(
						Display.getDefault().getActiveShell(), Messages.ViewEditorPart_MigrationErrorTitle,
						Messages.ViewEditorPart_MigrationErrorText1 +
							Messages.ViewEditorPart_MigrationErrorText2);
					Activator
						.getDefault()
						.getLog()
						.log(
							new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ViewEditorPart_MigrationErrorTitle,
								e));
				}

				// If a migration is necessary, only allow legacy dmr migration if the view model was migrated
				// successfully
				if (ToolingModeUtil.isSegmentToolingEnabled() && successfullyMigrated.contains(resourceURI)) {
					migrateLegacyDmrs(shell, resourceURI);
				}
			}

			migrateTemplateModels(shell);

		} else if (ToolingModeUtil.isSegmentToolingEnabled()) {
			migrateLegacyDmrs(shell, resourceURI);
		}
	}

	/**
	 * Checks whether the current view model contains any legacy DMRs. If yes, ask the user whether (s)he wants to
	 * migrate them to segment based DMRs and execute the migration if the user accepts.
	 *
	 * @param shell The shell to open UI dialogs on
	 * @param resourceURI the resource URI of the view model to migrate
	 */
	private void migrateLegacyDmrs(Shell shell, final URI resourceURI) {
		final DmrToSegmentsMigrator migrator = getEditorSite().getService(DmrToSegmentsMigrator.class);
		if (migrator.needsMigration(resourceURI)) {
			final boolean migrate = MessageDialog.openQuestion(shell, Messages.ViewEditorPart_LegacyMigrationTitle,
				Messages.ViewEditorPart_LegacyMigrationQuestion);
			if (migrate) {
				try {
					new ProgressMonitorDialog(shell).run(true, false, monitor -> {
						try {
							migrator.performMigration(resourceURI);
						} catch (final DmrToSegmentsMigrationException ex) {
							throw new InvocationTargetException(ex);
						}
					});
				} catch (InvocationTargetException | InterruptedException ex) {
					MessageDialog.openError(
						Display.getDefault().getActiveShell(), Messages.ViewEditorPart_LegacyMigrationErrorTitle,
						Messages.ViewEditorPart_LegacyMigrationErrorText +
							Messages.ViewEditorPart_MigrationErrorText2);
					Activator.getDefault().getLog().log(
						new Status(IStatus.ERROR, Activator.PLUGIN_ID,
							Messages.ViewEditorPart_LegacyMigrationErrorTitle, ex));
				}
			}
		}
	}

	/**
	 * If there is a template migrator, prompt the user if (s)he wants to search the workspace for template models that
	 * need migration. Afterwards, let the user chose which models to migrate and execute the migration.
	 *
	 * @param shell The {@link Shell} to create the dialogs for prompting the user on.
	 */
	private void migrateTemplateModels(final Shell shell) {
		final TemplateModelWorkspaceMigrator templateMigrator = TemplateModelMigratorUtil
			.getTemplateModelWorkspaceMigrator();
		if (templateMigrator == null) {
			return;
		}
		// Prompt user to migrate template models in the workspace
		final boolean migrateTemplates = MessageDialog.openQuestion(shell,
			Messages.ViewEditorPart_TemplateMigrationTitle,
			Messages.ViewEditorPart_TemplateMigrationDescription);
		if (migrateTemplates) {
			final List<URI> templateModelsToMigrate = getTemplateModelWorkspaceURIsToMigrate();

			final IRunnableWithProgress runnable = new IRunnableWithProgress() {
				@Override
				public void run(IProgressMonitor monitor)
					throws InvocationTargetException {
					try {
						for (final URI uri : templateModelsToMigrate) {
							templateMigrator.performMigration(uri);
						}
					} catch (final TemplateModelMigrationException ex) {
						throw new InvocationTargetException(ex);
					}
				}
			};

			try {
				new ProgressMonitorDialog(shell).run(true, false, runnable);
			} catch (final InvocationTargetException e) {
				MessageDialog.openError(
					Display.getDefault().getActiveShell(), Messages.ViewEditorPart_TemplateMigrationErrorTitle,
					Messages.ViewEditorPart_TemplateMigrationErrorMessage);
				Activator
					.getDefault().getLog().log(
						new Status(IStatus.ERROR, Activator.PLUGIN_ID,
							Messages.ViewEditorPart_TemplateMigrationErrorTitle, e));
			} catch (final InterruptedException e) {
				MessageDialog.openError(
					Display.getDefault().getActiveShell(), Messages.ViewEditorPart_TemplateMigrationErrorTitle,
					Messages.ViewEditorPart_TemplateMigrationErrorMessage);
				Activator.getDefault().getLog().log(
					new Status(IStatus.ERROR, Activator.PLUGIN_ID,
						Messages.ViewEditorPart_TemplateMigrationErrorTitle, e));
			}

		}
	}

	/**
	 * @param resourceURI the resource URI for which the migration dialog was opened. This URI will be removed from the
	 *            list of workspace URI in need of migration, which will be presented to the user.
	 */
	private List<URI> getWorkspaceURIsToMigrate(URI resourceURI) {
		final List<URI> uris = new ArrayList<URI>();

		final ViewModelWorkspaceMigrator workspaceMigrator = ViewModelMigratorUtil
			.getViewModelWorkspaceMigrator();
		if (workspaceMigrator == null) {
			return uris;
		}
		try {
			final ArrayList<URI> urIsToMigrate = workspaceMigrator.getURIsToMigrate();

			// Get the editors's resource uri as a uri with an absolute file path and remove it from the workspace URIs
			// to migrate in order to avoid migrating it two times (this would throw an exception).
			final IResource findMember = ResourcesPlugin.getWorkspace().getRoot()
				.findMember(resourceURI.toPlatformString(true));
			final String osString = findMember.getLocation().toOSString();
			urIsToMigrate.remove(URI.createFileURI(osString));

			if (urIsToMigrate.size() > 0) {
				final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
				final ListSelectionDialog migrationDialog = MigrationDialogHelper
					.getViewModelListMigrationDialog(shell,
						urIsToMigrate);

				if (migrationDialog.open() == Window.OK) {
					final Object[] selectedURIs = migrationDialog.getResult();
					if (selectedURIs != null) {
						for (final Object selectedUri : selectedURIs) {
							uris.add((URI) selectedUri);
						}
					}
				}
			}
		} catch (final CoreException ex) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex));
		}
		return uris;
	}

	private List<URI> getTemplateModelWorkspaceURIsToMigrate() {
		final List<URI> uris = new LinkedList<URI>();

		final TemplateModelWorkspaceMigrator workspaceMigrator = TemplateModelMigratorUtil
			.getTemplateModelWorkspaceMigrator();
		if (workspaceMigrator == null) {
			return uris;
		}
		try {
			final List<URI> urIsToMigrate = workspaceMigrator.getURIsToMigrate();

			if (urIsToMigrate.size() > 0) {
				final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
				final ListSelectionDialog migrationDialog = MigrationDialogHelper
					.getTemplateModelListMigrationDialog(shell, urIsToMigrate);

				if (migrationDialog.open() == Window.OK) {
					final Object[] selectedURIs = migrationDialog.getResult();
					if (selectedURIs != null) {
						for (final Object selectedUri : selectedURIs) {
							uris.add((URI) selectedUri);
						}
					}
				}
			}
		} catch (final CoreException ex) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex));
		}
		return uris;
	}

	private boolean checkIfMigrationIsNeeded(Shell shell, final URI resourceURI, final ViewModelMigrator migrator) {
		final CheckMigrationRunnable runnable = new CheckMigrationRunnable(migrator, resourceURI);
		try {
			new ProgressMonitorDialog(shell).run(true, false, runnable);
		} catch (final InvocationTargetException ex) {
			Activator.getDefault().getLog()
				.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ViewEditorPart_MigrationErrorTitle, ex));
		} catch (final InterruptedException ex) {
			Activator.getDefault().getLog()
				.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ViewEditorPart_MigrationErrorTitle, ex));
		}
		return runnable.getResult();
	}

	@Override
	public void createPartControl(Composite parent) {
		this.parent = parent;
		parent.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));

		final VView view = getView();

		Activator.getViewModelRegistry().registerViewModel(view, resource.getURI().toString());
		try {
			Activator.getViewModelRegistry().registerViewModelEditor(view, this);
		} catch (final IOException e) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
		}
		if (view.getRootEClass() != null) {
			if (view.getRootEClass().eResource() != null) {
				Activator.getViewModelRegistry().register(view.getRootEClass().eResource().getURI().toString(),
					view);
			} else {
				Activator
					.getDefault()
					.getLog()
					.log(
						new Status(IStatus.WARNING, Activator.PLUGIN_ID,
							"The Root EClass of the view cannot be resolved." + view.getRootEClass())); //$NON-NLS-1$
			}
		}
		showView();
	}

	private void registerEcore(Resource viewResource) throws IOException {
		for (final String ecorePath : ViewModelHelper.getEcorePaths(viewResource)) {
			if (ecorePath == null) {
				return;
			}
			EcoreHelper.registerEcore(ecorePath);
		}
	}

	private void saveChangedView(VView view) {
		try {
			view.eResource().save(getSaveOptions());
		} catch (final IOException e) {
			Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
		}
	}

	private String selectEcoreFromWorkspace() {
		final ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(Display.getDefault()
			.getActiveShell(), new WorkbenchLabelProvider(), new BaseWorkbenchContentProvider());
		dialog.setInput(ResourcesPlugin.getWorkspace().getRoot());
		dialog.setAllowMultiple(false);
		dialog.setValidator(new ISelectionStatusValidator() {

			@Override
			public IStatus validate(Object[] selection) {
				if (selection.length == 1) {
					if (selection[0] instanceof IFile) {
						final IFile file = (IFile) selection[0];
						if (file.getType() == IResource.FILE) {
							return new Status(IStatus.OK, Activator.PLUGIN_ID, IStatus.OK, null, null);
						}
					}
				}
				return new Status(IStatus.ERROR, Activator.PLUGIN_ID, IStatus.ERROR,
					Messages.ViewEditorPart_EcoreSelectionValidation,
					null);
			}
		});
		dialog.setTitle(Messages.ViewEditorPart_EcoreSelectionTitle);

		if (dialog.open() == Window.OK) {

			final IFile file = (IFile) dialog.getFirstResult();
			return file.getFullPath()
				.toString();
		}
		return null;
	}

	private void showView() {
		final VView view = getView();

		if (XMLResource.class.isInstance(view.eResource())
			&& !XMLResource.class.cast(view.eResource()).getEObjectToExtensionMap().isEmpty()) {
			// we are showing a view which wasn't fully loaded
			MessageDialog
				.openWarning(
					parent.getShell(),
					Messages.ViewEditorPart_LoadedPartlyTitle,
					Messages.ViewEditorPart_LoadedPartlyDescription);
		}

		try {
			final Map<String, Object> contextValues = Collections.singletonMap(
				IEclipseContext.class.getName(),
				getSite().getService(IEclipseContext.class));
			final ViewModelContext viewModelContext = ViewModelContextFactory.INSTANCE
				.createViewModelContext(ViewProviderHelper.getView(view, null), view,
					provide(new DefaultReferenceService(), new EMFDeleteServiceImpl()),
					contextValues);

			if (!isEditable(getEditorInput())) {
				viewModelContext.getViewModel().setReadonly(true);
			}

			viewModelContext.putContextValue("enableMultiEdit", Boolean.TRUE); //$NON-NLS-1$
			render = ECPSWTViewRenderer.INSTANCE.render(parent, viewModelContext);
			getSite().setSelectionProvider(
				viewModelContext.getService(ECPSelectionProviderService.class).getSelectionProvider());
		} catch (final ECPRendererException ex) {
			Activator.getDefault().getReportService().report(
				new StatusReport(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex)));
		}
	}

	@Override
	public void setFocus() {
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.ide.view.service.ViewModelEditorCallback#reloadViewModel()
	 */
	@Override
	public void reloadViewModel() {
		Display.getDefault().asyncExec(new ReloadViewModelRunnable());
	}

	@Override
	public void dispose() {
		final VView view = getView();
		if (view != null) {
			Activator.getViewModelRegistry().unregisterViewModelEditor(view, this);
		}
		if (partListener != null) {
			getSite().getPage().removePartListener(partListener);
		}
		super.dispose();
	}

	/**
	 * @return the VView object
	 */
	public VView getView() {
		if (resource == null || resource.getContents().isEmpty()) {
			return null;
		}
		final EObject eObject = resource.getContents().get(0);
		if (!VView.class.isInstance(eObject)) {
			return null;
		}
		return (VView) eObject;
	}

	/**
	 * Runnable to check if a migration is needed.
	 *
	 * @author Johannes Faltermeier
	 *
	 */
	private static final class CheckMigrationRunnable implements IRunnableWithProgress {
		private final ViewModelMigrator migrator;
		private final URI resourceURI;
		private boolean needsMigration;

		/**
		 * Default constructor.
		 *
		 * @param migrator the migrator
		 * @param resourceURI the resource uri to check
		 */
		CheckMigrationRunnable(ViewModelMigrator migrator, URI resourceURI) {
			this.migrator = migrator;
			this.resourceURI = resourceURI;
		}

		@Override
		public void run(IProgressMonitor monitor)
			throws InvocationTargetException {
			needsMigration = !migrator.checkMigration(resourceURI);
		}

		/**
		 * Returns the result of the migration check.
		 *
		 * @return <code>true</code> if migration is needed, <code>false</code> otherwise
		 */
		public boolean getResult() {
			return needsMigration;
		}
	}

	/**
	 * @author Jonas
	 *
	 */
	private final class ReloadViewModelRunnable implements Runnable {
		@Override
		public void run() {
			if (parent == null || parent.isDisposed()) {
				final IWorkbenchPage page = instance.getSite().getPage();
				page.closeEditor(instance, true);
				return;
			}
			if (render != null) {
				render.dispose();
				render.getSWTControl().dispose();
			}

			for (final String ecorePath : getView().getEcorePaths()) {
				if (ecorePath != null) {
					try {
						EcoreHelper.registerEcore(ecorePath);
					} catch (final IOException e) {
						Activator.getDefault().getLog()
							.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
					}
				}
			}

			// reload view resource after EClass' package resource was loaded into the package registry
			try {
				loadView(true, true);
			} catch (final IOException e) {
				Activator.getDefault().getLog()
					.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
			} catch (final PartInitException e) {
				Activator.getDefault().getLog()
					.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
				return;
			}
			final VView view = getView();

			try {
				Activator.getViewModelRegistry().registerViewModelEditor(view, instance);
			} catch (final IOException e) {
				Activator.getDefault().getLog()
					.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e));
			}

			if (view.getRootEClass() != null) {
				if (view.getRootEClass().eResource() != null) {
					Activator.getViewModelRegistry().register(
						view.getRootEClass().eResource().getURI().toString(),
						view);
				} else {
					Activator
						.getDefault()
						.getLog()
						.log(
							new Status(IStatus.WARNING, Activator.PLUGIN_ID,
								"The Root EClass of the view cannot be resolved." + view.getRootEClass())); //$NON-NLS-1$
				}
			}
			showView();
			parent.layout(true);
		}
	}

	/**
	 *
	 * */
	private class ViewPartListener implements IPartListener2 {
		@Override
		public void partActivated(IWorkbenchPartReference partRef) {
			if (instance.equals(partRef.getPart(true))) {

				final VView view = getView();

				// TODO: remove? Should probably handled manually by the user instead.
				if ((view.getEcorePaths().isEmpty()
					|| ResourcesPlugin.getWorkspace().getRoot().findMember(view.getEcorePaths().get(0)) == null)
					&& view.getRootEClass() != null && view.getRootEClass().eIsProxy()) {

					final String selectedECorePath = selectEcoreFromWorkspace();
					if (selectedECorePath != null) {
						view.getEcorePaths().add(selectedECorePath);
						saveChangedView(view);
						reloadViewModel();
					}
				}
				if (ecoreOutOfSync) {
					PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
						@Override
						public void run() {
							final Shell activeShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
								.getShell();
							final MessageDialog dialog = new MessageDialog(
								activeShell,
								Messages.ViewEditorPart_Warning,
								null,
								Messages.ViewEditorPart_EditorViewChanged,
								MessageDialog.WARNING,
								new String[] { Messages.ViewEditorPart_Yes, Messages.ViewEditorPart_No },
								0);
							final int result = dialog.open();
							if (result == 0) {
								Activator.getViewModelRegistry().unregisterViewModelEditor(getView(), instance);
								Activator.getViewModelRegistry().unregister(
									getView().getRootEClass().eResource().getURI().toString(),
									getView());
								reloadViewModel();
							}
							ecoreOutOfSync = false;
						}
					});
				}
			}
		}

		@Override
		public void partBroughtToTop(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partClosed(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partDeactivated(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partOpened(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partHidden(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partVisible(IWorkbenchPartReference partRef) {
		}

		@Override
		public void partInputChanged(IWorkbenchPartReference partRef) {
		}
	}

	/**
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.ide.view.service.ViewModelEditorCallback#signalEcoreOutOfSync()
	 */
	@Override
	public void signalEcoreOutOfSync() {
		ecoreOutOfSync = true;

	}

	/** Listens for changes in the editor's resource. */
	private class EditorResourceChangedListener implements IResourceChangeListener {

		/**
		 * {@inheritDoc}
		 *
		 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
		 */
		@Override
		public void resourceChanged(IResourceChangeEvent event) {
			final IResourceDelta delta = event.getDelta();
			final IResourceDeltaVisitor visitor = new IResourceDeltaVisitor() {
				@Override
				public boolean visit(IResourceDelta delta) {
					if (delta.getKind() == IResourceDelta.REMOVED) {
						final FileEditorInput fei = (FileEditorInput) instance.getEditorInput();
						if (delta.getFullPath().equals(fei.getFile().getFullPath())) {
							final IWorkbenchPage page = instance.getSite().getPage();
							Display.getDefault().asyncExec(new Runnable() {
								@Override
								public void run() {
									if (page != null) {
										page.closeEditor(instance, false);
									}
								}
							});
							return false;
						}
					}
					return true;
				}
			};
			try {
				if (delta == null) {
					return;
				}
				delta.accept(visitor);
			} catch (final CoreException ex) {
			}
		}
	}
}