/* $Id: CollaborationsFactoryMDRImpl.java 18765 2010-09-18 23:15:32Z tfmorris $

  *****************************************************************************

  * Copyright (c) 2009,2010 Contributors - see below

  * 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:

  *    bobtarling

  *    Tom Morris

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 1996-2007 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies.  This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason.  IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.model.mdr;

 import java.util.Collection;

 import java.util.Iterator;

 import javax.jmi.reflect.InvalidObjectException;

 import org.argouml.model.CollaborationsFactory;

 import org.argouml.model.InvalidElementException;

 import org.argouml.model.Model;

 import org.omg.uml.behavioralelements.collaborations.AssociationEndRole;

 import org.omg.uml.behavioralelements.collaborations.AssociationRole;

 import org.omg.uml.behavioralelements.collaborations.ClassifierRole;

 import org.omg.uml.behavioralelements.collaborations.Collaboration;

 import org.omg.uml.behavioralelements.collaborations.CollaborationInstanceSet;

 import org.omg.uml.behavioralelements.collaborations.CollaborationsPackage;

 import org.omg.uml.behavioralelements.collaborations.Interaction;

 import org.omg.uml.behavioralelements.collaborations.InteractionInstanceSet;

 import org.omg.uml.behavioralelements.collaborations.Message;

 import org.omg.uml.behavioralelements.commonbehavior.Link;

 import org.omg.uml.foundation.core.Classifier;

 import org.omg.uml.foundation.core.Namespace;

 import org.omg.uml.foundation.core.Operation;

 import org.omg.uml.foundation.datatypes.AggregationKind;

 import org.omg.uml.foundation.datatypes.AggregationKindEnum;

 /**

  * Factory to create UML classes for the UML BehaviorialElements::Collaborations

  * package.<p>

  *

  * @since ARGO0.19.5

  * @author Ludovic Maître

  * @author Tom Morris

  * @author Thierry Lach (did derivation from NSUML implementation)

  */

 class CollaborationsFactoryMDRImpl extends AbstractUmlModelFactoryMDR

         implements CollaborationsFactory {

     /**

      * The model implementation.

      */

     private MDRModelImplementation modelImpl;

     /**

      * Don't allow instantiation.

      *

      * @param implementation

      *            To get other helpers and factories.

      */

     CollaborationsFactoryMDRImpl(MDRModelImplementation implementation) {

         modelImpl = implementation;

     }

     public AssociationEndRole createAssociationEndRole() {

         AssociationEndRole myAssociationEndRole =

             getCollabPkg().getAssociationEndRole().createAssociationEndRole();

         super.initialize(myAssociationEndRole);

         return myAssociationEndRole;

     }

     private CollaborationsPackage getCollabPkg() {

         return modelImpl.getUmlPackage().getCollaborations();

     }

     public AssociationRole createAssociationRole() {

         AssociationRole myAssociationRole =

             getCollabPkg().getAssociationRole().createAssociationRole();

         super.initialize(myAssociationRole);

         return myAssociationRole;

     }

     public ClassifierRole createClassifierRole() {

         ClassifierRole myClassifierRole =

             getCollabPkg().getClassifierRole().createClassifierRole();

         super.initialize(myClassifierRole);

         return myClassifierRole;

     }

     public Collaboration createCollaboration() {

         Collaboration myCollaboration =

             getCollabPkg().getCollaboration().createCollaboration();

         super.initialize(myCollaboration);

         return myCollaboration;

     }

     public CollaborationInstanceSet createCollaborationInstanceSet() {

         CollaborationInstanceSet obj =

             getCollabPkg().getCollaborationInstanceSet()

                 .createCollaborationInstanceSet();

         super.initialize(obj);

         return obj;

     }

     public Interaction createInteraction() {

         Interaction myInteraction =

             getCollabPkg().getInteraction().createInteraction();

         super.initialize(myInteraction);

         return myInteraction;

     }

     public InteractionInstanceSet createInteractionInstanceSet() {

         InteractionInstanceSet obj =

             getCollabPkg().getInteractionInstanceSet()

                 .createInteractionInstanceSet();

         super.initialize(obj);

         return obj;

     }

     public Message createMessage() {

         Message myMessage =

             getCollabPkg().getMessage().createMessage();

         super.initialize(myMessage);

         return myMessage;

     }

     public ClassifierRole buildClassifierRole(Object collaboration) {

         Collaboration myCollaboration = (Collaboration) collaboration;

         ClassifierRole classifierRole = createClassifierRole();

         classifierRole.setNamespace(myCollaboration);

         modelImpl.getCoreHelper().setMultiplicity(classifierRole, 1, 1);

         return classifierRole;

     }

     public Object buildCollaboration(Object handle) {

         Namespace namespace = (Namespace) handle;

         Collaboration modelelement = createCollaboration();

         modelelement.setNamespace(namespace);

         modelelement.setName("newCollaboration");

         modelelement.setAbstract(false);

         return modelelement;

     }

     public Object buildCollaboration(Object namespace,

             Object representedElement) {

         if (!(namespace instanceof Namespace)) {

             throw new IllegalArgumentException("Argument is not "

                     + "a namespace");

         }

         if (representedElement instanceof Classifier

                 || representedElement instanceof Operation) {

             Collaboration collaboration =

                 (Collaboration) buildCollaboration(namespace);

             if (representedElement instanceof Classifier) {

                 collaboration.

                 setRepresentedClassifier((Classifier) representedElement);

                 return collaboration;

             }

             if (representedElement instanceof Operation) {

                 collaboration.

                 setRepresentedOperation((Operation) representedElement);

                 return collaboration;

             }

         }

         throw new IllegalArgumentException("Represented element must be"

                 + " Collaboration or Operation");

     }

     public Interaction buildInteraction(Object handle) {

         Collaboration collab = (Collaboration) handle;

         Interaction inter = createInteraction();

         inter.setContext(collab);

         inter.setName("newInteraction");

         return inter;

     }

     public AssociationEndRole buildAssociationEndRole(Object atype) {

         ClassifierRole type = (ClassifierRole) atype;

         AssociationEndRole end = createAssociationEndRole();

         end.setParticipant(type);

         return end;

     }

     public AssociationRole buildAssociationRole(Object from, Object to) {

         return buildAssociationRole((ClassifierRole) from, (ClassifierRole) to);

     }

     /**

      * Internal type-checked version of buildAssociationRole.

      */

     private AssociationRole buildAssociationRole(ClassifierRole from,

             ClassifierRole to) {

         Collaboration collaboration = (Collaboration) from.getNamespace();

         if (collaboration == null 

                 || !collaboration.equals(to.getNamespace())) {

             throw new IllegalArgumentException("ClassifierRoles must be in"

                     + " same non-null namespace");

         }

         AssociationRole role = createAssociationRole();

         role.setNamespace(collaboration);

         // The 4-arg version of this method depends on this ordering.

         // Don't change it!

         role.getConnection().add(buildAssociationEndRole(from));

         role.getConnection().add(buildAssociationEndRole(to));

         return role;

     }

     @Deprecated

     public AssociationRole buildAssociationRole(Object from, Object agg1, Object to,

             Object agg2, Boolean unidirectional) {

         if (unidirectional == null) {

             return buildAssociationRole(from, agg1, to, agg2, false);

         } else {

             return buildAssociationRole(from, agg1, to, agg2, 

                     unidirectional.booleanValue());

         }

     }

     public AssociationRole buildAssociationRole(Object from, Object agg1,

             Object to, Object agg2, boolean unidirectional) {

         AggregationKind ak1 = checkAggregationKind(agg1);

         AggregationKind ak2 = checkAggregationKind(agg2);

         AssociationRole role = buildAssociationRole((ClassifierRole) from, 

                 (ClassifierRole) to);

         AssociationEndRole end =

                 (AssociationEndRole) role.getConnection().get(0);

         end.setAggregation(ak1);

         end.setNavigable(!unidirectional);

         end = (AssociationEndRole) role.getConnection().get(1);

         end.setAggregation(ak2);

         end.setNavigable(true); // probably redundant - just in case

         return role;

     }

     /**

      * Checks that aggregationKind is valid and promotes null

      * to AK_NONE.

      * @param aggregationKind Candidate AggregationKind or null

      * @return valid checked AggregationKind

      */

     private AggregationKind checkAggregationKind(Object aggregationKind) {

         if (aggregationKind == null) {

             aggregationKind = AggregationKindEnum.AK_NONE;

         }

         return (AggregationKind) aggregationKind;

     }

     public AssociationRole buildAssociationRole(Object link) {

         if (!(link instanceof Link)) {

             throw new IllegalArgumentException("Argument is not a link");

         }

         Object from = modelImpl.getCoreHelper().getSource(link);

         Object to = modelImpl.getCoreHelper().getDestination(link);

         Object classifierRoleFrom =

             modelImpl.getFacade().getClassifiers(from).iterator().next();

         Object classifierRoleTo =

             modelImpl.getFacade().getClassifiers(to).iterator().next();

         Object collaboration =

             modelImpl.getFacade().getNamespace(classifierRoleFrom);

         if (collaboration != modelImpl.getFacade().getNamespace(

                 classifierRoleTo)) {

             throw new IllegalStateException("ClassifierRoles do not belong "

                     + "to the same collaboration");

         }

         if (collaboration == null) {

             throw new IllegalStateException("Collaboration may not be "

                     + "null");

         }

         AssociationRole associationRole = createAssociationRole();

         modelImpl.getCoreHelper().setNamespace(associationRole, collaboration);

         modelImpl.getCoreHelper().addLink(associationRole, link);

         return associationRole;

     }

     /**

      * Builds a message within some interaction related to some assocationrole.

      * The message is added as the last in the interaction sequence.

      * Furthermore, the message is added as the last to the list of messages

      * already attached to the role. Effectively, the already attached messages

      * become predecessors of this message.

      * TODO: This sets the activator as a side effect. However it is impossible

      * to determine the activator at this stage as we don't yet know what the

      * action will be of the message we're creating. See issue 5692.

      *

      * @param inter

      *            The Interaction.

      * @param role

      *            The Association Role.

      * @return The newly created Message.

      */

     private Message buildMessageInteraction(Interaction inter,

             AssociationRole role) {

         assert inter != null : "An interaction must be provided";

         assert role != null : "An association role must be provided";

         Message message = createMessage();

         inter.getMessage().add(message);

         message.setCommunicationConnection(role);

         if (role.getConnection().size() == 2) {

             message.setSender((ClassifierRole) role.getConnection().get(0)

                     .getParticipant());

             message.setReceiver((ClassifierRole) role.getConnection().get(1)

                     .getParticipant());

             Collection<Message> messages =

                 Model.getFacade().getReceivedMessages(message.getSender());

             Message lastMsg = lastMessage(messages, message);

             if (lastMsg != null) {

                 message.setActivator(lastMsg);

                 messages = Model.getFacade().getActivatedMessages(lastMsg);

             } else {

                 messages = Model.getFacade().getSentMessages(

                         message.getSender());

             }

             lastMsg = lastMessage(messages, message);

             if (lastMsg != null) {

                 message.getPredecessor().add(findEnd(lastMsg));

             }

         }

         return message;

     }

     /**

      * Finds the last message in the collection not equal to null and not equal

      * to m.

      *

      * @param c

      *            A collection containing exclusively Messages.

      * @param m

      *            A Message.

      * @return The last message in the collection, or null.

      */

     private Message lastMessage(Collection<Message> c, Message m) {

         Message last = null;

         for (Message msg : c) {

             if (msg != null && msg != m) {

                 last = msg;

             }

         }

         return last;

     }

     /**

      * Walks the tree of successors to m rooted until a leaf is found. The leaf

      * is the returned. If m is itself a leaf, then m is returned.

      *

      * @param m A Message.

      * @return The last message in one branch of the tree rooted at m.

      */

     private Message findEnd(Message m) {

         while (true) {

             Collection<Message> c = Model.getFacade().getSuccessors(m);

             Iterator<Message> it = c.iterator();

             if (!it.hasNext()) {

                 return m;

             }

             m = it.next();

         }

     }

     public Message buildMessage(Object acollab, Object arole) {

         if (!(arole instanceof AssociationRole)) {

             throw new IllegalArgumentException(

                     "An association role must be supplied - got " + arole);

         }

         try {

             if (acollab instanceof Collaboration) {

                 return buildMessageCollab((Collaboration) acollab,

                         (AssociationRole) arole);

             }

             if (acollab instanceof Interaction) {

                 return buildMessageInteraction((Interaction) acollab,

                         (AssociationRole) arole);

             }

             throw new IllegalArgumentException("No valid object " + acollab);

         } catch (InvalidObjectException e) {

             throw new InvalidElementException(e);

         }

     }

     private Message buildMessageCollab(Collaboration collab,

             AssociationRole role) {

         Interaction inter = null;

         if (collab.getInteraction().size() == 0) {

             inter = buildInteraction(collab);

         } else {

             inter = (Interaction) (collab.getInteraction().toArray())[0];

         }

         return buildMessageInteraction(inter, role);

     }

     public Message buildActivator(Object owner, Object interaction) {

         Message theOwner = (Message) owner;

         Interaction theInteraction;

         if (interaction == null) {

             theInteraction = theOwner.getInteraction();

         } else {

             theInteraction = (Interaction) interaction;

         }

         if (interaction == null) {

             throw new IllegalArgumentException();

         }

         Message activator = createMessage();

         activator.setInteraction(theInteraction);

         theOwner.setActivator(activator);

         return activator;

     }

     /**

      * @param elem

      *            the associationendrole

      */

     void deleteAssociationEndRole(Object elem) {

         if (!(elem instanceof AssociationEndRole)) {

             throw new IllegalArgumentException();

         }

     }

     /**

      * @param elem

      *            the associationrole

      */

     void deleteAssociationRole(Object elem) {

         AssociationRole role = (AssociationRole) elem;

         for (Message message : role.getMessage()) {

             modelImpl.getUmlFactory().delete(message);

         }

     }

     /**

      * @param elem

      *            the UML element to be deleted

      */

     void deleteClassifierRole(Object elem) {

         ClassifierRole cr = (ClassifierRole) elem;

         // delete Messages which have this as sender or receiver

         CollaborationsPackage cPkg = ((org.omg.uml.UmlPackage) cr

                 .refOutermostPackage()).getCollaborations();

         modelImpl.getUmlHelper().deleteCollection(

                 cPkg.getAMessageSender().getMessage(cr));

         modelImpl.getUmlHelper().deleteCollection(

                 cPkg.getAReceiverMessage().getMessage(cr));

         // TODO: delete Collaborations where this is the last ClassifierRole?

 //        Object owner = cr.refImmediateComposite();

 //        if (owner instanceof Collaboration) {

 //            Collection ownedElements = ((Collaboration) owner)

 //                    .getOwnedElement();

 //            if (ownedElements.size() == 1 && ownedElements.contains(cr))

 //                nsmodel.getUmlFactory().delete(owner);

 //        }

     }

     /**

      * @param elem

      *            the UML element to be delete

      */

     void deleteCollaboration(Object elem) {

         if (!(elem instanceof Collaboration)) {

             throw new IllegalArgumentException();

         }

     }

     /**

      * @param elem

      *            the UML element to be delete

      */

     void deleteCollaborationInstanceSet(Object elem) {

         if (!(elem instanceof CollaborationInstanceSet)) {

             throw new IllegalArgumentException();

         }

         // InteractionInstanceSets will get deleted automatically

         // because they are associated by composition

     }

     /**

      * @param elem

      *            the UML element to be delete

      */

     void deleteInteraction(Object elem) {

         if (!(elem instanceof Interaction)) {

             throw new IllegalArgumentException();

         }

     }

     /**

      * @param elem

      *            the UML element to be delete

      */

     void deleteInteractionInstanceSet(Object elem) {

         if (!(elem instanceof InteractionInstanceSet)) {

             throw new IllegalArgumentException();

         }

     }

     /**

      * @param elem

      *            the UML element to be delete

      */

     void deleteMessage(Object elem) {

         Message message = (Message) elem;

         // If this is the only message contained in the Interaction

         // we delete the Interaction

         Interaction i = message.getInteraction();

         if (i != null && i.getMessage().size() == 1) {

             modelImpl.getUmlFactory().delete(i);

         }

     }

 }