package org.andromda.metafacades.uml14;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Iterator;
   import org.andromda.core.common.ExceptionUtils;
   import org.andromda.core.configuration.Filters;
   import org.andromda.core.metafacade.MetafacadeBase;
  import org.andromda.core.metafacade.MetafacadeConstants;
  import org.andromda.core.metafacade.MetafacadeFactory;
  import org.andromda.core.metafacade.ModelAccessFacade;
  import org.andromda.metafacades.uml.EntityMetafacadeUtils;
  import org.andromda.metafacades.uml.ModelElementFacade;
  import org.andromda.metafacades.uml.PackageFacade;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.Predicate;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.omg.uml.UmlPackage;
  import org.omg.uml.foundation.core.ModelElement;
  
  /**
   * Contains a UML model, follows the {@link ModelAccessFacade} interface and can therefore be processed by AndroMDA.
   *
   * @author <a href="http://www.mbohlen.de">Matthias Bohlen </a>
   * @author Chad Brandon
   * @author Bob Fields
   */
  public class UMLModelAccessFacade
      implements ModelAccessFacade
  {
      private static final Logger logger = Logger.getLogger(UMLModelAccessFacade.class);
      private UmlPackage model;
  
      /**
       * @see org.andromda.core.metafacade.ModelAccessFacade#setModel(Object)
       */
      public void setModel(final Object model)
      {
          ExceptionUtils.checkNull("model", model);
          ExceptionUtils.checkAssignable(
              UmlPackage.class,
              "modelElement",
              model.getClass());
          this.model = (UmlPackage)model;
          // TODO: - clears out the foreign key cache (probably not
          //         the cleanest way, but the easiest at this point).
          EntityMetafacadeUtils.clearForeignKeyConstraintNameCache();
      }
  
      /**
       * @see org.andromda.core.metafacade.ModelAccessFacade#getModel()
       */
      public UmlPackage getModel()
      {
          return model;
      }
  
      /**
       * @see org.andromda.core.metafacade.ModelAccessFacade#getName(Object)
       */
      public String getName(final Object modelElement)
      {
          ExceptionUtils.checkNull("modelElement", modelElement);
          ExceptionUtils.checkAssignable(
              ModelElementFacade.class,
              "modelElement",
              modelElement.getClass());
          return ((ModelElementFacade)modelElement).getName();
      }
  
      /**
       * @see org.andromda.core.metafacade.ModelAccessFacade#getPackageName(Object)
       */
      public String getPackageName(final Object modelElement)
      {
          ExceptionUtils.checkNull("modelElement", modelElement);
          ExceptionUtils.checkAssignable(
              ModelElementFacade.class,
              "modelElement",
              modelElement.getClass());
          final ModelElementFacade modelElementFacade = (ModelElementFacade)modelElement;
          final StringBuilder packageName = new StringBuilder(modelElementFacade.getPackageName(true));
  
          // - if the model element is a package then the package name will be the name
          //   of the package with its package name
          if (modelElement instanceof PackageFacade)
          {
              final String name = modelElementFacade.getName();
              if (StringUtils.isNotBlank(name))
              {
                  packageName.append(MetafacadeConstants.NAMESPACE_SCOPE_OPERATOR);
                  packageName.append(name);
              }
          }
          return packageName.toString();
      }
  
     /**
      * @see org.andromda.core.metafacade.ModelAccessFacade#getStereotypeNames(Object)
      */
     public Collection<String> getStereotypeNames(final Object modelElement)
     {
         Collection<String> stereotypeNames = new ArrayList();
         if (modelElement instanceof ModelElement)
         {
             ModelElement element = (ModelElement)modelElement;
             Collection<ModelElement> stereotypes = element.getStereotype();
             for (final Iterator<ModelElement> iterator = stereotypes.iterator(); iterator.hasNext();)
             {
                 ModelElement stereotype = iterator.next();
                 stereotypeNames.add(stereotype.getName());
             }
         }
         else if (modelElement instanceof ModelElementFacade)
         {
             stereotypeNames = ((ModelElementFacade)modelElement).getStereotypeNames();
         }
         return stereotypeNames;
     }
 
     /**
      * @see org.andromda.core.metafacade.ModelAccessFacade#findByStereotype(String)
      */
     public Collection<MetafacadeBase> findByStereotype(String stereotype)
     {
         final String methodName = "UMLModelAccessFacade.findByStereotype";
         final Collection<MetafacadeBase> metafacades = new ArrayList<MetafacadeBase>();
         stereotype = StringUtils.trimToEmpty(stereotype);
         if (StringUtils.isNotBlank(stereotype))
         {
             if (this.model != null)
             {
                 final Collection<ModelElement> underlyingElements = model.getCore().getModelElement().refAllOfType();
                 if (underlyingElements != null && !underlyingElements.isEmpty())
                 {
                     for (final ModelElement element : underlyingElements)
                     {
                         Collection<String> stereotypeNames = this.getStereotypeNames(element);
                         if (stereotypeNames != null && stereotypeNames.contains(stereotype))
                         {
                             metafacades.add(MetafacadeFactory.getInstance().createMetafacade(element));
                         }
                     }
                 }
                 if (logger.isDebugEnabled())
                 {
                     logger.debug("completed " + methodName + " with " + metafacades.size() + " modelElements");
                 }
             }
             this.filterMetafacades(metafacades);
         }
         return metafacades;
     }
 
     /**
      * @see org.andromda.core.metafacade.ModelAccessFacade#getModelElements()
      */
     public Collection<MetafacadeBase> getModelElements()
     {
         Collection<MetafacadeBase> metafacades = Collections.emptyList();
         if (this.model != null)
         {
             metafacades =
                 MetafacadeFactory.getInstance().createMetafacades(
                     this.model.getCore().getModelElement().refAllOfType());
             this.filterMetafacades(metafacades);
         }
         return metafacades;
     }
 
     /**
      * Stores the package filter information.  Protected
      * visibility for better inner class access performance.
      */
     protected Filters modelPackages;
 
     /**
      * @see org.andromda.core.metafacade.ModelAccessFacade#setPackageFilter(org.andromda.core.configuration.Filters)
      */
     public void setPackageFilter(final Filters modelPackages)
     {
         this.modelPackages = modelPackages;
     }
 
     /**
      * Filters out those metafacades which <strong>should </strong> be processed.
      *
      * @param metafacades the Collection of modelElements.
      */
     private void filterMetafacades(final Collection metafacades)
     {
         if (this.modelPackages != null && !this.modelPackages.isEmpty())
         {
             CollectionUtils.filter(
                 metafacades,
                 new Predicate()
                 {
                     public boolean evaluate(final Object metafacade)
                     {
                         boolean valid = false;
                         if (metafacade instanceof MetafacadeBase)
                         {
                             final ModelElementFacade modelElementFacade = (ModelElementFacade)metafacade;
                             final StringBuilder packageName = new StringBuilder(modelElementFacade.getPackageName(true));
 
                             // - if the model element is a package then the package name will be the name
                             //   of the package with its package name
                             if (metafacade instanceof PackageFacade)
                             {
                                 final String name = modelElementFacade.getName();
                                 if (StringUtils.isNotBlank(name))
                                 {
                                     packageName.append(MetafacadeConstants.NAMESPACE_SCOPE_OPERATOR);
                                     packageName.append(name);
                                 }
                             }
                             valid = modelPackages.isApply(packageName.toString());
                         }
                         return valid;
                     }
                 });
         }
     }
 }