/*******************************************************************************
 * Copyright (c) 2011-2014 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:
 * Lucas - initial API and implementation
 * Johannes Faltermeier - initial API and implementation
 ******************************************************************************/
package org.eclipse.emf.ecp.view.edapt;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IContributor;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EPackage.Registry;
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.ecore.xmi.XMLResource;
import org.eclipse.emf.ecp.spi.view.migrator.NameSpaceHandler;
import org.eclipse.emf.ecp.spi.view.migrator.SAXUtil;
import org.eclipse.emf.ecp.spi.view.migrator.string.StringViewModelMigrator;
import org.eclipse.emf.ecp.spi.view.migrator.string.StringViewModelMigratorUtil;
import org.eclipse.emf.ecp.view.migrator.ViewModelMigrationException;
import org.eclipse.emf.ecp.view.migrator.ViewModelMigrator;
import org.eclipse.emf.ecp.view.spi.model.util.VViewResourceFactoryImpl;
import org.eclipse.emf.edapt.common.IResourceSetFactory;
import org.eclipse.emf.edapt.migration.MigrationException;
import org.eclipse.emf.edapt.migration.execution.Migrator;
import org.eclipse.emf.edapt.migration.execution.MigratorRegistry;
import org.eclipse.emf.edapt.spi.history.Change;
import org.eclipse.emf.edapt.spi.history.History;
import org.eclipse.emf.edapt.spi.history.HistoryFactory;
import org.eclipse.emf.edapt.spi.history.MigrationChange;
import org.eclipse.emf.edapt.spi.history.Release;
import org.eclipse.emf.edapt.spi.migration.MigrationPlugin;
import org.osgi.framework.Bundle;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
 * A {@link ViewModelMigrator} using edapt.
 *
 * @author Lucas
 * @author jfaltermeier
 *
 */
public class EdaptViewModelMigrator implements ViewModelMigrator, StringViewModelMigrator {

	private static final String ECORE_NS_URI = "http://www.eclipse.org/emf/2002/Ecore"; //$NON-NLS-1$

	private static final Comparator<String> RELEASE_COMPERATOR = new Comparator<String>() {
		@Override
		public int compare(String left, String right) {
			return Integer.valueOf(left).compareTo(Integer.valueOf(right));
		}
	};

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.spi.view.migrator.string.StringViewModelMigrator#checkMigration(java.lang.String)
	 * @since 1.8
	 */
	@Override
	public boolean checkMigration(String serializedViewModel) {
		return checkMigration(StringViewModelMigratorUtil.getNamespaceURIs(serializedViewModel));
	}

	@Override
	public boolean checkMigration(final URI resourceURI) {
		return checkMigration(getNamespaceURIs(resourceURI));
	}

	private boolean checkMigration(final List<String> nsUris) {
		boolean allReleasesAreLatest = true;
		final List<Release> releases = new ArrayList<Release>();
		for (final String nsUri : nsUris) {
			final Migrator migrator = MigratorRegistry.getInstance()
				.getMigrator(nsUri);
			if (migrator == null) {
				// no migrator registered. assume all is fine
				continue;
			}
			final Release nsRelease = getReleaseFromMigrator(nsUri, migrator);
			releases.add(nsRelease);
			if (!migrator.getLatestRelease().equals(nsRelease)) {
				allReleasesAreLatest = false;
				break;
			}
		}
		return allReleasesAreLatest;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see org.eclipse.emf.ecp.spi.view.migrator.string.StringViewModelMigrator#performMigration(java.lang.String)
	 * @since 1.8
	 */
	@Override
	public String performMigration(String serializedViewModel) throws ViewModelMigrationException {
		PrintWriter printWriter = null;
		File tempViewModelFile = null;
		Scanner scanner = null;
		try {
			tempViewModelFile = File.createTempFile("view", ".view"); //$NON-NLS-1$//$NON-NLS-2$
			tempViewModelFile.deleteOnExit();
			printWriter = new PrintWriter(tempViewModelFile);
			printWriter.print(serializedViewModel);
			printWriter.flush();
			printWriter.close();
			performMigration(URI.createFileURI(tempViewModelFile.getAbsolutePath()));
			scanner = new Scanner(tempViewModelFile, "UTF-8"); //$NON-NLS-1$
			return scanner.useDelimiter("\\A").next(); //$NON-NLS-1$
		} catch (final IOException ex) {
			throw new ViewModelMigrationException(ex);
		} finally {
			if (printWriter != null) {
				printWriter.close();
			}
			if (scanner != null) {
				scanner.close();
			}
			if (tempViewModelFile != null) {
				tempViewModelFile.delete();
			}
		}
	}

	@Override
	public void performMigration(final URI resourceURI) throws ViewModelMigrationException {
		final History history = HistoryFactory.eINSTANCE.createHistory();
		final Release sourceRelease = HistoryFactory.eINSTANCE.createRelease();
		final List<Release> targetReleases = new ArrayList<Release>();
		/*
		 * Analyse the domain model of the view. Generate a history for ecores which have no registered history and add
		 * them to source release. Mapping contains information about which uris from the domain have histories and
		 * which have no history.
		 */
		final NSURIMapping domainMapping = addChangesForDomainModel(resourceURI, sourceRelease);

		/* Get NS URIs with a registered history (domain and view model) */
		final List<String> nsUris = getNamespaceURIsWithHistory(resourceURI, domainMapping);

		/* Combine the changes from the histories in one big history */
		orderHistoriesAndCombineChanges(sourceRelease, targetReleases, nsUris);

		/* add releases to history */
		history.getReleases().add(sourceRelease);
		history.getReleases().addAll(targetReleases);
		history.getReleases().add(HistoryFactory.eINSTANCE.createRelease()); // expected by history editor

		try {
			/* Save history file */
			final URI uri = saveHistoryFile(history);

			/* Trigger the migration */
			final Migrator migrator = new Migrator(uri, new CustomMigrationClassLoader());
			migrator.setResourceSetFactory(new IResourceSetFactory() {
				@Override
				public ResourceSet createResourceSet() {
					final ResourceSetImpl resourceSet = new ResourceSetImpl();
					resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put(
						Resource.Factory.Registry.DEFAULT_EXTENSION, new VViewResourceFactoryImpl());
					return resourceSet;
				}
			});
			final Release release = migrator.getRelease(0);
			migrator.migrateAndSave(Collections.singletonList(resourceURI), release, null,
				new NullProgressMonitor());

		} catch (final IOException ex) {
			throw new ViewModelMigrationException(ex);
		} catch (final MigrationException ex) {
			throw new ViewModelMigrationException(ex);
		} finally {
			reregisterExtensionMigrators();
		}
	}

	/**
	 * @param history
	 * @return
	 * @throws IOException
	 */
	private URI saveHistoryFile(final History history) throws IOException {
		final File historyFile = File.createTempFile("EMFFormsMigration", ".history"); //$NON-NLS-1$//$NON-NLS-2$
		historyFile.deleteOnExit();
		final URI uri = URI.createFileURI(historyFile.getAbsolutePath());
		final Resource resource = new ResourceSetImpl().createResource(uri);
		resource.getContents().add(history);
		resource.save(Collections.singletonMap(XMLResource.OPTION_ENCODING, "UTF-8")); //$NON-NLS-1$
		return uri;
	}

	/**
	 * @param history
	 * @param sourceRelease
	 * @param targetReleases
	 * @param nsUris
	 */
	private void orderHistoriesAndCombineChanges(final Release sourceRelease,
		final List<Release> targetReleases, final List<String> nsUris) {
		/* build a dependency tree for all view models with a history */
		final PackageDependencyGraph viewModelPackageGraph = new PackageDependencyGraph();
		final Map<String, Migrator> nsURIToMigratorMap = new LinkedHashMap<String, Migrator>();
		final Map<String, String> latestToCurrentNSURIMap = new LinkedHashMap<String, String>();
		for (final String nsUri : nsUris) {
			final org.eclipse.emf.edapt.migration.execution.Migrator migrator = MigratorRegistry.getInstance()
				.getMigrator(nsUri);
			nsURIToMigratorMap.put(nsUri, migrator);
			/* get available uri from history */
			for (final String migratorNSURI : migrator.getNsURIs()) {
				if (Registry.INSTANCE.containsKey(migratorNSURI)) {
					viewModelPackageGraph.addPackage(migratorNSURI);
					if (latestToCurrentNSURIMap.containsKey(migratorNSURI)) {
						final String string = latestToCurrentNSURIMap.get(migratorNSURI);
						final String olderNSURI = string.compareTo(nsUri) < 0 ? string : nsUri;
						latestToCurrentNSURIMap.put(migratorNSURI, olderNSURI);
					} else {
						latestToCurrentNSURIMap.put(migratorNSURI, nsUri);
					}
					break;
				}
			}
		}

		/* using the dependency tree, combine changes from all registered histories based on the release label. */
		final Map<String, List<Change>> sourceReleaseNameToChangesMap = new LinkedHashMap<String, List<Change>>();
		final Map<String, List<Change>> targetReleaseNameToChangesMap = new LinkedHashMap<String, List<Change>>();
		final Iterator<Set<String>> viewModelPackageIterator = viewModelPackageGraph.getIerator();
		while (viewModelPackageIterator.hasNext()) {
			final Set<String> latestURIs = viewModelPackageIterator.next();
			for (final String latestURI : latestURIs) {
				if (!latestToCurrentNSURIMap.keySet().contains(latestURI)) {
					continue;
				}
				final String nsUri = latestToCurrentNSURIMap.get(latestURI);
				final org.eclipse.emf.edapt.migration.execution.Migrator migrator = nsURIToMigratorMap
					.get(nsUri);

				final Release nsRelease = getReleaseFromMigrator(nsUri, migrator);

				// add changes to source release
				final int sourceIndex = nsRelease.getNumber();
				for (int i = 0; i <= sourceIndex; i++) {
					final Release currentRelease = migrator.getRelease(i);
					if (!sourceReleaseNameToChangesMap.containsKey(currentRelease.getLabel())) {
						sourceReleaseNameToChangesMap.put(currentRelease.getLabel(), new ArrayList<Change>());
					}
					sourceReleaseNameToChangesMap.get(currentRelease.getLabel()).addAll(currentRelease.getChanges());

				}

				// add changes to target release
				final int targetIndex = migrator.getLatestRelease().getNumber();
				if (targetIndex > sourceIndex) {
					for (int i = sourceIndex + 1; i <= targetIndex; i++) {
						final Release currentRelease = migrator.getRelease(i);
						if (!targetReleaseNameToChangesMap.containsKey(currentRelease.getLabel())) {
							targetReleaseNameToChangesMap.put(currentRelease.getLabel(), new ArrayList<Change>());
						}
						targetReleaseNameToChangesMap.get(currentRelease.getLabel())
							.addAll(currentRelease.getChanges());
					}
				}
			}
		}

		/* Based on combined changes from all histories insert the changed to source release and target releases */
		fillReleases(sourceRelease, targetReleases, sourceReleaseNameToChangesMap, targetReleaseNameToChangesMap);
	}

	/**
	 * @param sourceRelease
	 * @param targetReleases
	 * @param sourceReleaseNameToChangesMap
	 * @param targetReleaseNameToChangesMap
	 */
	private void fillReleases(final Release sourceRelease, final List<Release> targetReleases,
		final Map<String, List<Change>> sourceReleaseNameToChangesMap,
		final Map<String, List<Change>> targetReleaseNameToChangesMap) {

		final Set<String> sourceReleaseNames = new TreeSet<String>(RELEASE_COMPERATOR);
		sourceReleaseNames.addAll(sourceReleaseNameToChangesMap.keySet());
		final Set<String> targetReleaseNames = new TreeSet<String>(RELEASE_COMPERATOR);
		targetReleaseNames.addAll(targetReleaseNameToChangesMap.keySet());

		for (final String release : sourceReleaseNames) {
			final List<Change> list = sourceReleaseNameToChangesMap.get(release);
			sourceRelease.getChanges().addAll(list);
			sourceRelease.setDate(new Date());
			sourceRelease.setLabel("source"); //$NON-NLS-1$
		}

		for (final String release : targetReleaseNames) {
			final Release targetRelease = HistoryFactory.eINSTANCE.createRelease();
			targetRelease.setDate(new Date());
			targetRelease.setLabel(release);
			targetReleases.add(targetRelease);
			final List<Change> list = targetReleaseNameToChangesMap.get(release);
			targetRelease.getChanges().addAll(list);

			// move custom migrations to end of target release, because every custom migration issues a validation.
			// TODO it would be great if we could config edapt to not validate after each custom migration.
			final List<Integer> indexes = new ArrayList<Integer>();
			for (int i = 0; i < targetRelease.getChanges().size(); i++) {
				final Change currentChange = targetRelease.getChanges().get(i);
				if (MigrationChange.class.isInstance(currentChange)) {
					indexes.add(i);
				}
			}
			final int lastIndex = targetRelease.getChanges().size() - 1;
			for (int i = indexes.size() - 1; i > -1; i--) {
				final Change changeToMove = targetRelease.getChanges().get(indexes.get(i));
				targetRelease.getChanges().move(lastIndex, changeToMove);
			}
		}
	}

	/**
	 * @param resourceURI
	 * @param domainMapping
	 * @return
	 */
	private List<String> getNamespaceURIsWithHistory(final URI resourceURI, final NSURIMapping domainMapping) {
		final List<String> nsUris = getNamespaceURIs(resourceURI);
		for (final String nsURI : domainMapping.getNsURIsWithGeneratedHistory()) {
			nsUris.remove(nsURI);
		}
		nsUris.addAll(domainMapping.getNsURIsWithHistory());
		return nsUris;
	}

	/**
	 * Returns the ns uris for which a history was created.
	 *
	 * @param resourceURI
	 * @return
	 */
	private NSURIMapping addChangesForDomainModel(URI resourceURI, Release release) {
		// get rootpackage nsuri from view
		// check if package is available in registry -> generate history
		final Set<String> nsURIsWithHistory = new LinkedHashSet<String>();
		final Set<String> nsURIsWithGeneratedHistory = new LinkedHashSet<String>();

		final PackageDependencyGraph domainModelPackageGraph = new PackageDependencyGraph();
		domainModelPackageGraph.addPackage(ECORE_NS_URI);
		final Set<String> rootPackageURIs = getRootPackageURI(resourceURI);
		for (String rootPackageNsUri : rootPackageURIs) {
			final Migrator rootMigrator = MigratorRegistry.getInstance().getMigrator(rootPackageNsUri);
			if (rootMigrator != null) {
				for (final String migratorNSURI : rootMigrator.getNsURIs()) {
					if (Registry.INSTANCE.containsKey(migratorNSURI)) {
						nsURIsWithHistory.add(rootPackageNsUri);
						rootPackageNsUri = migratorNSURI;
						break;
					}
				}
			}
			domainModelPackageGraph.addPackage(rootPackageNsUri);
		}

		final List<EPackage> rootPackages = new ArrayList<EPackage>();
		final Iterator<Set<String>> packageIterator = domainModelPackageGraph.getIerator();

		while (packageIterator.hasNext()) {
			final Set<String> nsURIs = packageIterator.next();
			for (final String nsURI : nsURIs) {
				/* there is no history available from the extensionpoint */
				if (MigratorRegistry.getInstance().getMigrator(nsURI) == null) {
					final EPackage ePackage = Registry.INSTANCE.getEPackage(nsURI);
					rootPackages.add(ePackage);
					nsURIsWithGeneratedHistory.add(nsURI);
				} else {
					nsURIsWithHistory.add(nsURI);
				}
			}
		}

		@SuppressWarnings("restriction")
		final org.eclipse.emf.edapt.history.recorder.HistoryGenerator rootGenerator = new org.eclipse.emf.edapt.history.recorder.HistoryGenerator(
			rootPackages);
		@SuppressWarnings("restriction")
		final List<Change> rootChanges = rootGenerator.generate().getFirstRelease().getChanges();
		release.getChanges().addAll(rootChanges);
		return new NSURIMapping(nsURIsWithHistory, nsURIsWithGeneratedHistory);
	}

	/**
	 * @param nsUri The name space URI of the package whose {@link Release} is wanted.
	 * @param migrator The {@link Migrator} which should provide the {@link Release}.
	 * @return
	 */
	private Release getReleaseFromMigrator(final String nsUri, final Migrator migrator) {
		final Map<String, Set<Release>> releaseMap = migrator.getReleaseMap();
		final Set<Release> nsReleases = releaseMap.get(nsUri);
		/* in case multiple are found pick the newest one */
		return nsReleases.stream()
			.sorted(this::compareReleases)
			.findFirst()
			.orElse(null);
	}

	private int compareReleases(Release r1, Release r2) {
		return r2.getNumber() - r1.getNumber();
	}

	/**
	 * @return the namespaces of all models used in the given resource.
	 */
	private List<String> getNamespaceURIs(URI resourceURI) {
		@SuppressWarnings("restriction")
		final File file = org.eclipse.emf.edapt.internal.common.URIUtils.getJavaFile(resourceURI);
		// read all namespaces from root element with SAX
		final NameSpaceHandler handler = new NameSpaceHandler();
		executeContentHandler(file, handler);

		return handler.getNsURIs();
	}

	/**
	 * @return the namespaces of all models used in the given resource.
	 */
	private Set<String> getRootPackageURI(URI resourceURI) {
		@SuppressWarnings("restriction")
		final File file = org.eclipse.emf.edapt.internal.common.URIUtils.getJavaFile(resourceURI);
		// read root package namespace uri with SAX
		final RootPackageHandler handler = new RootPackageHandler();
		executeContentHandler(file, handler);
		if (handler.foundRootEClass()) {
			return Collections.singleton(handler.getRootPackageURI());
		}
		final RootPackageCalculationHandler calcHandler = new RootPackageCalculationHandler();
		executeContentHandler(file, calcHandler);
		return calcHandler.getUsedPackages();
	}

	private static void executeContentHandler(File file, final DefaultHandler contentHandler) {
		try {
			SAXUtil.executeContentHandler(new FileReader(file), contentHandler);
		} catch (final FileNotFoundException ex) {
		}
	}

	/** Register all migrators from extensions. */
	private void reregisterExtensionMigrators() {
		final IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
		final IConfigurationElement[] configurationElements = extensionRegistry
			.getConfigurationElementsFor("org.eclipse.emf.edapt.migrators"); //$NON-NLS-1$

		for (final IConfigurationElement configurationElement : configurationElements) {
			registerExtensionMigrator(configurationElement);
		}
	}

	/** Register migrator for one extension. */
	@SuppressWarnings("restriction")
	private void registerExtensionMigrator(
		IConfigurationElement configurationElement) {

		final String migrationPath = configurationElement.getAttribute("path"); //$NON-NLS-1$

		final IContributor contributor = configurationElement.getContributor();
		final String bundleName = contributor.getName();
		final Bundle bundle = Platform.getBundle(bundleName);
		final URI migratorURI = URI.createPlatformPluginURI("/" + bundleName + "/" //$NON-NLS-1$ //$NON-NLS-2$
			+ migrationPath, true);
		try {
			MigratorRegistry.getInstance().registerMigrator(migratorURI,
				new org.eclipse.emf.edapt.internal.migration.execution.internal.BundleClassLoader(bundle));
		} catch (final MigrationException e) {
			org.eclipse.emf.edapt.internal.common.LoggingUtils.logError(MigrationPlugin.getPlugin(), e);
		}
	}

	/** Content handler for extraction of the root package namespace URI using SAX. */
	private static class RootPackageHandler extends DefaultHandler {

		/** The root package's namespace URI. */
		private String rootPackageURI = ""; //$NON-NLS-1$
		private boolean rootEClassFound;

		/**
		 * {@inheritDoc}
		 *
		 * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String,
		 *      org.xml.sax.Attributes)
		 */
		@Override
		public void startElement(String uri, String localName, String qName, Attributes attributes)
			throws SAXException {
			super.startElement(uri, localName, qName, attributes);
			if (localName.equals("rootEClass")) { //$NON-NLS-1$
				final String rawUri = attributes.getValue("href"); //$NON-NLS-1$
				rootPackageURI = rawUri.split("#")[0]; //$NON-NLS-1$
				rootEClassFound = true;
				throw new SAXException();
			}
		}

		/**
		 * Whether an element with the rootEClass attribute has been found.
		 *
		 * @return <code>true</code> if found, <code>false</code> otherwise
		 */
		public boolean foundRootEClass() {
			return rootEClassFound;
		}

		/** Returns the root package's namespace URI. */
		public String getRootPackageURI() {
			return rootPackageURI;
		}
	}

	/**
	 * Content handler for finding all used NS-URIs in a view model.
	 *
	 * @author jfaltermeier
	 *
	 */
	private static class RootPackageCalculationHandler extends DefaultHandler {

		/** The root package's namespace URI. */
		private final Set<String> packages = new LinkedHashSet<String>();

		@Override
		public void startElement(String uri, String localName, String qName, Attributes attributes)
			throws SAXException {
			super.startElement(uri, localName, qName, attributes);
			final String href = attributes.getValue("href"); //$NON-NLS-1$
			final String type = attributes.getValue("xsi:type"); //$NON-NLS-1$
			if (href == null || type == null) {
				return;
			}
			if (!type.endsWith("EAttribute") && !type.endsWith("EReference")) { //$NON-NLS-1$ //$NON-NLS-2$
				return;
			}
			packages.add(href.split("#")[0]); //$NON-NLS-1$
		}

		/** Returns the root package's namespace URI. */
		public Set<String> getUsedPackages() {
			return packages;
		}
	}

	/**
	 * Mapping for domain nsURIs.
	 *
	 * @author jfaltermeier
	 *
	 */
	private static class NSURIMapping {
		private final Set<String> nsURIsWithHistory;
		private final Set<String> nsURIsWithGeneratedHistory;

		/**
		 * Default constructor.
		 *
		 * @param nsURIsWithHistory ns uris of models with a history available at the extension point
		 * @param nsURIsWithGeneratedHistory ns uris of models for which we generated a history
		 */
		NSURIMapping(Set<String> nsURIsWithHistory, Set<String> nsURIsWithGeneratedHistory) {
			this.nsURIsWithHistory = nsURIsWithHistory;
			this.nsURIsWithGeneratedHistory = nsURIsWithGeneratedHistory;
		}

		public Set<String> getNsURIsWithHistory() {
			return nsURIsWithHistory;
		}

		public Set<String> getNsURIsWithGeneratedHistory() {
			return nsURIsWithGeneratedHistory;
		}
	}

}