/*******************************************************************************
 * Copyright (c) 2011, 2012 Red Hat, Inc.
 *  All rights reserved.
 * This program is 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:
 * Red Hat, Inc. - initial API and implementation
 *
 * @author Bob Brodt
 ******************************************************************************/

package org.eclipse.bpmn2.modeler.ui.adapters.properties;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

import org.eclipse.bpmn2.Activity;
import org.eclipse.bpmn2.Bpmn2Package;
import org.eclipse.bpmn2.CallableElement;
import org.eclipse.bpmn2.DataAssociation;
import org.eclipse.bpmn2.DataInput;
import org.eclipse.bpmn2.DataInputAssociation;
import org.eclipse.bpmn2.DataObject;
import org.eclipse.bpmn2.DataObjectReference;
import org.eclipse.bpmn2.DataOutput;
import org.eclipse.bpmn2.DataOutputAssociation;
import org.eclipse.bpmn2.DataStore;
import org.eclipse.bpmn2.DataStoreReference;
import org.eclipse.bpmn2.DocumentRoot;
import org.eclipse.bpmn2.Event;
import org.eclipse.bpmn2.FlowElementsContainer;
import org.eclipse.bpmn2.InputOutputSpecification;
import org.eclipse.bpmn2.ItemAwareElement;
import org.eclipse.bpmn2.Process;
import org.eclipse.bpmn2.Property;
import org.eclipse.bpmn2.di.BPMNShape;
import org.eclipse.bpmn2.modeler.core.adapters.AdapterUtil;
import org.eclipse.bpmn2.modeler.core.adapters.ExtendedPropertiesAdapter;
import org.eclipse.bpmn2.modeler.core.adapters.FeatureDescriptor;
import org.eclipse.bpmn2.modeler.core.features.ContextConstants;
import org.eclipse.bpmn2.modeler.core.model.Bpmn2ModelerFactory;
import org.eclipse.bpmn2.modeler.core.preferences.ModelEnablements;
import org.eclipse.bpmn2.modeler.core.utils.AnchorUtil;
import org.eclipse.bpmn2.modeler.core.utils.BusinessObjectUtil;
import org.eclipse.bpmn2.modeler.core.utils.GraphicsUtil;
import org.eclipse.bpmn2.modeler.core.utils.ModelUtil;
import org.eclipse.bpmn2.modeler.ui.features.flow.DataAssociationFeatureContainer;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.IDeleteFeature;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IReconnectionFeature;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.context.impl.DeleteContext;
import org.eclipse.graphiti.features.context.impl.ReconnectionContext;
import org.eclipse.graphiti.mm.algorithms.styles.Point;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.ui.editor.DiagramEditor;

/**
 * @author Bob Brodt
 *
 */
public class DataAssociationPropertiesAdapter extends ExtendedPropertiesAdapter<DataAssociation> {

	/**
	 * @param adapterFactory
	 * @param object
	 */
	public DataAssociationPropertiesAdapter(AdapterFactory adapterFactory, DataAssociation object) {
		super(adapterFactory, object);

    	EStructuralFeature ref;
    	
    	ref = Bpmn2Package.eINSTANCE.getDataAssociation_SourceRef();
    	setFeatureDescriptor(ref, new SourceTargetFeatureDescriptor(adapterFactory,object,ref));
		setProperty(ref, UI_CAN_EDIT_INLINE, Boolean.FALSE);
		setProperty(ref, UI_CAN_EDIT, Boolean.FALSE);
		setProperty(ref, UI_CAN_CREATE_NEW, Boolean.FALSE);
		setProperty(ref, UI_IS_MULTI_CHOICE, Boolean.TRUE);

		ref = Bpmn2Package.eINSTANCE.getDataAssociation_TargetRef();
    	setFeatureDescriptor(ref, new SourceTargetFeatureDescriptor(adapterFactory,object,ref));
		setProperty(ref, UI_CAN_EDIT_INLINE, Boolean.FALSE);
		setProperty(ref, UI_CAN_EDIT, Boolean.FALSE);
		setProperty(ref, UI_CAN_CREATE_NEW, Boolean.FALSE);
		setProperty(ref, UI_IS_MULTI_CHOICE, Boolean.TRUE);
	}

	public class SourceTargetFeatureDescriptor extends FeatureDescriptor<DataAssociation> {

		public SourceTargetFeatureDescriptor(AdapterFactory adapterFactory, DataAssociation object, EStructuralFeature feature) {
			super(adapterFactory, object, feature);
		}
		
		@Override
		public String getLabel(Object context) {
			Object object = adopt(context);
			if (object instanceof DataInputAssociation)
				return Messages.DataAssociationPropertiesAdapter_Source;
			return Messages.DataAssociationPropertiesAdapter_Target;
		}

		@Override
		public Hashtable<String, Object> getChoiceOfValues(Object context) {
			List<EObject> values = new ArrayList<EObject>();
			// search for all Properties and DataStores
			// Properties are contained in the nearest enclosing Process or Event;
			// DataStores are contained in the DocumentRoot
			DataAssociation association = adopt(context);
			EObject container = ModelUtil.getContainer(association);
			values.addAll( ModelUtil.collectAncestorObjects(container, "properties", new Class[] {Activity.class}) ); //$NON-NLS-1$
			values.addAll( ModelUtil.collectAncestorObjects(container, "properties", new Class[] {Process.class}) ); //$NON-NLS-1$
			values.addAll( ModelUtil.collectAncestorObjects(container, "properties", new Class[] {Event.class}) ); //$NON-NLS-1$
			values.addAll( ModelUtil.collectAncestorObjects(container, "dataStore", new Class[] {DocumentRoot.class}) ); //$NON-NLS-1$
			values.addAll( ModelUtil.collectAncestorObjects(container, "flowElements", new Class[] {FlowElementsContainer.class}, new Class[] {ItemAwareElement.class})); //$NON-NLS-1$
			
			Activity activity = (Activity)ModelUtil.findNearestAncestor(container, new Class[] {Activity.class});
			if (activity!=null) {
				InputOutputSpecification ioSpec = activity.getIoSpecification();
				if (ioSpec!=null) {
					if (association instanceof DataInputAssociation)
						values.addAll(ioSpec.getDataInputs());
					else
						values.addAll(ioSpec.getDataOutputs());
				}
			}
			
			CallableElement callable = (CallableElement)ModelUtil.findNearestAncestor(container, new Class[] {CallableElement.class});
			if (callable!=null) {
				InputOutputSpecification ioSpec = callable.getIoSpecification();
				if (ioSpec!=null) {
					if (association instanceof DataInputAssociation)
						values.addAll(ioSpec.getDataInputs());
					else
						values.addAll(ioSpec.getDataOutputs());
				}
			}
			
			super.setChoiceOfValues(values);
			return super.getChoiceOfValues(context);
		}
		
		@Override
		public EObject createFeature(Resource resource, Object context, EClass eClass) {
			DataAssociation association = adopt(context);
			// what kind of object should we create? Property or DataStore?
			if (eClass==null) {
				if (ModelUtil.findNearestAncestor(association, new Class[] {Process.class, Event.class}) != null)
					// nearest ancestor is a Process or Event, so new object will be a Property
					eClass = Bpmn2Package.eINSTANCE.getProperty();
				else if(ModelUtil.findNearestAncestor(association, new Class[] {DocumentRoot.class}) != null)
					eClass = Bpmn2Package.eINSTANCE.getDataStore();
			}			
			if (eClass!=null) {
				return Bpmn2ModelerFactory.create(resource, eClass);
			}
			return null;
		}
		
		@SuppressWarnings("unchecked")
		@Override
		public void setValue(Object context, Object value) {
			final DataAssociation association = adopt(context);

			EObject container = null;
			EStructuralFeature containerFeature = null;
			if (value instanceof Property) {
				if (((Property)value).eContainer()==null) {
					// this Property isn't owned by anything yet - figure out who the owner is
					container = ModelUtil.findNearestAncestor(association, new Class[] {Activity.class});
					if (container==null)
						container = ModelUtil.findNearestAncestor(association, new Class[] {Event.class});
					if (container==null)
						container = ModelUtil.findNearestAncestor(association, new Class[] {Process.class});
					containerFeature = container.eClass().getEStructuralFeature("properties"); //$NON-NLS-1$
				}
			}
			else if (value instanceof DataStore) {
				if (((DataStore)value).eContainer()==null) {
					// this DataStore isn't owned by anything yet - figure out who the owner is
					container = ModelUtil.findNearestAncestor(association, new Class[] {DocumentRoot.class});
					containerFeature = container.eClass().getEStructuralFeature("dataStore"); //$NON-NLS-1$
				}
			}
			else if (value instanceof String) {
				// first check if a property with this name already exists
				Hashtable<String, Object> choices = getChoiceOfValues(object);
				Property property = (Property)choices.get(value);
				if (property==null) {
					// need to create a new one!
					DiagramEditor editor = ModelUtil.getEditor(object);
					ModelEnablements modelEnablement =
							(ModelEnablements)editor.getAdapter(ModelEnablements.class);
					// find nearest element that can contain a Property and create one
					container = association;
					for (;;) {
						container = ModelUtil.findNearestAncestor(container, new Class[] {Activity.class, Event.class, Process.class});
						if (container==null)
							return;
						containerFeature = container.eClass().getEStructuralFeature("properties"); //$NON-NLS-1$
						if (modelEnablement.isEnabled(container.eClass(), containerFeature))
							break;
					}
						
					containerFeature = container.eClass().getEStructuralFeature("properties"); //$NON-NLS-1$
					property = Bpmn2ModelerFactory.create(Property.class);
					ExtendedPropertiesAdapter adapter = ExtendedPropertiesAdapter.adapt(property);
					adapter.getObjectDescriptor().setDisplayName((String)value);
				}
				value = property;
			}

			final EObject c = container;
			final EStructuralFeature cf = containerFeature;
			final ItemAwareElement v = (ItemAwareElement)value;
			
			TransactionalEditingDomain editingDomain = getEditingDomain(association);
			if (feature == Bpmn2Package.eINSTANCE.getDataAssociation_SourceRef()) {
				if (editingDomain == null) {
					setSourceRef(association, v, c, cf);
				} else {
					editingDomain.getCommandStack().execute(new RecordingCommand(editingDomain) {
						@Override
						protected void doExecute() {
							setSourceRef(association, v, c, cf);
						}
					});
				}
			}
			else {
				if (editingDomain == null) {
					setTargetRef(association, v, c, cf);
				} else {
					editingDomain.getCommandStack().execute(new RecordingCommand(editingDomain) {
						@Override
						protected void doExecute() {
							setTargetRef(association, v, c, cf);
						}
					});
				}
			}
		}

		@SuppressWarnings({ "unchecked", "rawtypes" })
		private void setSourceRef(DataAssociation association, ItemAwareElement value, EObject container, EStructuralFeature containerFeature) {
			if (association.getSourceRef().size()==0) {
				if (container!=null) {
					if (containerFeature.isMany())
						((List)container.eGet(containerFeature)).add(value);
					else
						container.eSet(containerFeature, value);
				}
				association.getSourceRef().add(value);
			}
			else {
				if (container!=null) {
					if (containerFeature.isMany())
						((List)container.eGet(containerFeature)).add(value);
					else
						container.eSet(containerFeature, value);
				}
				updateConnectionIfNeeded(association, value);
				association.getSourceRef().set(0,value);
			}
			if (association.getTargetRef()!=null) {
				ItemAwareElement targetRef = association.getTargetRef();
				if (value!=null)
					targetRef.setItemSubjectRef(value.getItemSubjectRef());
				else
					targetRef.setItemSubjectRef(null);
			}
		}
		
		@SuppressWarnings({ "unchecked", "rawtypes" })
		private void setTargetRef(DataAssociation association, ItemAwareElement value, EObject container, EStructuralFeature containerFeature) {
			if (container!=null) {
				if (containerFeature.isMany())
					((List)container.eGet(containerFeature)).add(value);
				else
					container.eSet(containerFeature, value);
			}
			updateConnectionIfNeeded(association, value);
			association.setTargetRef(value);
			if (!association.getSourceRef().isEmpty()) {
				ItemAwareElement sourceRef = association.getSourceRef().get(0);
				if (value!=null)
					sourceRef.setItemSubjectRef(value.getItemSubjectRef());
				else
					sourceRef.setItemSubjectRef(null);
			}
		}

		private void updateConnectionIfNeeded(DataAssociation association, ItemAwareElement value) {
			DiagramEditor diagramEditor = ModelUtil.getDiagramEditor(association);
			Diagram diagram = diagramEditor.getDiagramTypeProvider().getDiagram();
			IFeatureProvider fp = diagramEditor.getDiagramTypeProvider().getFeatureProvider();
			Shape owner = null;
			EObject container = association.eContainer();
			if (container instanceof Activity || container instanceof Event) {
				for (PictogramElement pe : Graphiti.getLinkService().getPictogramElements(diagram, container)) {
					if (pe instanceof Shape && BusinessObjectUtil.getFirstElementOfType(pe, BPMNShape.class)!=null)
						owner = (Shape) pe;
				}
			}
			
			PictogramElement pe = null;
			if (value instanceof DataObject ||
					value instanceof DataObjectReference ||
					value instanceof DataStore ||
					value instanceof DataStoreReference ||
					value instanceof DataInput ||
					value instanceof DataOutput) {
				List<PictogramElement> pes = Graphiti.getLinkService().getPictogramElements(diagram, (EObject)value);
				for (PictogramElement p : pes) {
					if (BusinessObjectUtil.getFirstElementOfType(p, BPMNShape.class)!=null) {
						pe = p;
						break;
					}
				}
			}

			Connection connection = DataAssociationFeatureContainer.findDataAssociation(diagram, association);
			if (connection!=null) {
				// There's an existing DataAssociation connection which needs to
				// either be reconnected or deleted, depending on what the combobox
				// selection is.
				if (pe!=null) {
					// need to reconnect the DataAssociation
					ReconnectionContext rc = null;
					if (association instanceof DataOutputAssociation) {
						Point p = GraphicsUtil.createPoint(connection.getStart());
						Anchor a = AnchorUtil.findNearestAnchor((AnchorContainer) pe, p);
						rc = new ReconnectionContext(connection, connection.getStart(), a, null);
						rc.setTargetPictogramElement(pe);
						rc.setTargetLocation(Graphiti.getPeService().getLocationRelativeToDiagram(a));
						rc.setReconnectType(ReconnectionContext.RECONNECT_TARGET);
					}
					else {
						Point p = GraphicsUtil.createPoint(connection.getEnd());
						Anchor a = AnchorUtil.findNearestAnchor(owner, p);
						rc = new ReconnectionContext(connection, a, connection.getEnd(), null);
						rc.setTargetPictogramElement(pe);
						rc.setTargetLocation(Graphiti.getPeService().getLocationRelativeToDiagram(a));
						rc.setReconnectType(ReconnectionContext.RECONNECT_SOURCE);
					}
					IReconnectionFeature rf = fp.getReconnectionFeature(rc);
					if (rf.canReconnect(rc)) {
						rf.reconnect(rc);
					}
				}
				else {
					// need to delete the DataAssociation connection
					DeleteContext dc = new DeleteContext(connection);
					connection.getLink().getBusinessObjects().remove(0);
					IDeleteFeature df = fp.getDeleteFeature(dc);
					df.delete(dc);
				}
			}
			else if (pe!=null){
				// There is no existing DataAssociation connection, but the newly selected source or target
				// is some kind of data object shape, so we need to create a connection between the Activity
				// (or Throw/Catch Event) that owns the DataAssociation, and the new data object shape.
				Point p = GraphicsUtil.createPoint((AnchorContainer) pe);
				Anchor ownerAnchor = AnchorUtil.findNearestAnchor(owner, p);
				p = GraphicsUtil.createPoint(owner);
				Anchor peAnchor = AnchorUtil.findNearestAnchor((AnchorContainer) pe, p);
				AddConnectionContext ac = null;
				if (association instanceof DataOutputAssociation) {
					ac = new AddConnectionContext(ownerAnchor, peAnchor);
				}
				else {
					ac = new AddConnectionContext(peAnchor, ownerAnchor);
				}
				ac.putProperty(ContextConstants.BUSINESS_OBJECT, association);
				ac.setNewObject(association);
				IAddFeature af = fp.getAddFeature(ac);
				if (af.canAdd(ac)) {
					af.add(ac);
				}
			}
		}
	}
}