/**
 * <copyright>
 *
 * Copyright (c) 2015 itemis 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
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *     itemis - Initial API and implementation
 *
 * </copyright>
 */
package org.eclipse.sphinx.emf.workspace.ui.viewers.state.providers;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.Assert;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.provider.IWrapperItemProvider;
import org.eclipse.emf.transaction.RunnableWithResult;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ITreePathContentProvider;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.sphinx.emf.edit.TransientItemProvider;
import org.eclipse.sphinx.emf.util.EcoreResourceUtil;
import org.eclipse.sphinx.emf.workspace.ui.internal.Activator;
import org.eclipse.sphinx.platform.util.PlatformLogUtil;
import org.eclipse.ui.IMemento;

public class TreeElementStateProviderFactory {

	public static final String MEMENTO_TYPE_GROUP_SELECTED = Activator.getPlugin().getSymbolicName() + ".selected"; //$NON-NLS-1$
	public static final String MEMENTO_TYPE_GROUP_EXPANDED = Activator.getPlugin().getSymbolicName() + ".expanded"; //$NON-NLS-1$

	public static final String MEMENTO_TYPE_ELEMENT_PROJECT = Activator.getPlugin().getSymbolicName() + ".project"; //$NON-NLS-1$
	public static final String MEMENTO_TYPE_ELEMENT_FOLDER = Activator.getPlugin().getSymbolicName() + ".folder"; //$NON-NLS-1$
	public static final String MEMENTO_TYPE_ELEMENT_FILE = Activator.getPlugin().getSymbolicName() + ".file"; //$NON-NLS-1$
	public static final String MEMENTO_TYPE_ELEMENT_EOBJECT = Activator.getPlugin().getSymbolicName() + ".eObject"; //$NON-NLS-1$
	public static final String MEMENTO_TYPE_ELEMENT_TRANSIENT = Activator.getPlugin().getSymbolicName() + ".transient"; //$NON-NLS-1$

	public static final String MEMENTO_KEY_NAME = "name"; //$NON-NLS-1$
	public static final String MEMENTO_KEY_PATH = "path"; //$NON-NLS-1$
	public static final String MEMENTO_KEY_URI = "uri"; //$NON-NLS-1$
	public static final String MEMENTO_KEY_PARENT_URI = "parentURI"; //$NON-NLS-1$
	public static final String MEMENTO_KEY_TRANSIENT_CHILDREN = "transientChildren"; //$NON-NLS-1$

	private TreeViewer viewer;

	public TreeElementStateProviderFactory(TreeViewer viewer) {
		Assert.isNotNull(viewer);
		this.viewer = viewer;
	}

	public ITreeElementStateProvider create(Object element) {
		return create(getParentPath(element), element);
	}

	public ITreeElementStateProvider create(TreePath treePath) {
		Assert.isNotNull(treePath);
		return create(treePath.getParentPath(), treePath.getLastSegment());
	}

	protected ITreeElementStateProvider create(TreePath parentPath, Object element) {
		Assert.isNotNull(parentPath != null);

		if (element instanceof IProject) {
			return new ProjectElementStateProvider(viewer, (IProject) element);
		} else if (element instanceof IFolder) {
			return new FolderElementStateProvider(viewer, (IFolder) element);
		} else if (element instanceof IFile) {
			return new FileElementStateProvider(viewer, (IFile) element);
		} else if (element instanceof EObject) {
			URI uri = getURI((EObject) element);
			return new EObjectElementStateProvider(viewer, uri);
		} else if (isTransientElement(element)) {
			Object eObjectParent = null;
			List<Object> transientChildren = new ArrayList<Object>();
			transientChildren.add(element);
			for (int i = parentPath.getSegmentCount() - 1; i >= 0; i--) {
				Object parent = parentPath.getSegment(i);
				if (!isTransientElement(parent)) {
					eObjectParent = parent;
					break;
				}
				transientChildren.add(parent);
			}
			Collections.reverse(transientChildren);

			if (eObjectParent instanceof EObject) {
				URI eObjectParentURI = getURI((EObject) eObjectParent);
				return createTransientElementProvider(eObjectParentURI, transientChildren);
			}
		}
		return null;
	}

	public ITreeElementStateProvider createFromMemento(IMemento elementMemento) {
		if (MEMENTO_TYPE_ELEMENT_PROJECT.equals(elementMemento.getType())) {
			return new ProjectElementStateProvider(viewer, elementMemento);
		} else if (MEMENTO_TYPE_ELEMENT_FOLDER.equals(elementMemento.getType())) {
			return new FolderElementStateProvider(viewer, elementMemento);
		} else if (MEMENTO_TYPE_ELEMENT_FILE.equals(elementMemento.getType())) {
			return new FileElementStateProvider(viewer, elementMemento);
		} else if (MEMENTO_TYPE_ELEMENT_EOBJECT.equals(elementMemento.getType())) {
			return new EObjectElementStateProvider(viewer, elementMemento);
		} else if (MEMENTO_TYPE_ELEMENT_TRANSIENT.equals(elementMemento.getType())) {
			return createTransientElementStateProvider(elementMemento);
		}
		return null;
	}

	protected boolean isTransientElement(Object element) {
		return element instanceof TransientItemProvider || element instanceof IWrapperItemProvider;
	}

	protected TransientElementStateProvider createTransientElementProvider(URI eObjectParentURI, List<Object> transientChildren) {
		return new TransientElementStateProvider(viewer, eObjectParentURI, transientChildren);
	}

	protected TransientElementStateProvider createTransientElementStateProvider(IMemento elementMemento) {
		return new TransientElementStateProvider(viewer, elementMemento);
	}

	protected TreePath getParentPath(Object element) {
		IContentProvider contentProvider = viewer.getContentProvider();
		if (contentProvider instanceof ITreePathContentProvider) {
			TreePath[] parents = ((ITreePathContentProvider) contentProvider).getParents(element);
			if (parents.length > 0) {
				return parents[0];
			}
		}
		return TreePath.EMPTY;
	}

	protected URI getURI(final EObject eObject) {
		if (eObject != null) {
			final TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(eObject);
			if (editingDomain != null) {
				try {
					return TransactionUtil.runExclusive(editingDomain, new RunnableWithResult.Impl<URI>() {
						@Override
						public void run() {
							setResult(EcoreResourceUtil.getURI(eObject, true));
						}
					});
				} catch (InterruptedException ex) {
					PlatformLogUtil.logAsWarning(Activator.getPlugin(), ex);
				}
			} else {
				return EcoreResourceUtil.getURI(eObject, true);
			}
		}
		return null;
	}
}