//------------------------------------------------------------------------------
// 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.diagram.model.impl;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.epf.diagram.model.ActivityDetailDiagram;
import org.eclipse.epf.diagram.model.ModelFactory;
import org.eclipse.epf.diagram.model.ModelPackage;
import org.eclipse.epf.diagram.model.Node;
import org.eclipse.epf.diagram.model.RoleNode;
import org.eclipse.epf.diagram.model.RoleTaskComposite;
import org.eclipse.epf.diagram.model.TaskNode;
import org.eclipse.epf.diagram.model.WorkProductComposite;
import org.eclipse.epf.diagram.model.util.GraphicalDataHelper;
import org.eclipse.epf.diagram.model.util.GraphicalDataManager;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Diagram;
import org.eclipse.epf.uma.GraphNode;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Property;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.UMASemanticModelBridge;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.ecore.util.OppositeFeatureNotification;
import org.eclipse.epf.uma.util.AssociationHelper;


/**
 * <!-- begin-user-doc --> An implementation of the model object '<em><b>Role Task Composite</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.epf.diagram.model.impl.RoleTaskCompositeImpl#getRowIndex <em>Row Index</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class RoleTaskCompositeImpl extends NodeContainerImpl implements
		RoleTaskComposite {
	
	/**
	 * The default value of the '{@link #getRowIndex() <em>Row Index</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getRowIndex()
	 * @generated
	 * @ordered
	 */
	protected static final int ROW_INDEX_EDEFAULT = 0;

	/**
	 * The cached value of the '{@link #getRowIndex() <em>Row Index</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getRowIndex()
	 * @generated
	 * @ordered
	 */
	protected int rowIndex = ROW_INDEX_EDEFAULT;

//	private int rowIndex;
	
	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 */
	protected RoleTaskCompositeImpl() {
		super();

		methodElementAdapter = new RoleDescriptorAdapter();
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return ModelPackage.Literals.ROLE_TASK_COMPOSITE;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public int getRowIndex() {
		return rowIndex;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setRowIndex(int newRowIndex) {
		int oldRowIndex = rowIndex;
		rowIndex = newRowIndex;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX, oldRowIndex, rowIndex));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
				return new Integer(getRowIndex());
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
				setRowIndex(((Integer)newValue).intValue());
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
				setRowIndex(ROW_INDEX_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
				return rowIndex != ROW_INDEX_EDEFAULT;
		}
		return super.eIsSet(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public String toString() {
		if (eIsProxy()) return super.toString();

		StringBuffer result = new StringBuffer(super.toString());
		result.append(" (rowIndex: "); //$NON-NLS-1$
		result.append(rowIndex);
		result.append(')');
		return result.toString();
	}

	private static boolean contains(Collection mixedCollection, Object element) {
		for (Iterator iter = mixedCollection.iterator(); iter.hasNext();) {
			if( element == TngUtil.unwrap(iter.next()) ) {
				return true;
			}		
		}
		return false;
	}
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.epf.diagram.model.impl.NodeImpl#setObject(java.lang.Object)
	 */
	public void setObject(Object newObject) {
		super.setObject(newObject);
		populateNodes(newObject);
	}
	
	public GraphNode getGraphNode(MethodElement methodElement) {
		if(isGraphicalDataRequired()) {
			if (getUMADiagram() == null) {
				// new MethodElement
				//
				return GraphicalDataManager.getInstance().createGraphNode(methodElement);
			}
			GraphNode node = findGraphNode(getUMADiagram(), methodElement);
			if (node == null) {
				node = GraphicalDataManager.getInstance().createGraphNode(methodElement);
				// createGraphConnectors(node, getUMADiagram());
				getUMADiagram().getContained().add(node);
			}
			String autolayout = GraphicalDataHelper.getAutoLayoutFlag((ActivityDetailDiagram)getDiagram());
			if(autolayout != null){
				GraphicalDataHelper.createProperty(node, GraphicalDataHelper.PROP_INDEX, new Integer(rowIndex).toString());
			}
			return node;
		}
		return null;
	}

	public GraphNode findGraphNode(Diagram diagram, Object methodElement) {
		for (Iterator iter = diagram.getContained().iterator(); iter.hasNext();) {
			GraphNode element = (GraphNode) iter.next();
			if (element.getSemanticModel() instanceof UMASemanticModelBridge
					&& methodElement == ((UMASemanticModelBridge) element
							.getSemanticModel()).getElement()) {

				Property property = GraphicalDataHelper.findProperty(element, GraphicalDataHelper.PROP_INDEX);
				
				if (property != null) {
					String index = property.getValue();
					if (index != null) {
						if (getRowIndex() == new Integer(index).intValue())
							return element;
					}
				}else{
					return element;
				}
			}
		}
		return null;
	}
	
//	public GraphNode createGraphNode(MethodElement element) {
//		GraphNode node = GraphicalDataManager.getInstance().createGraphNode(element);
//		GraphicalDataHelper.createProperty(node,
//				GraphicalDataHelper.PROP_INDEX, new Integer(rowIndex)
//						.toString());
//		return node;
//	}
	
	private class RoleDescriptorAdapter extends TransactionalNodeLink {

		@Override
		protected void handleNotification(Notification msg) {
			if(msg instanceof OppositeFeatureNotification) {
				Object feature = ((OppositeFeatureNotification)msg).getOppsiteFeature();
				if(feature == AssociationHelper.RoleDescriptor_PrimaryTaskDescriptors) {
					switch (msg.getEventType()) {
					case Notification.ADD:
						addNode((TaskDescriptor) msg.getNewValue());
						break;
					case Notification.REMOVE:
						removeNode(msg.getOldValue());
						break;
					case Notification.ADD_MANY:
						addNode((Collection) msg.getNewValue());
						break;
					case Notification.REMOVE_MANY:
						removeNode((Collection) msg.getOldValue());
						break;						
					}
					return;
				}
			}
			switch (msg.getFeatureID(Activity.class)) {
			case UmaPackage.ACTIVITY__BREAKDOWN_ELEMENTS:
				switch (msg.getEventType()) {
				case Notification.MOVE:
//					System.out.println("MOVEEEEEEED");
					break;
				}
				break;
			}
		}

	}

	/**
	 * @param oldValue
	 */
	private void removeNode(Object oldValue) {
		org.eclipse.epf.diagram.model.Diagram diagram = getDiagram();
		if(diagram == null) {
			System.err.println("RoleTaskCompositeImpl.removeNode(): [ERROR] no diagram"); //$NON-NLS-1$
		}
		Collection removedNodes = new HashSet();
		for (Iterator iter = nodes.iterator(); iter.hasNext();) {
			Node node = (Node) iter.next();
			if (oldValue instanceof TaskDescriptor) {
				if (node instanceof RoleNode) {
					ActivityDetailDiagramImpl d = (ActivityDetailDiagramImpl)getDiagram();
					List list = d.getRealizedPrimaryTaskDescriptors((RoleDescriptor) node.getObject());
					if (list == null || list.size() < 1) {
						iter.remove();
						removedNodes.add(node);
					}
				}
			}
			if (node.getObject() == oldValue) {
				iter.remove();
				removedNodes.add(node);
				if (oldValue instanceof TaskDescriptor) {
					Node wpnode = GraphicalDataHelper.findNode(
							(ActivityDetailDiagram) getDiagram(), oldValue);
					getDiagram().getNodes().remove(wpnode);
					wpnode = GraphicalDataHelper.findNode(
							(ActivityDetailDiagram) getDiagram(), oldValue);
					getDiagram().getNodes().remove(wpnode);
				}
			}
		}
		if (nodes.isEmpty()) {
			getDiagram().getNodes().remove(this);
		}
		// pushBackToDiagram(removedNodes);
	}

	/**
	 * @param descriptor
	 */
	private void addNode(TaskDescriptor descriptor) {
		addNode(getNodes(), descriptor);
	}

	private void addNode(Collection nodes, TaskDescriptor descriptor) {
		if(descriptor.getSuperActivities() == null) {
			return;
		}
		ActivityDetailDiagramImpl diagram = (ActivityDetailDiagramImpl) getDiagram();
		Node node = GraphicalDataHelper.findNode(this,
				descriptor, TaskNode.class);
		if (node == null) {
			node = diagram.createNode(descriptor);
			if(node != null) {
				int i = getNextIndex(getNodes());
				if (node instanceof TaskNodeImpl) {
					((TaskNodeImpl) node).doSetIndex(i + 1);
				}
				nodes.add(node);
				Collection inputOutputNodes = new ArrayList();
				diagram.createTaskInputOutputNodes(descriptor, inputOutputNodes);				
				if (!inputOutputNodes.isEmpty()) {
					diagram.getNodes().addAll(inputOutputNodes);
					diagram.populateLinks(inputOutputNodes, false);
				}
			}
 		}
	}

	/**
	 * @param oldValue
	 */
	private void removeNode(Collection elements) {
		Collection nodes = new ArrayList();
		for (Iterator iter = nodes.iterator(); iter.hasNext();) {
			Node node = (Node) iter.next();
			if (elements.contains(node.getObject())) {
				nodes.add(node);
			}
		}
		getNodes().removeAll(nodes);
		// pushBackToDiagram(nodes);
	}

	/**
	 * @param newValue
	 */
	private void addNode(Collection elements) {
		Collection nodes = new ArrayList();
		for (Iterator iter = elements.iterator(); iter.hasNext();) {
			TaskDescriptor descriptor = (TaskDescriptor) iter.next();
			addNode(nodes, descriptor);
		}

		getNodes().addAll(nodes);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.epf.diagram.model.impl.NodeImpl#getMethodElementAdapterType()
	 */
	public Class getMethodElementAdapterType() {
		return RoleDescriptorAdapter.class;
	}
	
	/**
	 * @return
	 */
	private int getNextIndex(List nodes) {
		int index = 0;
		for(Iterator iterator = nodes.iterator(); iterator.hasNext();){
			Object obj = iterator.next();			
//			if(obj instanceof Node){
//				Node node = (Node)obj;
//				//String temp = GraphicalDataHelper.findProperty(node.getGraphNode(), GraphicalDataHelper.PROP_INDEX).getValue();
//				List list = node.getGraphNode().getList(UmaPackage.GRAPH_NODE__PROPERTY);
//				if(list != null && !list.isEmpty()){
//					for (int i = list.size() - 1; i > -1; i--) {
//						Property prop = (Property) list.get(i);
//						if (GraphicalDataHelper.PROP_INDEX.equals(prop.getKey())){
//							int temp  = Integer.parseInt(prop.getValue());
//							if(temp > index ) index = temp;
//						}
//					}
//				}
//			}
			if(obj instanceof TaskNodeImpl) {
				int id = ((TaskNodeImpl)obj).doGetIndex();
				if(id > index) {
					index = id;
				}
			}
		}
		return index;
	}
	
	private static final Comparator comparator = new Comparator() {

		public int compare(Object obj1, Object obj2) {
			if (obj1 == obj2)
				return 0;
			if(obj1 instanceof TaskNodeImpl && obj2 instanceof TaskNodeImpl){
				TaskNodeImpl node1 = (TaskNodeImpl)obj1;
				TaskNodeImpl node2 = (TaskNodeImpl)obj2;
				if(node1.doGetIndex() >  node2.doGetIndex())
					return 1;
			}
			return 0;
		}

	};

	public void createTaskInputOutputNodes(TaskDescriptor descriptor, Collection nodes) {
		Node newNode = null;
		if (!descriptor.getMandatoryInput().isEmpty()) {
			newNode = createWorkProductComposite(descriptor,
					WorkProductComposite.INPUTS);
			nodes.add(newNode);
		}
		if (!descriptor.getOutput().isEmpty()) {
			newNode = createWorkProductComposite(descriptor,
					WorkProductComposite.OUTPUTS);
			nodes.add(newNode);
		}
	}
	
	public WorkProductComposite createWorkProductComposite(
			TaskDescriptor taskDescriptor, int type) {
		WorkProductComposite workproductComposite = ModelFactory.eINSTANCE
				.createWorkProductComposite();
		workproductComposite.setUMAContainer(getGraphNode());
		workproductComposite.setDiagram(getDiagram());
		workproductComposite.setType(type);
		workproductComposite.setObject(taskDescriptor);
		return workproductComposite;
	}
	
	private TaskNode createTaskNode(TaskDescriptor td) {
		TaskNode taskNode = null;
		for (Iterator iter = getNodes().iterator(); iter.hasNext();) {
			Node node = (Node) iter.next();
			if(node instanceof TaskNode) {
				TaskNode tn = (TaskNode) node;
				if(tn.getLinkedElement() == td) {
					taskNode = tn;
					break;
				}
			}
		}
		if(taskNode == null) {
			taskNode = ModelFactory.eINSTANCE.createTaskNode();
			taskNode.setDiagram(getDiagram());
		}
		taskNode.setObject(td);
		return taskNode;
	}
	
	private RoleNode createRoleNode(RoleDescriptor rd) {
		RoleNode roleNode = null;
		for (Iterator iter = getNodes().iterator(); iter.hasNext();) {
			Node node = (Node) iter.next();
			if(node instanceof RoleNode) {
				RoleNode rn = (RoleNode) node;
				if(rn.getLinkedElement() == rd) {
					roleNode = rn;
					break;
				}
			}
		}
		if(roleNode == null) {
			roleNode = ModelFactory.eINSTANCE.createRoleNode();
			roleNode.setDiagram(getDiagram());
			roleNode.setObject(rd);
		}
		return roleNode;
	}
	
	public void populateNodes(Object newObject){
		
		if (newObject instanceof RoleDescriptor) {
			RoleDescriptor roleDescriptor = (RoleDescriptor) newObject;
			ActivityDetailDiagramImpl diagram = (ActivityDetailDiagramImpl) getDiagram();
			Collection allElements = diagram.getAllBreakdownElements(true);
			List taskNodes = new ArrayList();
			List primaryTaskDescriptors = AssociationHelper.getPrimaryTaskDescriptors(roleDescriptor);
			if (!primaryTaskDescriptors.isEmpty()) { // overriding
																	
				List taskDescriptors = new ArrayList();
				taskDescriptors.addAll(primaryTaskDescriptors);
				HashSet selectedDescriptors = new HashSet();
				boolean autoLayout = ((ActivityDetailDiagramImpl)getDiagram()).isAutoLayout();
				if(autoLayout) {
					int index = 0;
					int rowTasksCount = 0;
					int startCount = 0;
					
					for (Iterator iter = allElements.iterator(); iter.hasNext();) {
						Object obj = iter.next();
						obj = TngUtil.unwrap(obj);
						if (obj instanceof TaskDescriptor
								&& TngUtil.contains(taskDescriptors, obj)) {
							TaskDescriptor taskDescriptor = (TaskDescriptor) obj;
							
							if(startCount < rowIndex * GraphicalDataHelper.getTasksPerRow()){
								startCount++;
							} else {

								if (!selectedDescriptors
										.contains(taskDescriptor)) {
									selectedDescriptors.add(taskDescriptor);
									Node node = GraphicalDataHelper.findNode(
											this, taskDescriptor,
											TaskNode.class);
									if (node == null) {
//										node = createTaskNode(taskDescriptor,
//												index, allElements);
										node = createTaskNode(taskDescriptor);
										TaskNodeImpl tn = (TaskNodeImpl) node;
										if (autoLayout || tn.doGetIndex() == -1) {
											tn.doSetIndex(index);
//											index++;
										}
										//return node;
									}
									else {
										// this will make sure that link between the node and linked element is established
										//
										node.setObject(taskDescriptor);
									}
									((NamedNodeImpl) node).setItemProvider(allElements);

									if (rowTasksCount < GraphicalDataHelper
											.getTasksPerRow()) {
										taskNodes.add(node);
										if(node instanceof TaskNode){
											((TaskNode)node).setIndex(index);
											index++;
										}
										rowTasksCount++;
									} else {
										break;
									}
								}
							}
						}
					}
					// Sort the taskNode based on their index if autolayout is
					// false
					if (!autoLayout) {
						Collections.sort(taskNodes, comparator);
					}
				} else {
					List oldTaskDescriptors = new ArrayList();
					Diagram umaDiagram = getUMADiagram();
					if(umaDiagram != null) {
						// Lame way of doing this, to fix a defect of 1.0 to 1.0.1 migration				  
						List graphNodes = umaDiagram.getContained();
						for (Iterator iter = graphNodes.iterator(); iter.hasNext();) {
							GraphNode element = (GraphNode) iter.next();
							Object bridge = element.getSemanticModel();
							if(bridge instanceof UMASemanticModelBridge){
								Object taskObject = ((UMASemanticModelBridge)bridge).getElement();
								List list = element.getList(UmaPackage.GRAPH_NODE__PROPERTY);
								Property property = GraphicalDataHelper.getPropertyByKey(list,
										GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE);
								if (taskDescriptors.contains(taskObject) && property == null) {
									oldTaskDescriptors.add(taskObject);
								}
							}
						}
					}
					else {
						for (Iterator iter = getNodes().iterator(); iter
								.hasNext();) {
							Node node = (Node) iter.next();
							if(node.getLinkedElement() instanceof TaskDescriptor) {
								oldTaskDescriptors.add(node.getLinkedElement());
							}
						}
					}
					for (Iterator iter = oldTaskDescriptors.iterator(); iter.hasNext();) {
						TaskDescriptor taskDescriptor = (TaskDescriptor) iter.next();

						// eliminate descriptor that is duplicate, suppressed or filtered out
						//
						if(!selectedDescriptors.contains(taskDescriptor)
								&& contains(allElements, taskDescriptor) // make sure that task descriptor is of the owning activity
						) {
							selectedDescriptors.add(taskDescriptor);					
							Node node = GraphicalDataHelper.findNode(getDiagram(),
									taskDescriptor, TaskNode.class);
							if (node == null) {
								node = createTaskNode(taskDescriptor);
								((NamedNodeImpl) node).setItemProvider(allElements);
							}
							taskNodes.add(node);
						}
					}
				}
			}
			if(!taskNodes.isEmpty()) {
				// add role node
				//
				NamedNodeImpl namedNode = ((NamedNodeImpl) createRoleNode(roleDescriptor));
				namedNode.visible = true;
				namedNode.setItemProvider(allElements);
				getNodes().add(namedNode);		
				taskNodes.add(namedNode);
			}
			selectNodes(taskNodes);
		}
		
	}
	
//	public Node createTaskNode(TaskDescriptor taskDescriptor, int index, Collection allElements) {
//		Node node = ModelFactory.eINSTANCE.createTaskNode();
//		node.setDiagram(getDiagram());
//		node.setObject(taskDescriptor);
//		((NamedNodeImpl) node).setItemProvider(allElements);
//		if (GraphicalDataHelper.findProperty(node.getGraphNode(),
//				GraphicalDataHelper.PROP_INDEX) == null
//				|| GraphicalDataHelper
//						.isAutoLayout((ActivityDetailDiagram) getDiagram())) {
//			GraphicalDataHelper.createProperty(node.getGraphNode(),
//					GraphicalDataHelper.PROP_INDEX, new Integer(index)
//							.toString());
//			index++;
//		}
//		return node;
//	}
	
} // RoleTaskCompositeImpl