//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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.process;

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

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator;
import org.eclipse.emf.edit.provider.Disposable;
import org.eclipse.emf.edit.provider.IWrapperItemProvider;
import org.eclipse.epf.library.edit.ICachedChildrenItemProvider;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.process.command.PBSDragAndDropCommand;
import org.eclipse.epf.library.edit.process.command.PBSDropCommand;
import org.eclipse.epf.library.edit.util.Comparators;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.Milestone;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.WorkProductDescriptor;
import org.eclipse.epf.uma.util.AssociationHelper;


/**
 * @author Phong Nguyen Le
 * @since 1.0
 */
public class PBSActivityItemProvider extends BSActivityItemProvider 
implements ICachedChildrenItemProvider
{

	private Disposable rolledUpWrappers;

	/**
	 * @param adapterFactory
	 */
	public PBSActivityItemProvider(AdapterFactory adapterFactory) {
		super(adapterFactory);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.ibm.library.edit.process.BSActivityItemProvider#collectNewChildDescriptors(java.util.Collection,
	 *      java.lang.Object)
	 */
	protected void collectNewChildDescriptors(Collection newChildDescriptors,
			Object object) {
		// Activity act = (Activity) object;
		// if(hasChildDescriptor(act)) {
		// newChildDescriptors.add
		// (createChildParameter
		// (UmaPackage.eINSTANCE.getActivity_BreakdownElements(),
		// UmaFactory.eINSTANCE.createWorkProductDescriptor()));
		// }
		// else {
		newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE
				.getActivity_BreakdownElements(), UmaFactory.eINSTANCE
				.createPhase()));

		newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE
				.getActivity_BreakdownElements(), UmaFactory.eINSTANCE
				.createIteration()));

		newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE
				.getActivity_BreakdownElements(), UmaFactory.eINSTANCE
				.createActivity()));

		// if(act.getBreakdownElements().isEmpty()) {
		newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE
				.getActivity_BreakdownElements(), UmaFactory.eINSTANCE
				.createWorkProductDescriptor()));
		// }

		// }

		newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE
				.getActivity_BreakdownElements(), UmaFactory.eINSTANCE
				.createMilestone()));

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.epf.uma.tng.process.BSActivityItemProvider#acceptAsChild(java.lang.Object)
	 */
	protected boolean acceptAsChild(Object child) {
		child = TngUtil.unwrap(child);

		if (child instanceof Activity
				|| child instanceof WorkProductDescriptor
				|| child instanceof Milestone) {
			return super.acceptAsChild(child);
		}
		return false;
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.emf.edit.provider.ItemProviderAdapter#getChildren(java.lang.Object)
	 */
	public Collection getChildren(Object object) {
		if (rolledUpWrappers != null) {
			rolledUpWrappers.dispose();
		}

		if (isRolledUp()) {
			Map workProductToWrappersMap = new HashMap();
			Collection children = super.getChildren(object);
			for (Iterator iter = children.iterator(); iter.hasNext();) {
				Object child = iter.next();
				Object e = TngUtil.unwrap(child);
				if (e instanceof WorkProductDescriptor) {
					WorkProductDescriptor desc = (WorkProductDescriptor) e;
					List list = AssociationHelper.getDeliverableDescriptors(desc);
					Object wrapperKey = desc.getWorkProduct() == null ? (Object)desc : desc.getWorkProduct();
					List wrappers = (List) workProductToWrappersMap.get(wrapperKey);
					if (list.size() < 1) {
						// check if the descriptor already exists in the
						// rollup list
						//
						if(wrappers == null) {
							wrappers = new ArrayList();
							workProductToWrappersMap.put(wrapperKey, wrappers);
							wrappers.add(new ComposedWPDescriptorWrapperItemProvider(child, object, adapterFactory));
						}
						else {
							for (int i = wrappers.size() - 1; i > -1; i--) {
								((ComposedWPDescriptorWrapperItemProvider)wrappers.get(i)).addWorkProductDescriptor(child);
							}
						}
					} else {
							boolean checkExist = true;							
							if(wrappers == null) {
								wrappers = new ArrayList();
								workProductToWrappersMap.put(wrapperKey, wrappers);
								checkExist = false;
							}
							if(checkExist) {
								// remove any wrapper that is not of type DeliverableWorkProductDescriptorItemProvider from the wrapper list
								//
								for (Iterator iterator = wrappers.iterator(); iterator
										.hasNext();) {
									Object wrapper = (Object) iterator.next();
									if(!(wrapper instanceof DeliverableWorkProductDescriptorItemProvider)) {
										iter.remove();
									}
								}
								
								checkExist = wrappers.size() > 0;
							}
							
							// show one descriptor per deliverable
							//
							add_descriptors:
							for (Iterator iterator = list.iterator(); iterator.hasNext();) {
								Object deliverableDescriptor = iterator.next();
								if(checkExist) {
									for (int i = wrappers.size() - 1; i > -1; i--) {
										DeliverableWorkProductDescriptorItemProvider wrapper = (DeliverableWorkProductDescriptorItemProvider) wrappers.get(i);
										if(wrapper.deliverableDescriptor == deliverableDescriptor) {
											wrapper.addWorkProductDescriptor(child);
											continue add_descriptors;
										}
									}
								}

								DeliverableWorkProductDescriptorItemProvider itemProvider = new DeliverableWorkProductDescriptorItemProvider(
										desc, object, adapterFactory);
								itemProvider.deliverableDescriptor = deliverableDescriptor;
								wrappers.add(itemProvider);
							}

					}
				}
			}
			List rolledUpChildren = new ArrayList();
			for (Iterator iter = workProductToWrappersMap.values().iterator(); iter.hasNext();) {
				rolledUpChildren.addAll((Collection) iter.next());
				
			}
			List result = removeSubartifactsFromChildren(rolledUpChildren, true);
			if(rolledUpWrappers == null) {
				rolledUpWrappers = new Disposable();
			}
			rolledUpWrappers.addAll(result);
			
			// dispose wrappers of subartifact
			//
			for(int i = rolledUpChildren.size() - 1; i > -1; i--) {
				IWrapperItemProvider wrapper = (IWrapperItemProvider) rolledUpChildren.get(i);
				if(!rolledUpWrappers.contains(wrapper)) {
					wrapper.dispose();
				}
			}
			
			Collections.sort(result, Comparators.PRESENTATION_NAME_COMPARATOR);
			
			updateCachedChildren(result);
			
			return result;
		}

		Collection children = removeSubartifactsFromChildren(super.getChildren(object), false);
		
		updateCachedChildren(children);
		
		return children;
	}	
	
	/* (non-Javadoc)
	 * @see org.eclipse.epf.library.edit.process.BreakdownElementItemProvider#dispose()
	 */
	public void dispose() {
		if(rolledUpWrappers != null) {
			rolledUpWrappers.dispose();
		}
		
		super.dispose();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.epf.library.edit.process.BSActivityItemProvider#isNewDescriptor(java.util.List, java.lang.Object)
	 */
	protected boolean isNewDescriptor(List children, Object child) {
		// return true to let overriden getChildren() to handle the uniqueness of the rollup list
		//
		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.ibm.library.edit.process.BSActivityItemProvider#createOrMovePackageFor(java.util.List)
	 */
	protected void createOrMovePackageFor(List newChildren) {
		super.createOrMovePackageFor(newChildren);

		for (Iterator iter = newChildren.iterator(); iter.hasNext();) {
			Object e = iter.next();
			if (e instanceof WorkProductDescriptor) {
				// add deliverable parts to the activity's package
				WorkProductDescriptor wpd = (WorkProductDescriptor) e;
				for (Iterator iterator = wpd.getDeliverableParts().iterator(); iterator
						.hasNext();) {
					WorkProductDescriptor part = (WorkProductDescriptor) iterator
							.next();
					ProcessUtil.addToContainer(part, this, false);
				}
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.ibm.library.edit.process.BSActivityItemProvider#getObject(org.eclipse.epf.uma.Descriptor)
	 */
	protected Object getObject(Descriptor descriptor) {
		return ((WorkProductDescriptor) descriptor).getWorkProduct();
	}

	protected Command createDragAndDropCommand(EditingDomain domain,
			Object owner, float location, int operations, int operation,
			Collection collection) {
		return new PBSDragAndDropCommand(domain, owner, location, operations,
				operation, collection);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.ibm.library.edit.process.BSActivityItemProvider#createDropCommand(java.lang.Object,
	 *      java.util.List)
	 */
	public IResourceAwareCommand createDropCommand(Object owner,
			List dropElements) {
		return new PBSDropCommand((Activity) owner, dropElements);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.ibm.library.edit.process.BSActivityItemProvider#acceptAsRolledUpChild(java.lang.Object)
	 */
	protected boolean acceptAsRolledUpChild(Object child) {
		Object obj = TngUtil.unwrap(child);

		if (obj instanceof WorkProductDescriptor && ((WorkProductDescriptor)obj).getSuperActivities() != null) {
			return super.acceptAsRolledUpChild(obj);
		}
		return false;
	}

	public Collection getEClasses() {
		return ProcessUtil.getPBSEclasses();
	}

	private static class DeliverableWorkProductDescriptorItemProvider extends
			ComposedWPDescriptorWrapperItemProvider {

		private Object deliverableDescriptor;

		/**
		 * @param value
		 * @param owner
		 * @param adapterFactory
		 */
		public DeliverableWorkProductDescriptorItemProvider(
				WorkProductDescriptor value, Object owner,
				AdapterFactory adapterFactory) {
			super(value, owner, adapterFactory);
			readOnly = false;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see com.ibm.library.edit.process.BreakdownElementWrapperItemProvider#getAttribute(java.lang.Object,
		 *      java.lang.String)
		 */
		public String getAttribute(Object object, String property) {
			if (property == IBSItemProvider.COL_DELIVERABLE) {
				return TngUtil.getPresentationName(deliverableDescriptor);
			}
			return super.getAttribute(object, property);
		}

	}

	protected List removeSubartifactsFromChildren(Collection children, boolean unwrap) {
		MethodConfiguration config = getConfigurator() == null ? null : getConfigurator().getMethodConfiguration();
		List<?> list = ProcessUtil.removeSubartifactsFromChildren(config, children, unwrap);
		if(list.size() !=  children.size()) {
			// parent of descriptors of subartifacts has been set to this activity
			// iterate the subtree of the artifact descriptors in chidren list to correct this
			//
			for (Iterator<?> iterator = children.iterator(); iterator.hasNext();) {
				Object child = (Object) iterator.next();
				if(child instanceof WorkProductDescriptor && ((WorkProductDescriptor)child).getWorkProduct() instanceof Artifact) {
					for(AdapterFactoryTreeIterator<?> iter = new AdapterFactoryTreeIterator<Object>(adapterFactory, child);
						iter.hasNext(); iter.next());					
				}
			}
		}
		return list;
	}

	@Override
	protected boolean isWrappingRollupNeeded(Object object) {
		if(TngUtil.unwrap(object) instanceof WorkProductDescriptor) {
			return true;
		}
		return super.isWrappingRollupNeeded(object);
	}
	
}