//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 IBM Corporation 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.edit.navigator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.provider.IItemLabelProvider;
import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.provider.ItemProviderAdapter;
import org.eclipse.emf.edit.provider.ViewerNotification;
import org.eclipse.epf.library.edit.ILibraryItemProvider;
import org.eclipse.epf.library.edit.IStatefulItemProvider;
import org.eclipse.epf.library.edit.LibraryEditPlugin;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.util.Comparators;
import org.eclipse.epf.library.edit.util.PluginUIPackagesMap;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.provider.MethodPluginItemProvider;

/**
 * Item Provider Adapter that represents a plugin-package.  This is a UI folder only
 * @author Jeff Hardy
 *
 */
public class PluginUIPackagesItemProvider extends ItemProviderAdapter implements IStructuredItemContentProvider,
	ITreeItemContentProvider, IItemLabelProvider, ILibraryItemProvider, IStatefulItemProvider {

	public static final String PLUGIN_PACKAGE_SEPARATOR = "."; //$NON-NLS-1$

	private Object parent;
	
	private String name;
	
	private Collection<MethodPlugin> plugins;

	private Map<String, PluginUIPackagesItemProvider> pluginPackagesItemProvidersMap = new HashMap<String, PluginUIPackagesItemProvider>();


	/**
	 * Creates a new instance.
	 */
	public PluginUIPackagesItemProvider(AdapterFactory adapterFactory, String packageName, Collection<MethodPlugin> plugins) {
		super(adapterFactory);
		this.name = packageName;
		this.plugins = plugins;
	}

	public void setParent(Object parent) {
		this.parent = parent;
	}
	
	/**
	 * 
	 * @return the parent of this ItemProvider
	 */
	public Object getParent() {
		return parent;
	}
	
	@Override
	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
		// TODO Auto-generated method stub
		return super.getChildrenFeatures(object);
	}
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.emf.edit.provider.ItemProviderAdapter#getText(java.lang.Object)
	 */
	public String getText(Object object) {
		return name; 
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.emf.edit.provider.ItemProviderAdapter#getImage(java.lang.Object)
	 */
	public Object getImage(Object object) {
		return LibraryEditPlugin.INSTANCE.getImage("full/obj16/package_obj"); //$NON-NLS-1$
	}

	public static String getNameDelta(PluginUIPackagesItemProvider topObject, Object bottomObject) {
		
		String topName= topObject.getFullName();
		String bottomName = null;
		if (bottomObject instanceof PluginUIPackagesItemProvider) {
			bottomName = ((PluginUIPackagesItemProvider)bottomObject).getFullName();
			
		} else if (bottomObject instanceof MethodPlugin) {
			bottomName = ((MethodPlugin)bottomObject).getName();
		}
		
		if(bottomName == null || topName.equals(bottomName))
			return topName;
		try {
			String deltaname= bottomName.substring(topName.length()+1);
			return deltaname;
		} catch (StringIndexOutOfBoundsException e) {
			return bottomName;
		}
	}

	
	public Collection<Object> getChildren(Object parentElement) {
		return addChildren(plugins);
	}
	
	private Collection<Object> addChildren(Collection<MethodPlugin> plugins) {
		List children = new ArrayList();
		PluginUIPackagesMap map = new PluginUIPackagesMap();
		for (Iterator<MethodPlugin> iter = plugins.iterator();iter.hasNext();) {
			MethodPlugin plugin = iter.next();
			String deltaName = getNameDelta(this, plugin);
			int dotIdx = deltaName.indexOf(PLUGIN_PACKAGE_SEPARATOR);
			if (dotIdx != -1) {
				map.add(deltaName.substring(0, dotIdx), plugin);
			} else {
				children.add(plugin);
				Object adapter = adapterFactory.adapt(plugin,
						ITreeItemContentProvider.class);
				if (adapter instanceof ILibraryItemProvider) {
					((ILibraryItemProvider) adapter).setParent(this);
				}
			}
		}
		Collection<String> existingNames = new HashSet<String>();
		for (Iterator<Map.Entry<String, Set<MethodPlugin>>> iter = map.entrySet().iterator();iter.hasNext();) {
			Map.Entry<String, Set<MethodPlugin>> entry = iter.next();
			String name = entry.getKey();
			Set<MethodPlugin> plugSet = entry.getValue();
			PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name);
			if (provider == null) {
				provider = new PluginUIPackagesItemProvider(adapterFactory, name, plugSet);
				pluginPackagesItemProvidersMap.put(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name, provider);
			} else {
				provider.setPlugins(plugSet);
			}
			existingNames.add(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name);
			provider.setParent(this);
			children.add(provider);
		}
		retainPluginPackagesItemProviders(existingNames);
		Collections.sort(children, Comparators.PLUGINPACKAGE_COMPARATOR);
		return children;
	}
	
	/**
	 * 
	 * @return full name of this package
	 */
	public String getFullName() {
		String fullName = getName();
		Object parent = getParent();
		while (parent instanceof PluginUIPackagesItemProvider) {
			fullName = ((PluginUIPackagesItemProvider)parent).getName() + PLUGIN_PACKAGE_SEPARATOR + fullName;
			parent = ((PluginUIPackagesItemProvider)parent).getParent();
		}
		return fullName;
		
	}

	public String getName() {
		return name;
	}
	
	@Override
	public Object getParent(Object object) {
		if (parent != null)
			return parent;
		return target;
	}
	
	public void notifyChanged(Notification notification) {
		updateChildren(notification);

		switch (notification.getFeatureID(MethodPlugin.class)) {
		case UmaPackage.METHOD_PLUGIN__NAME:
			fireNotifyChanged(new ViewerNotification(notification, notification
					.getNotifier(), true, true));
			break;
		}

		super.notifyChanged(notification);
	}

	@Override
	public void dispose() {
		// remove this from the plugins' adapter list
		if (pluginPackagesItemProvidersMap != null) {
			pluginPackagesItemProvidersMap.clear();
			pluginPackagesItemProvidersMap = null;
		}
		super.dispose();
	}
	
	private void retainPluginPackagesItemProviders(Collection<String> names) {
		for (Iterator<String> iter = pluginPackagesItemProvidersMap.keySet().iterator();iter.hasNext();) {
			String keyName = iter.next();
			if (!names.contains(keyName)) {
				PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(keyName);
				if (provider != null) {
					provider.dispose();
				}
				iter.remove();
			}
		}
	}
	
	public Collection<MethodPlugin> getPlugins() {
		return plugins;
	}

	public void setPlugins(Collection<MethodPlugin> plugins) {
		this.plugins = plugins;
	}
	
	/**
	 * 
	 * @param plugin
	 * @return the ItemProviderAdapter for the plugin - either a MethodPluginItemProvider or a PluginUIPackagesItemProvider. null if none found
	 */
	public ItemProviderAdapter getPluginItemProvider(MethodPlugin plugin) {
		String deltaName = getNameDelta(this, plugin);
		int dotIdx = deltaName.indexOf(PluginUIPackagesItemProvider.PLUGIN_PACKAGE_SEPARATOR);
		if (dotIdx != -1) {
			String packageProviderName = deltaName.substring(0, dotIdx);
			if (pluginPackagesItemProvidersMap != null) {
				PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(getFullName() + PLUGIN_PACKAGE_SEPARATOR + packageProviderName);
				if (provider != null) {
					return provider;
				}
			}			
		} else {
			return (MethodPluginItemProvider) TngUtil
				.getAdapter(plugin, MethodPluginItemProvider.class);
		}
		return null;
	}
	
	/**
	 * 
	 * @param itemName name of item to find
	 * @param lib MethodLibrary
	 * @return the MethodPlugin or PluginUIPackagesItemProvider with the specified name, or null if not found
	 */
	public static Object findPluginItemProvider(String itemName, MethodLibrary lib) {
		ITreeItemContentProvider adapter = (ITreeItemContentProvider)TngAdapterFactory.INSTANCE
				.getNavigatorView_ComposedAdapterFactory().adapt(lib, ITreeItemContentProvider.class);
		if (adapter instanceof MethodLibraryItemProvider) {
			MethodLibraryItemProvider libraryAdapter = (MethodLibraryItemProvider)adapter;
			List<MethodPlugin> pluginList = lib.getMethodPlugins();
			for (MethodPlugin plugin : pluginList) {
				if (itemName.equals(plugin.getName())) {
					return plugin;
				}
				Collection<?> children = libraryAdapter.getChildren(lib);
				ItemProviderAdapter pluginTreeAdapter = libraryAdapter.getPluginItemProvider(plugin);
				while (pluginTreeAdapter instanceof PluginUIPackagesItemProvider) {
					if (itemName.equals(((PluginUIPackagesItemProvider)pluginTreeAdapter).getFullName())) {
						return pluginTreeAdapter;
					}
					children = pluginTreeAdapter.getChildren(pluginTreeAdapter);
					pluginTreeAdapter = ((PluginUIPackagesItemProvider)pluginTreeAdapter).getPluginItemProvider(plugin);
				}
			}
		}
		return null;
	}
}