//------------------------------------------------------------------------------
// 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
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// 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.diagram.core.bridge;

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

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.WorkBreakdownElement;
import org.eclipse.epf.uma.WorkOrder;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.uml2.uml.ActivityEdge;
import org.eclipse.uml2.uml.ActivityNode;

/**
 * @author Phong Nguyen Le
 *
 * @since 1.2
 */
public class WorkBreakdownElementNodeAdapter extends NodeAdapter {
	private class WorkBreakdownElementAdapter extends MethodElementAdapter {
		protected Collection handleNotification(Notification msg) {
			WorkOrder obj;
			switch (msg.getFeatureID(WorkBreakdownElement.class)) {
			case UmaPackage.WORK_BREAKDOWN_ELEMENT__LINK_TO_PREDECESSOR:
				switch (msg.getEventType()) {
				case Notification.ADD:
					obj = (WorkOrder) msg.getNewValue();
					addIncomingConnection(obj.getPred());
					break;
				case Notification.REMOVE:
					obj = (WorkOrder) msg.getOldValue();
					removeIncomingConnection(obj.getPred());
					break;
				case Notification.ADD_MANY:
					Collection collection = (Collection) msg.getNewValue();
					for (Iterator iter = collection.iterator(); iter.hasNext();) {
						obj = (WorkOrder) iter.next();
						addIncomingConnection(obj.getPred());
					}
					break;
				case Notification.REMOVE_MANY:
					collection = (Collection) msg.getOldValue();
					for (Iterator iter = collection.iterator(); iter.hasNext();) {
						obj = (WorkOrder) iter.next();
						removeIncomingConnection(obj.getPred());
					}
					break;
				}
				break;
			case UmaPackage.WORK_BREAKDOWN_ELEMENT__SUPPRESSED:
				switch (msg.getEventType()) {
				case Notification.SET:
//					Boolean b = (Boolean)msg.getNewValue();
//					handleSuppressed(b.booleanValue());
					break;
				}
				break;
			default:
				return super.handleNotification(msg);
			}
			return Collections.EMPTY_LIST;
		}
	}

	/**
	 * @param e
	 */
	public WorkBreakdownElementNodeAdapter(MethodElement e) {
		super(e);
	}

	public void handleSuppressed(boolean b) {
		if(b){
			List incomings = getNode().getIncomings();
			for (int i =0; i<incomings.size(); i++) {
				Object obj = incomings.get(i);
				ActivityEdge link = null;
				if(obj != null ){
					link = (ActivityEdge)obj;
				}
				if(link != null && link.getSource() != null){
					NodeAdapter sourceNodeAdapter = BridgeHelper.getNodeAdapter(link.getSource());
					boolean oldNotify1 = sourceNodeAdapter != null ? sourceNodeAdapter.notificationEnabled : false;
					try {
						if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = false;
						link.setTarget(null);
						getNode().getIncomings().remove(link);
					} finally {
						if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = oldNotify1;
					}
				}
			}
			List outGoings = getNode().getOutgoings();
			for (int i =0; i<outGoings.size(); i++) {
				Object obj = outGoings.get(i);
				ActivityEdge link = null;
				if(obj != null ){
					link = (ActivityEdge)obj;
				}
				if(link != null && link.getTarget() != null){
					NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(link.getTarget());
					boolean oldNotify1 = nodeAdapter != null ? nodeAdapter.notificationEnabled : false;
					try {
						if(nodeAdapter != null) nodeAdapter.notificationEnabled = false;
						link.setSource(null);
						getNode().getIncomings().remove(link);
					} finally {
						if(nodeAdapter != null) nodeAdapter.notificationEnabled = oldNotify1;
					}
				}
			}
		}else{
			List nodes = getDiagram().getNodes();
			for (Iterator iter = nodes.iterator(); iter.hasNext();) {
				ActivityNode element = (ActivityNode) iter.next();
				if(element != getNode() && target instanceof MethodElement){
					MethodElement me = BridgeHelper.getMethodElement(element);
					if(me != null){
						addIncomingConnection(me);
						addOutgoingConnection(me);
					}
				}
			}
		}
	}

	protected MethodElementAdapter createMethodElementAdapter() {
		return new WorkBreakdownElementAdapter();
	}
	
	protected boolean addToUMA(ActivityEdge link) {
		if (!super.addToUMA(link))
			return false;
		
		MethodElement e = BridgeHelper.getMethodElement(link.getSource());
		if (e instanceof WorkBreakdownElement) {
			// this is a direct link
			// add new WorkOrder object to UMA
			//
			WorkOrder order = null;
			WorkBreakdownElement succ = (WorkBreakdownElement) BridgeHelper.getMethodElement(link.getTarget());
			WorkBreakdownElement pred = (WorkBreakdownElement) e;
			if (UmaUtil.findWorkOrder(succ, pred) == null) {
				NodeAdapter sourceNodeAdapter = BridgeHelper.getNodeAdapter(link.getSource());	
				// node adapter can be NULL if the node is not currently visible in the diagram
				//
				boolean sourceNotify = sourceNodeAdapter != null ? sourceNodeAdapter.notificationEnabled : false;
				try {
					if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = false;
					//Create a workorder and disable notification flag.
					order = addDefaultWorkOrder(link.getTarget(), pred);
				} finally {
					if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = sourceNotify;
				}
			}

			// set the WorkOrder as the element of the SemanticModel of the
			// link's GraphEdge
			BridgeHelper.setSemanticModel(link, order);
		} 
		else if (BridgeHelper.isSynchBar(link.getSource())) {
			// get all WorkBreakdownElementNodes that are comming to this
			// TypedNode, both directly and indirectly
			// and create work orders with their activity as predecessor
			//

			// Predecessor should be created only in case of
			// Syncronization Bar, not for DecisionPoint.
			// TODO: review
			
				
				Collection actNodes = new ArrayList();
				// Get the collection incoming connection of syncbar 
				// excluding decisionpoint incoming connection
				BridgeHelper.getSyncBarSourceNodes(link.getSource(), actNodes);
				WorkBreakdownElement succ = (WorkBreakdownElement) BridgeHelper.getMethodElement(link.getTarget());
				for (Iterator iter = actNodes.iterator(); iter.hasNext();) {
					ActivityNode node = (ActivityNode) iter.next();
					WorkBreakdownElement pred = (WorkBreakdownElement) BridgeHelper.getMethodElement(node);
					if (UmaUtil.findWorkOrder(succ, pred) == null) {
						NodeAdapter sourceNode = BridgeHelper.getNodeAdapter(node);
						boolean sourceNotify = sourceNode.notificationEnabled;
						try {
							sourceNode.notificationEnabled = false;
							// Create a workorder and disable notification flag.
							addDefaultWorkOrder(link.getTarget(), pred);
						} finally {
							sourceNode.notificationEnabled = sourceNotify;
						}
					}
				}
		}
		return true;
	}
	
	protected ActivityEdge addIncomingConnection(MethodElement source) {
		ActivityEdge link = super.addIncomingConnection(source);
		if (link == null)
			return link;

		WorkOrder workOrder = UmaUtil.findWorkOrder(
				(WorkBreakdownElement) getElement(), source);
		BridgeHelper.setSemanticModel(link, workOrder);

		return link;
	}

	protected ActivityEdge addOutgoingConnection(MethodElement target) {
		ActivityEdge link = super.addOutgoingConnection(target);

		WorkOrder workOrder = UmaUtil.findWorkOrder(
				(WorkBreakdownElement) target, getElement());
		BridgeHelper.setSemanticModel(link, workOrder);

		return link;
	}

	protected boolean removeIncomingConnection(MethodElement source) {
		// look for the incoming connection with source as linked object of the
		// source node
		//
		for (ActivityEdge link : getNode().getIncomings()) {
			if (link.getSource() != null
					&& BridgeHelper.getMethodElement(link.getSource()) == source) {
				// disable internal notification of the source node
				//
				NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(link.getSource());
				boolean oldNotify = nodeAdapter != null ? nodeAdapter.notificationEnabled : false;
				try {
					if(nodeAdapter != null) nodeAdapter.notificationEnabled = false;
					link.setSource(null);
				} finally {
					if(nodeAdapter != null) nodeAdapter.notificationEnabled = oldNotify;
				}
				link.setTarget(null);
				BridgeHelper.setSemanticModel(link, null);
				getDiagram().getEdges().remove(link);
				return true;
			}
		}
		return false;
	}
	
//	@Override
//	protected void handleNotification(Notification msg) {
//		switch(msg.getFeatureID(ActivityParameterNode.class)) {
//		case UMLPackage.ACTIVITY_PARAMETER_NODE__EANNOTATIONS:
//			switch(msg.getEventType()) {
//			case Notification.ADD:
//				ActivityParameterNode node = (ActivityParameterNode) msg.getNotifier();
//				String type = BridgeHelper.getType(node);
//				MethodElement e = BridgeHelper.getMethodElement(node);				
//				if(e instanceof BreakdownElement && 
//						type != null && !type.equals(BridgeHelper.getType(e))) {
//					// replace the currently linked method element with the right one
//					//
//					EClass rightType = BridgeHelper.getType(type);
//					if(rightType != null) {
//						Object rightElement = UmaFactory.eINSTANCE.create(rightType);
//						List list = ((BreakdownElement)e).getSuperActivities().getBreakdownElements();
//						list.set(list.indexOf(e), rightElement);
//						return;
//					}
//					
//				}
//			}
//		}
//		
//		super.handleNotification(msg);
//	}
}