package org.andromda.metafacades.uml14;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.LinkedHashMap;
   import java.util.List;
   import java.util.Map;
   import org.andromda.core.common.ExceptionUtils;
  import org.andromda.core.metafacade.MetafacadeConstants;
  import org.andromda.core.metafacade.MetafacadeFactory;
  import org.andromda.metafacades.uml.ActivityGraphFacade;
  import org.andromda.metafacades.uml.ClassifierFacade;
  import org.andromda.metafacades.uml.EventFacade;
  import org.andromda.metafacades.uml.MetafacadeUtils;
  import org.andromda.metafacades.uml.ModelElementFacade;
  import org.andromda.metafacades.uml.ParameterFacade;
  import org.andromda.metafacades.uml.UMLProfile;
  import org.andromda.metafacades.uml.UseCaseFacade;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.Predicate;
  import org.apache.commons.lang.StringUtils;
  import org.omg.uml.behavioralelements.activitygraphs.ActivityGraph;
  import org.omg.uml.behavioralelements.statemachines.Event;
  import org.omg.uml.behavioralelements.statemachines.FinalState;
  import org.omg.uml.behavioralelements.usecases.UseCase;
  import org.omg.uml.foundation.core.Attribute;
  import org.omg.uml.foundation.core.Classifier;
  import org.omg.uml.foundation.core.CorePackage;
  import org.omg.uml.foundation.core.ModelElement;
  import org.omg.uml.foundation.core.Parameter;
  import org.omg.uml.foundation.core.Stereotype;
  import org.omg.uml.foundation.core.TaggedValue;
  import org.omg.uml.foundation.core.UmlClass;
  import org.omg.uml.foundation.datatypes.VisibilityKind;
  import org.omg.uml.foundation.datatypes.VisibilityKindEnum;
  import org.omg.uml.modelmanagement.Model;
  import org.omg.uml.modelmanagement.UmlPackage;
  
  /**
   * Utilities for dealing with UML 1.4 metafacades
   *
   * @author Chad Brandon
   * @author Bob Fields
   */
  public class UML14MetafacadeUtils
  {
      /**
       * Finds a given model element in the model having the specified
       * <code>fullyQualifiedName</code>. If the model element can <strong>NOT
       * </strong> be found, <code>null</code> will be returned instead.
       *
       * @param fullyQualifiedName the fully qualified name of the element to
       *        search for.
       * @param separator the PSM separator used for qualifying the name (example
       *        ".").
       * @param modelName a flag indicating whether or not a search shall be performed using
       *        the fully qualified model name or fully qualified PSM name.
       * @return the found model element
       */
      static Object findByFullyQualifiedName(final String fullyQualifiedName, final String separator, final boolean modelName)
      {
          Object modelElement;
          Collection elements = ((org.omg.uml.UmlPackage)MetafacadeFactory.getInstance().getModel().getModel()).getCore()
                  .getModelElement()
                  .refAllOfType();
          modelElement = CollectionUtils.find(elements, new Predicate()
          {
              public boolean evaluate(Object object)
              {
                  ModelElement element = (ModelElement)object;
                  StringBuilder fullName = new StringBuilder(getPackageName(element, separator, modelName));
                  String name = element.getName();
                  if (StringUtils.isNotBlank(name))
                  {
                      String namespaceSeparator = MetafacadeConstants.NAMESPACE_SCOPE_OPERATOR;
                      if (!modelName)
                      {
                          namespaceSeparator = separator;
                      }
                      fullName.append(namespaceSeparator);
                      fullName.append(name);
                  }
                  return fullName.toString().equals(fullyQualifiedName);
              }
          });
          return modelElement;
      }
  
      private static String empty = "";
      /**
       * Constructs the package name for the given <code>metaObject</code>, separating the package name by the given
       * <code>separator</code>.
       *
       * @param metaObject the Model Element
       * @param separator the PSM namespace separator
       * @param modelName true/false on whether or not to get the model package name instead
       *        of the PSM package name.
       * @return the package name.
      */
     static String getPackageName(ModelElement metaObject, String separator, boolean modelName)
     {
         String packageName = empty;
         for (ModelElement namespace = metaObject.getNamespace(); (namespace instanceof UmlPackage) &&
                 !(namespace instanceof Model); namespace = namespace.getNamespace())
         {
             packageName = packageName.equals(empty) ? namespace.getName() : namespace.getName() + separator + packageName;
         }
         if (modelName && StringUtils.isNotBlank(packageName))
         {
             packageName = StringUtils.replace(packageName, separator, MetafacadeConstants.NAMESPACE_SCOPE_OPERATOR);
         }
         return packageName;
     }
 
     /**
      * Basically just checks to make sure the <code>model</code> is of type <code>org.omg.uml.UmlPackage</code> and
      * retrieves the <code>CorePackage</code> from it.
      *
      * @return the <code>model</code> as a <code>org.omg.uml.UmlPackage</code>
      */
     static CorePackage getCorePackage()
     {
         return ((org.omg.uml.UmlPackage)MetafacadeFactory.getInstance().getModel().getModel()).getCore();
     }
 
     /**
      * Finds and returns the first model element having the given <code>name</code> in the <code>modelPackage</code>,
      * returns <code>null</code> if not found.
      *
      * @param name the name to find.
      * @return the found model element.
      */
     static Object findByName(final String name)
     {
         Object modelElement = null;
         if (StringUtils.isNotBlank(name))
         {
             modelElement = CollectionUtils.find(getModel().getCore().getModelElement().refAllOfType(), new Predicate()
             {
                 public boolean evaluate(Object object)
                 {
                     return StringUtils.trimToEmpty(((ModelElement)object).getName()).equals(name);
                 }
             });
         }
         return modelElement;
     }
 
     /**
      * Gets the root package in the model.
      *
      * @return the root package as a UmlPackage.
      */
     static UmlPackage getRootPackage()
     {
         Object result = null;
         Collection rootPackages = UML14MetafacadeUtils.getModel().getModelManagement().getModel().refAllOfType();
         for (Object rootPackage : rootPackages)
         {
             // get the first package that's a ModelElement instance
             // Note: UML2 allows top level ModelElement to be a Package.
             if (rootPackage instanceof ModelElement)
             {
                 result = rootPackage;
                 break;
             }
         }
         return (UmlPackage)result;
     }
 
     /**
      * Returns the entire model.
      *
      * @return org.omg.uml.UmlPackage model instance.
      */
     static org.omg.uml.UmlPackage getModel()
     {
         return (org.omg.uml.UmlPackage)MetafacadeFactory.getInstance().getModel().getModel();
     }
 
     /**
      * Gets the correct meta model visibility kind for the given <code>visibility</code> string.
      *
      * @param visibility the visibility to retrieve.
      * @return the VisibilityKind
      */
     static VisibilityKind getVisibilityKind(String visibility)
     {
         VisibilityKind visibilityKind = null;
         visibility = StringUtils.trimToEmpty(visibility);
         if ("public".equals(visibility))
         {
             visibilityKind = VisibilityKindEnum.VK_PUBLIC;
         }
         else if ("private".equals(visibility))
         {
             visibilityKind = VisibilityKindEnum.VK_PRIVATE;
         }
         else if (StringUtils.isEmpty(visibility))
         {
             visibilityKind = VisibilityKindEnum.VK_PACKAGE;
         }
         else if ("protected".equals(visibility))
         {
             visibilityKind = VisibilityKindEnum.VK_PROTECTED;
         }
         return visibilityKind;
     }
 
     /**
      * Creates an attribute having the give <code>name</code> and the type
      * having the given <code>fullyQualifiedTypeName</code>, with the
      * specified visibility, if no type can be found with the given name, no
      * type is set.
      *
      * @param name the new name
      * @param fullyQualifiedTypeName the name of the fully qualified type
      * @param visibility the visibility name
      * @param separator the separator used for qualifying the name.
      * @return the new Attribute.
      */
     static Attribute createAttribute(String name, String fullyQualifiedTypeName, String visibility, String separator)
     {
         Attribute attribute = UML14MetafacadeUtils.getCorePackage().getAttribute().createAttribute();
         attribute.setName(name);
         attribute.setVisibility(UML14MetafacadeUtils.getVisibilityKind(visibility));
         Object type = UML14MetafacadeUtils.findByFullyQualifiedName(fullyQualifiedTypeName, separator, false);
         if (type != null && Classifier.class.isAssignableFrom(type.getClass()))
         {
             attribute.setType((Classifier)type);
         }
         return attribute;
     }
 
     /**
      * Indicates whether or not the attribute exists on the given </code>classifier</code>.
      *
      * @param classifier the classifier to check
      * @param name the name of the attribute
      * @return true/false
      */
     static boolean attributeExists(Object classifier, String name)
     {
         boolean exists = false;
         if (Classifier.class.isAssignableFrom(classifier.getClass()))
         {
             List features = ((Classifier)classifier).getFeature();
             if (features != null && !features.isEmpty())
             {
                 for (final Iterator featureIterator = features.iterator(); featureIterator.hasNext();)
                 {
                     Object feature = featureIterator.next();
                     if (feature != null && Attribute.class.isAssignableFrom(feature.getClass()))
                     {
                         exists = StringUtils.trimToEmpty(((Attribute)feature).getName()).equals(name);
                         if(exists)
                         {
                             break;
                         }
                     }
                 }
             }
         }
         return exists;
     }
 
     /**
      * Finds or creates a stereotype with the given name. If the stereotype isn't found, it will be created.
      *
      * @param name the name of the stereotype.
      * @return the new Stereotype.
      */
     static Stereotype findOrCreateStereotype(String name)
     {
         Object stereotype = UML14MetafacadeUtils.findByName(name);
         if (stereotype == null || !Stereotype.class.isAssignableFrom(stereotype.getClass()))
         {
             stereotype = UML14MetafacadeUtils.getCorePackage().getStereotype().createStereotype();
             ((Stereotype)stereotype).setName(name);
         }
         return (Stereotype)stereotype;
     }
 
     /**
      * Returns the first use-case it can find with the given name.
      * @param name
      * @return findFirstUseCaseWithNameAndStereotype(name, null)
      */
     static UseCase findFirstUseCaseWithName(String name)
     {
         return findFirstUseCaseWithNameAndStereotype(name, null);
     }
 
     /**
      * Returns the first use-case it can find with the given name and stereotype, if the stereotype is not specified (it
      * is null) it will be ignored and the returned use-case may have any arbitrary stereotype.
      * @param name
      * @param stereotypeName
      * @return useCaseWithNameAndStereotype
      */
     static UseCase findFirstUseCaseWithNameAndStereotype(String name, String stereotypeName)
     {
         UseCase useCaseWithNameAndStereotype = null;
 
         Collection<UseCase> useCases = getModel().getUseCases().getUseCase().refAllOfType();
         for (final Iterator<UseCase> useCaseIterator = useCases.iterator(); useCaseIterator.hasNext() && useCaseWithNameAndStereotype ==
                 null;)
         {
             UseCase useCase = useCaseIterator.next();
             if (name.equals(useCase.getName()))
             {
                 if (stereotypeName == null || isStereotypePresent(useCase, stereotypeName))
                 {
                     useCaseWithNameAndStereotype = useCase;
                 }
             }
         }
 
         return useCaseWithNameAndStereotype;
     }
 
     /**
      * Returns the first activity graph it can find with the given name.
      * @param name
      * @return findFirstActivityGraphWithNameAndStereotype(name, null)
      */
     static ActivityGraph findFirstActivityGraphWithName(String name)
     {
         return findFirstActivityGraphWithNameAndStereotype(name, null);
     }
 
     /**
      * Returns the first activity graph it can find with the given name and stereotype, if the stereotype is not
      * specified (it is null) it will be ignored and the returned activity graph may have any arbitrary stereotype.
      * @param name
      * @param stereotypeName
      * @return graphWithNameAndStereotype
      */
     static ActivityGraph findFirstActivityGraphWithNameAndStereotype(String name, String stereotypeName)
     {
         ActivityGraph graphWithNameAndStereotype = null;
 
         Collection<ActivityGraph> graphs = getModel().getActivityGraphs().getActivityGraph().refAllOfType();
         for (final Iterator<ActivityGraph> graphIterator = graphs.iterator();
              graphIterator.hasNext() && graphWithNameAndStereotype == null;)
         {
             ActivityGraph graph = graphIterator.next();
             if (name.equals(graph.getName()))
             {
                 if (stereotypeName == null || isStereotypePresent(graph, stereotypeName))
                 {
                     graphWithNameAndStereotype = graph;
                 }
             }
         }
 
         return graphWithNameAndStereotype;
     }
 
     /**
      * Returns true if the given model element has a tag with the given name and value, returns false otherwise.
      * @param element
      * @param tag
      * @param value
      * @return tagPresent
      */
     static boolean isTagPresent(ModelElement element, String tag, Object value)
     {
         boolean tagPresent = false;
 
         Collection<TaggedValue> taggedValues = element.getTaggedValue();
         for (final Iterator<TaggedValue> taggedValueIterator = taggedValues.iterator(); taggedValueIterator.hasNext() && !tagPresent;)
         {
             TaggedValue taggedValue = taggedValueIterator.next();
             // does this name match the argument tagged value name ?
             // Check both the UML14 format name @andromda.value and EMF Format andromda_whatever
             String tagName = taggedValue.getName();
             if (tag.equals(tagName) || MetafacadeUtils.getEmfTaggedValue(tag).equals(tagName)
                 || MetafacadeUtils.getUml14TaggedValue(tag).equals(tagName))
             {
                 for (final Iterator valueIterator = taggedValue.getDataValue().iterator(); valueIterator.hasNext() &&
                         !tagPresent;)
                 {
                     Object dataValue = valueIterator.next();
                     if (value.equals(dataValue))
                     {
                         tagPresent = true;
                     }
                 }
                 for (final Iterator valueIterator = taggedValue.getReferenceValue().iterator(); valueIterator.hasNext() &&
                         !tagPresent;)
                 {
                     Object referenceValue = valueIterator.next();
                     if (value.equals(referenceValue))
                     {
                         tagPresent = true;
                     }
                 }
             }
         }
         return tagPresent;
     }
 
     /**
      * Returns true if the given model element has a hyperlink with the given value, returns false otherwise.
      * @param element
      * @param value
      * @return isTagPresent(element, "hyperlinkModel", value)
      */
     static boolean isHyperlinkPresent(ModelElement element, Object value)
     {
         return isTagPresent(element, "hyperlinkModel", value);
     }
 
     /**
      * @param element
      * @param stereotypeName
      * @return stereotypePresent
      */
     static boolean isStereotypePresent(ModelElement element, String stereotypeName)
     {
         boolean stereotypePresent = false;
 
         Collection<Stereotype> stereotypes = element.getStereotype();
         for (final Iterator<Stereotype> stereotypeIterator = stereotypes.iterator();
              stereotypeIterator.hasNext() && !stereotypePresent;)
         {
             Stereotype stereotype = stereotypeIterator.next();
             if (stereotypeName.equals(stereotype.getName()))
             {
                 stereotypePresent = true;
             }
         }
         return stereotypePresent;
     }
 
     /**
      * Returns the first use-case this method can find with the given tagged value or hyperlink. Both arguments are used
      * to look for the tagged value but only <code>value</code> is used to search for the hyperlink.
      * @param tag
      * @param value
      * @return useCaseWithTaggedValue
      */
     static UseCase findUseCaseWithTaggedValueOrHyperlink(String tag, String value)
     {
         UseCase useCaseWithTaggedValue = null;
 
         Collection<UseCase> useCases = getModel().getUseCases().getUseCase().refAllOfType();
         for (final Iterator<UseCase> useCaseIterator = useCases.iterator(); useCaseIterator.hasNext() && useCaseWithTaggedValue ==
                 null;)
         {
             // loop over all use-cases
             UseCase useCase = useCaseIterator.next();
             if (isTagPresent(useCase, tag, value) || isHyperlinkPresent(useCase, value))
             {
                 useCaseWithTaggedValue = useCase;
             }
         }
 
         return useCaseWithTaggedValue;
     }
 
     /**
      * Returns the first class this method can find with the given tagged value or hyperlink. Both arguments are used to
      * look for the tagged value but only <code>value</code> is used to search for the hyperlink.
      * @param tag
      * @param value
      * @return classWithTaggedValue
      */
     static UmlClass findClassWithTaggedValueOrHyperlink(String tag, String value)
     {
         UmlClass classWithTaggedValue = null;
 
         Collection<UmlClass> classes = getModel().getCore().getUmlClass().refAllOfType();
         for (final Iterator<UmlClass> classIterator = classes.iterator(); classIterator.hasNext() && classWithTaggedValue == null;)
         {
             // loop over all classes
             UmlClass clazz = classIterator.next();
             if (isTagPresent(clazz, tag, value) || isHyperlinkPresent(clazz, value))
             {
                 classWithTaggedValue = clazz;
             }
         }
 
         return classWithTaggedValue;
     }
 
     /**
      * @param useCase
      * @return finalStates
      */
     static Collection<FinalState> findFinalStatesWithNameOrHyperlink(UseCase useCase)
     {
         List finalStates = new ArrayList();
 
         if (useCase != null && useCase.getName() != null)
         {
             String useCaseName = useCase.getName();
             Collection<FinalState> allFinalStates = getModel().getStateMachines().getFinalState().refAllOfType();
             for (final Iterator<FinalState> iterator = allFinalStates.iterator(); iterator.hasNext();)
             {
                 FinalState finalState = iterator.next();
                 if (useCaseName != null)
                 {
                     if (useCaseName.equals(finalState.getName()))
                     {
                         finalStates.add(finalState);
                     }
                     else
                     {
                         if (isHyperlinkPresent(finalState, useCase))
                         {
                             finalStates.add(finalState);
                         }
                     }
                 }
                 else
                 {
                     if (isHyperlinkPresent(finalState, useCase))
                     {
                         finalStates.add(finalState);
                     }
                 }
             }
         }
 
         return finalStates;
     }
 
     /**
      * Finds the given metafacade class for the passed in <code>facade</code>.
      *
      * @param facade the model element facade for which to find the meta class.
      * @return the meta model element
      */
     static ActivityGraph getMetaClass(ActivityGraphFacade facade)
     {
         ActivityGraph activityGraph = null;
 
         if (facade != null)
         {
             String id = facade.getId();
             Collection<ModelElement> graphs = getModel().getActivityGraphs().getActivityGraph().refAllOfType();
             for (final Iterator<ModelElement> iterator = graphs.iterator(); iterator.hasNext() && activityGraph == null;)
             {
                 ModelElement element = iterator.next();
                 if (id.equals(element.refMofId()))
                 {
                     activityGraph = (ActivityGraph)element;
                 }
             }
         }
         return activityGraph;
     }
 
     /**
      * Finds the given metafacade class for the passed in <code>facade</code>.
      *
      * @param facade the model element facade for which to find the meta class.
      * @return the meta model element
      */
     static UseCase getMetaClass(UseCaseFacade facade)
     {
         UseCase useCase = null;
 
         if (facade != null)
         {
             String id = facade.getId();
             Collection<ModelElement> useCases = getModel().getUseCases().getUseCase().refAllOfType();
             for (final Iterator<ModelElement> iterator = useCases.iterator(); iterator.hasNext() && useCase == null;)
             {
                 ModelElement element = iterator.next();
                 if (id.equals(element.refMofId()))
                 {
                     useCase = (UseCase)element;
                 }
             }
         }
         return useCase;
     }
 
     /**
      * Finds the given metafacade class for the passed in <code>facade</code>.
      *
      * @param facade the model element facade for which to find the meta class.
      * @return the meta model element
      */
     static Parameter getMetaClass(ParameterFacade facade)
     {
         Parameter parameter = null;
 
         if (facade != null)
         {
             String id = facade.getId();
             Collection<ModelElement> parameters = getModel().getCore().getParameter().refAllOfType();
             for (final Iterator<ModelElement> iterator = parameters.iterator(); iterator.hasNext() && parameter == null;)
             {
                 ModelElement element = iterator.next();
                 if (id.equals(element.refMofId()))
                 {
                     parameter = (Parameter)element;
                 }
             }
         }
         return parameter;
     }
 
     /**
      * Finds the given metafacade class for the passed in <code>facade</code>.
      *
      * @param facade the model element facade for which to find the meta class.
      * @return the meta model element
      */
     static Event getMetaClass(EventFacade facade)
     {
         Event event = null;
 
         if (facade != null)
         {
             String id = facade.getId();
             Collection<ModelElement> events = getModel().getStateMachines().getEvent().refAllOfType();
             for (final Iterator<ModelElement> iterator = events.iterator(); iterator.hasNext() && event == null;)
             {
                 ModelElement element = iterator.next();
                 if (id.equals(element.refMofId()))
                 {
                     event = (Event)element;
                 }
             }
         }
         return event;
     }
 
     /**
      * Finds the given metafacade class for the passed in <code>facade</code>.
      *
      * @param facade the model element facade for which to find the meta class.
      * @return the meta model element
      */
     static ModelElement getMetaClass(ModelElementFacade facade)
     {
         ModelElement modelElement = null;
 
         if (facade != null)
         {
             String id = facade.getId();
             Collection<ModelElement> modelElements = getModel().getCore().getModelElement().refAllOfType();
             for (final Iterator<ModelElement> iterator = modelElements.iterator(); iterator.hasNext() && modelElement == null;)
             {
                 ModelElement element = iterator.next();
                 if (id.equals(element.refMofId()))
                 {
                     modelElement = element;
                 }
             }
         }
         return modelElement;
     }
 
     /**
      * Retrieves the serial version UID by reading the tagged value
      * {@link UMLProfile#TAGGEDVALUE_SERIALVERSION_UID} of the
      * <code>classifier</code>.
      *
      * @param classifier the classifier to be inspected.
      * @return the serial version UID of the classifier. Returns
      *         <code>null</code> if the tagged value cannot be found.
      */
     public static String getSerialVersionUID(ClassifierFacade classifier)
     {
         ExceptionUtils.checkNull("classifer", classifier);
         String serialVersionString = (String)classifier
                 .findTaggedValue(UMLProfile.TAGGEDVALUE_SERIALVERSION_UID);
         return StringUtils.trimToNull(serialVersionString);
     }
 
     /**
      * This method removes all duplicates within the <code>elements</code> collection while at the same
      * time copying tagged values from duplicates to the one remaining element with the given name.
      *
      * @param elements the elements to remove duplicates and copy tagged values to.
      * @return the elements with duplicates removed.
      */
     public static List<ModelElementFacade> removeDuplicatesAndCopyTaggedValues(final Collection<ModelElementFacade> elements)
     {
         final Map<String, ModelElementFacade> map = new LinkedHashMap<String, ModelElementFacade>();
         if (elements != null)
         {
             for (final Iterator<ModelElementFacade> iterator = elements.iterator(); iterator.hasNext();)
             {
                 ModelElementFacade element = iterator.next();
                 final String name = element.getName();
                 final ModelElementFacade existingVariable = map.get(name);
                 // - copy over any tagged values from the existing variable to the new one.
                 if (existingVariable != null)
                 {
                     element.copyTaggedValues(existingVariable);
                 }
                 map.put(
                     name,
                     element);
             }
         }
         return new ArrayList<ModelElementFacade>(map.values());
     }
 }