/*******************************************************************************
 * Copyright (c) 2009 by SAP AG, Walldorf. 
 * 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:
 *     SAP AG - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.jaxws.dom.integration.navigator;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.jst.ws.jaxws.dom.integration.internal.util.ProjectExplorerUtil;
import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingCanceled;
import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingDummy;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IDOM;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IServiceEndpointInterface;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebMethod;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebParam;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebService;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebServiceProject;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDOMRuntimeExtension;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDomLoadListener;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMLoadCanceledException;
import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMRuntimeManager;
import org.eclipse.jst.ws.jaxws.dom.runtime.registry.IWsDOMRuntimeInfo;
import org.eclipse.jst.ws.jaxws.dom.runtime.registry.WsDOMRuntimeRegistry;
import org.eclipse.jst.ws.jaxws.utils.ContractChecker;
import org.eclipse.jst.ws.jaxws.utils.facets.FacetUtils;
import org.eclipse.jst.ws.jaxws.utils.logging.Logger;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.navigator.CommonNavigator;
import org.eclipse.ui.navigator.CommonViewer;

/** 
 * Content provider for DOM related objects
 * 
 * @author 
 */
public class DOMAdapterFactoryContentProvider extends AdapterFactoryContentProvider
{
	private Map<IWsDOMRuntimeExtension, IWsDomLoadListener> loadListeners = new HashMap<IWsDOMRuntimeExtension, IWsDomLoadListener>(); 
	
	/**
	 * Constructor
	 */
	public DOMAdapterFactoryContentProvider()
	{
		this(CustomDomItemProviderAdapterFactory.INSTANCE);
	}
	
	/**
	 * Constructor
	 * @param adapterFactory
	 */
	public DOMAdapterFactoryContentProvider(AdapterFactory adapterFactory)
	{
		super(adapterFactory);
	}
	
	@Override
	public Object[] getChildren(final Object context)
	{
		if (context instanceof IAdaptable)
		{
			return getWsProject((IProject)((IAdaptable) context).getAdapter(IProject.class));
		}
		else if(context instanceof ILoadingWsProject) 
		{
			return new Object[] { ((ILoadingWsProject)context).isLoadCanceled() ? new ILoadingCanceled(){} : new ILoadingDummy(){} };
		}
		else if(context instanceof IWebServiceProject)
		{
			return new Object[]{ adapterFactory.adapt(context, ISEIChildList.class),
					adapterFactory.adapt(context, IWebServiceChildList.class) };
		}
		else if(context instanceof IWebServiceChildList)
		{
			Object[] webServices = ((IWebServiceChildList)context).getWSChildList().toArray();
			
			for(int ii=0; ii<webServices.length; ii++)
			{
				adapterFactory.adapt(webServices[ii], ITreeItemContentProvider.class);
			}
			
			return webServices;
		}
		else if(context instanceof ISEIChildList)
		{
			Object[] sEIs = ((ISEIChildList)context).getSEIChildList().toArray();
			
			for(int ii=0; ii<sEIs.length; ii++)
			{
				adapterFactory.adapt(sEIs[ii], ITreeItemContentProvider.class);
			}
			
			return sEIs;
		}
		else if(context instanceof IWebService)
		{
			final IServiceEndpointInterface sei = ((IWebService)context).getServiceEndpoint();
			if (sei == null) {
				return new Object[0];
			}
			
			adapterFactory.adapt(sei, ITreeItemContentProvider.class);
			return new Object[]{ sei };
		}
		else if(context instanceof IServiceEndpointInterface) {
			return extractMethods((IServiceEndpointInterface) context);
		}
		else if (context instanceof IWebMethod) {
			return extractParams((IWebMethod)context);
		}
		
		return new Object[0];
	}
	
	protected Object[] getWsProject(final IProject project) 
	{
		try {
			final IWsDOMRuntimeExtension runtime = getSupportingRuntime(project);
			if (runtime == null) {
				return new Object[0];
			}
			
			// WS project is loaded already
			final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), project); 
			if (wsProject != null)
			{
				adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
				return new Object[] { wsProject };
			}
			
			addRuntimeLoadListener(runtime);
			return new Object[] { new LoadingWsProject(project, false) };
		} 
		catch (WsDOMLoadCanceledException e) { // $JL-EXC$
			return new Object[] { new LoadingWsProject(project, true) }; 
		}
	}
	
	protected IWsDomLoadListener addRuntimeLoadListener(final IWsDOMRuntimeExtension runtime) 
	{
		IWsDomLoadListener loadListener = loadListeners.get(runtime); 
		if (loadListener!=null) {
			return loadListener;
		}
		
		loadListener = new LoadListener(runtime);		
		loadListeners.put(runtime, loadListener);		
		runtime.addLoadListener(loadListener);
		
		return loadListener;
	}
	
	protected Object[] extractMethods(final IServiceEndpointInterface sei) 
	{
		final List<IWebMethod> webMethods = sei.getWebMethods();
		for (IWebMethod webMethod : webMethods) {
			adapterFactory.adapt(webMethod, ITreeItemContentProvider.class);
		}
		
		return webMethods.toArray();		
	}
	
	protected Object[] extractParams(final IWebMethod method) 
	{
		final List<IWebParam> params = method.getParameters();
		for (IWebParam webParam : params) {
			adapterFactory.adapt(webParam, ITreeItemContentProvider.class);
		}
		
		return params.toArray();
	}
	
	@Override
	public boolean hasChildren(Object element)
	{
		if (element instanceof IWebServiceProject)
		{
			return true;
		}
		else if(element instanceof ILoadingWsProject) 
		{
			return true;
		}
		else if(element instanceof IWebServiceChildList)
		{
			return !((IWebServiceChildList)element).getWSChildList().isEmpty();
		}
		else if(element instanceof ISEIChildList)
		{
			return !((ISEIChildList)element).getSEIChildList().isEmpty();
		}
		else if (element instanceof IWebService)
		{
			return ((IWebService) element).getServiceEndpoint() != null; 
		}
		else if (element instanceof IServiceEndpointInterface)
		{
			return !((IServiceEndpointInterface)element).getWebMethods().isEmpty();
		}
		else if (element instanceof IWebMethod)
		{
			return !((IWebMethod)element).getParameters().isEmpty();
		}

		return false;
	}
	
	protected IWebServiceProject getWsProject(final IDOM dom, final IProject project)
	{
		if (dom == null) {
			return null;
		}
		
		for (IWebServiceProject wsProject : dom.getWebServiceProjects()) {
			if(wsProject.getName().equals(project.getName())) {
				return wsProject;
			}
		}
		
		return null;
	}
	
	protected IWsDOMRuntimeExtension getSupportingRuntime(final IProject project)
	{
		final Collection<IWsDOMRuntimeInfo> domRuntimeInfos = WsDOMRuntimeRegistry.getRegisteredRuntimesInfo();
		Map<String, String> facets;
		for (IWsDOMRuntimeInfo domRuntimeInfo : domRuntimeInfos) 
		{
			facets = domRuntimeInfo.getProjectFacets();
			if (hasFacet(facets, project)) {
				return getDomRuntime(domRuntimeInfo.getId());
			}
		}

		return null;
	}
	
	protected boolean hasFacet(final Map<String, String> facets, final IProject project)
	{
		for (String facetId : facets.keySet()) 
		{
			if (facetId == null || facets.get(facetId) == null) {
				continue;
			}
			
			try {
				if ((new FacetUtils()).hasFacetWithVersion(project, facets.get(facetId), facetId, true)){
					return true;
				}
			} 
			catch (CoreException e) {
				(new Logger()).logError(e.getMessage(), e);
			}
		}
		
		return false;
	}
	
	protected IWsDOMRuntimeExtension getDomRuntime(String runtimeId) {
		return WsDOMRuntimeManager.instance().getDOMRuntime(runtimeId);
	}
	
	/**
	 * Class that is used to listen when the DOM load will be finished. After the load has finished
	 * this class traverses the project explorers tree in order to find all instances of
	 * {@link ILoadingWsProject} and substitute them with loaded {@link IWebServiceProject}
	 * 
	 * @author Georgi Vachkov
	 */
	protected class LoadListener implements IWsDomLoadListener
	{
		private final IWsDOMRuntimeExtension runtime;
		
		public LoadListener(final IWsDOMRuntimeExtension runtime) 
		{
			ContractChecker.nullCheckParam(runtime, "runtime"); //$NON-NLS-1$
			this.runtime = runtime;
		}
			
		public void finished() 
		{
			Display.getDefault().asyncExec(new Runnable()
			{
				public void run() 
				{
					final IViewPart viewPart = ProjectExplorerUtil.INSTANCE.findProjectExplorer();
					if (viewPart instanceof CommonNavigator) 
					{
						final CommonViewer commonViewer = ((CommonNavigator)viewPart).getCommonViewer();
						for (TreeItem item : commonViewer.getTree().getItems()) {
							exchangeDummy(item, commonViewer);
						}
					}
				}
			});
		}		

		protected void exchangeDummy(final TreeItem treeItem, final CommonViewer commonViewer) 
		{
			if (treeItem == null || treeItem.getData() instanceof IWebServiceProject) {
				return;
			}
			
			if (treeItem.getData() instanceof ILoadingWsProject) {
				exchangeTreeItemData(treeItem, commonViewer);
			}
			else {
				for (TreeItem child : treeItem.getItems()) {
					exchangeDummy(child, commonViewer);
				}
			}
		}

		private void exchangeTreeItemData(final TreeItem treeItem, final CommonViewer commonViewer) 
		{
			final ILoadingWsProject loadingProject = (ILoadingWsProject)treeItem.getData();
			try {
				final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), loadingProject.getProject());
				adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
				treeItem.setData(wsProject);

			} catch (WsDOMLoadCanceledException e) { // $JL-EXC$
				treeItem.setData(new LoadingWsProject(loadingProject.getProject(), true));
			}
			
			commonViewer.refresh(loadingProject.getProject());
		}
		
		public void started() {
			// nothing to do here
		}
	}
	
	private class LoadingWsProject implements ILoadingWsProject
	{
		final IProject project;
		final boolean isCanceled;
		
		public LoadingWsProject(final IProject project, final boolean isCanceled) {
			ContractChecker.nullCheckParam(project, "project"); //$NON-NLS-1$
			this.project = project;
			this.isCanceled = isCanceled;
		}
		
		public IProject getProject() {
			return project;
		}

		public boolean isLoadCanceled() {
			return isCanceled;
		}
	}
}