package org.andromda.core.metafacade;
   
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.LinkedHashMap;
   import java.util.LinkedHashSet;
   import java.util.List;
   import java.util.Map;
  import org.andromda.core.common.AndroMDALogger;
  import org.andromda.core.common.ExceptionUtils;
  import org.andromda.core.profile.Profile;
  import org.apache.commons.collections.keyvalue.MultiKey;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  
  /**
   * The factory in charge of constructing Metafacade instances. In order for a
   * metafacade (i.e. a facade around a meta model element) to be constructed, it
   * must be constructed through this factory.
   *
   * @author <a href="http://www.mbohlen.de">Matthias Bohlen </a>
   * @author Chad Brandon
   * @author Peter Friese
   * @author Bob Fields
   */
  public final class MetafacadeFactory
      implements Serializable
  {
      private static final long serialVersionUID = 34L;
  
      /**
       * Caches the registered properties used within metafacades.
       */
      private final Map<String, Map<String, Map<String, Object>>> metafacadeNamespaces = new LinkedHashMap<String, Map<String, Map<String, Object>>>();
  
      /**
       * The shared instance of this factory.
       */
      private static MetafacadeFactory instance = null;
  
      private MetafacadeFactory()
      {
          // make sure that nobody instantiates it
      }
  
      /**
       * Returns the facade factory singleton.
       *
       * @return the only instance
       */
      public static MetafacadeFactory getInstance()
      {
          if (instance == null)
          {
              instance = new MetafacadeFactory();
          }
          return instance;
      }
  
      /**
       * The metafacade cache for this factory.
       */
      private final MetafacadeCache cache = MetafacadeCache.newInstance();
  
      /**
       * The metafacade mappings instance for this factory.
       */
      private final MetafacadeMappings mappings = MetafacadeMappings.newInstance();
  
      /**
       * Performs any initialization required by the factory (i.e. discovering all
       * <code>metafacade</code> mappings, etc).
       */
      public void initialize()
      {
          this.mappings.initialize();
      }
  
      /**
       * The shared profile instance.
       */
      private final Profile profile = Profile.instance();
  
      /**
       * The namespace that is currently active (i.e. being used) within the factory
       */
      private String namespace;
  
      /**
       * Sets the active namespace. The AndroMDA core and each cartridge have their own namespace for metafacade
       * registration.
       *
       * @param namespace the name of the active namespace.
       */
      public void setNamespace(final String namespace)
      {
          this.namespace = namespace;
          this.profile.setNamespace(namespace);
         this.cache.setNamespace(this.namespace);
     }
 
     /**
      * Returns the name of the active namespace.
      *
      * @return String the namespace name
      */
     public String getNamespace()
     {
         if (this.namespace == null)
         {
             throw new MetafacadeFactoryException("This metafacade factory's namespace must be populated before " +
                 "metafacade construction can occur");
         }
         return this.namespace;
     }
 
     /**
      * Returns a metafacade for a mappingObject, depending on its
      * <code>mappingClass</code> and (optionally) its <code>stereotypes</code>
      * and <code>context</code>.
      *
      * @param mappingObject the object used to map the metafacade (a meta model
      *        object or a metafacade itself).
      * @param context the name of the context the meta model element is
      *        registered under.
      * @return the new metafacade
      */
     public MetafacadeBase createMetafacade(
         final Object mappingObject,
         final String context)
     {
         return this.createMetafacade(
             mappingObject,
             context,
             null);
     }
 
     /**
      * Creates a metafacade given the <code>mappingObject</code>,
      * <code>contextName</code> and <code>metafacadeClass</code>.
      *
      * @param mappingObject the object used to map the metafacade (a meta model
      *        object or a metafacade itself).
      * @param context the name of the context the meta model element (if the
      *        mappObject is a meta model element) is registered under.
      * @param metafacadeClass if not null, it contains the name of the
      *        metafacade class to be used. This is used ONLY when instantiating
      *        super metafacades in an inheritance chain. The final metafacade
      *        will NEVER have a metafacadeClass specified (it will ALWAYS be
      *        null).
      * @return the new metafacade
      */
     private MetafacadeBase createMetafacade(
         final Object mappingObject,
         final String context,
         Class metafacadeClass)
     {
         final String methodName = "MetafacadeFactory.createMetafacade";
         ExceptionUtils.checkNull(
             "mappingObject",
             mappingObject);
 
         // - register the namespace properties (if they haven't been)
         this.registerNamespaceProperties();
 
         // if the mappingObject is REALLY a metafacade, just return it
         if (mappingObject instanceof MetafacadeBase)
         {
             return (MetafacadeBase)mappingObject;
         }
         try
         {
             final Collection<String> stereotypes = this.getModel().getStereotypeNames(mappingObject);
             if (this.getLogger().isDebugEnabled())
             {
                 this.getLogger().debug("mappingObject stereotypes --> '" + stereotypes + '\'');
             }
 
             MetafacadeMapping mapping = null;
             if (metafacadeClass == null)
             {
                 final MetafacadeMappings modelMetafacadeMappings = this.getModelMetafacadeMappings();
                 mapping = modelMetafacadeMappings.getMetafacadeMapping(
                     mappingObject,
                     this.getNamespace(),
                     context,
                     stereotypes);
                 if (this.getLogger().isDebugEnabled())
                 {
                     this.getLogger().debug("mappingObject getModelMetafacadeMappings for " + mappingObject + " namespace " + this.getNamespace() + " context " + context);
                 }
                 if (mapping != null)
                 {
                     metafacadeClass = mapping.getMetafacadeClass();
                 }
                 else
                 {
                     // get the default since no mapping was found.
                     metafacadeClass = modelMetafacadeMappings.getDefaultMetafacadeClass(this.getNamespace());
                     if (this.getLogger().isDebugEnabled())
                     {
                         this.getLogger().warn(
                             "Meta object model class '" + mappingObject.getClass() +
                             "' has no corresponding meta facade class, default is being used --> '" + metafacadeClass +
                                     '\'');
                     }
                 }
             }
 
             if (metafacadeClass == null)
             {
                 throw new MetafacadeMappingsException(methodName + " metafacadeClass was not retrieved from mappings" +
                     " or specified as an argument in this method for mappingObject --> '" + mappingObject + '\'');
             }
             final MetafacadeBase metafacade = this.getMetafacade(
                     metafacadeClass,
                     mappingObject,
                     context,
                     mapping);
 
             // IMPORTANT: initialize each metafacade ONLY once (otherwise we
             // get stack overflow errors)
             if (metafacade != null && !metafacade.isInitialized())
             {
                 metafacade.setInitialized();
                 metafacade.initialize();
             }
             return metafacade;
         }
         catch (final Throwable throwable)
         {
             final String message =
                 "Failed to construct a meta facade of type '" + metafacadeClass + "' with mappingObject of type --> '" +
                 mappingObject.getClass() + '\'';
             this.getLogger().error(message);
             throw new MetafacadeFactoryException(message, throwable);
         }
     }
 
     /**
      * Gets the model metafacade mappings (the mappings that correspond
      * to the current metafacade model namespace).
      *
      * @return the model metafacade mappings.
      */
     private MetafacadeMappings getModelMetafacadeMappings()
     {
         return this.mappings.getModelMetafacadeMappings(this.metafacadeModelNamespace);
     }
 
     /**
      * Validates all metafacades for the current namespace
      * and collects the messages in the internal validation messages
      * collection.
      *
      * @see #getValidationMessages()
      */
     public void validateAllMetafacades()
     {
         for (final MetafacadeBase metafacadeBase : this.getAllMetafacades())
         {
             metafacadeBase.validate(this.validationMessages);
         }
     }
 
     /**
      * Creates a metafacade from the passed in <code>mappingObject</code>, and
      * <code>mapping</code> instance.
      *
      * @param mappingObject the mapping object for which to create the
      *        metafacade.
      * @param mapping the mapping from which to create the metafacade
      * @return the metafacade, or null if it can't be created.
      */
     protected MetafacadeBase createMetafacade(
         final Object mappingObject,
         final MetafacadeMapping mapping)
     {
         try
         {
             return this.getMetafacade(
                 mapping.getMetafacadeClass(),
                 mappingObject,
                 mapping.getContext(),
                 mapping);
         }
         catch (final Throwable throwable)
         {
             final String message =
                 "Failed to construct a meta facade of type '" + mapping.getMetafacadeClass() +
                 "' with mappingObject of type --> '" + mapping.getMappingClassNames() + '\'';
             this.getLogger().error(message);
             throw new MetafacadeFactoryException(message, throwable);
         }
     }
 
     /**
      * Retrieves (if one has already been constructed) or constructs a new
      * <code>metafacade</code> from the given <code>metafacadeClass</code>
      * and <code>mappingObject</code>.
      *
      * @param metafacadeClass the metafacade class.
      * @param mappingObject the object to which the metafacade is mapped.
      * @param context the context to which the metafacade applies
      * @param mapping the optional MetafacadeMapping instance from which the
      *        metafacade is mapped.
      * @return the new (or cached) metafacade.
      * @throws Exception if any error occurs during metafacade creation
      */
     private MetafacadeBase getMetafacade(
         final Class metafacadeClass,
         final Object mappingObject,
         final String context,
         final MetafacadeMapping mapping)
         throws Exception
     {
         MetafacadeBase metafacade = this.cache.get(
                 mappingObject,
                 metafacadeClass);
         if (metafacade == null)
         {
             final MultiKey key = new MultiKey(mappingObject, metafacadeClass);
             if (!this.metafacadesInCreation.contains(key))
             {
                 this.metafacadesInCreation.add(
                     key);
                 if (mapping != null && mapping.isContextRoot())
                 {
                     metafacade = MetafacadeUtils.constructMetafacade(
                             metafacadeClass,
                             mappingObject,
                             null);
                     // set whether or not this metafacade is a context root
                     metafacade.setContextRoot(mapping.isContextRoot());
                 }
                 else
                 {
                     metafacade = MetafacadeUtils.constructMetafacade(
                             metafacadeClass,
                             mappingObject,
                             context);
                 }
                 this.metafacadesInCreation.remove(key);
 
                 this.cache.add(
                     mappingObject,
                     metafacade);
             }
         }
 
         if (metafacade != null)
         {
             // if the requested metafacadeClass is different from the one in the mapping, contextRoot should be reset
             if (mapping != null && !mapping.getMetafacadeClass().equals(metafacadeClass))
             {
                 metafacade.setContextRoot(false);
                 metafacade.resetMetafacadeContext(context);
             }
             // we need to set some things each time
             // we change a metafacade's namespace
             final String metafacadeNamespace = metafacade.getMetafacadeNamespace();
             if (metafacadeNamespace == null || !metafacadeNamespace.equals(this.getNamespace()))
             {
                 // assign the logger and active namespace
                 metafacade.setNamespace(this.getNamespace());
                 metafacade.setLogger(this.getLogger());
             }
         }
         return metafacade;
     }
 
     /**
      * Stores the metafacades being created, so that we don't get stuck in
      * endless recursion during creation.
      */
     private final Collection<MultiKey> metafacadesInCreation = new ArrayList<MultiKey>();
 
     /**
      * Returns a metafacade for a mappingObject, depending on its <code>mappingClass</code>.
      *
      * @param mappingObject the object which is used to map to the metafacade
      * @return MetafacadeBase the facade object (not yet attached to mappingClass object)
      */
     public MetafacadeBase createMetafacade(final Object mappingObject)
     {
         return this.createMetafacade(
             mappingObject,
             null,
             null);
     }
 
     /**
      * Create a facade implementation object for a mappingObject. The facade
      * implementation object must be found in a way that it implements the
      * interface <code>interfaceName</code>.
      *
      * @param interfaceName the name of the interface that the implementation
      *        object has to implement
      * @param mappingObject the mappingObject for which a facade shall be
      *        created
      * @param context the context in which this metafacade will be created.
      * @return MetafacadeBase the metafacade
      */
     public MetafacadeBase createFacadeImpl(
         final String interfaceName,
         final Object mappingObject,
         final String context)
     {
         ExceptionUtils.checkEmpty(
             "interfaceName",
             interfaceName);
         ExceptionUtils.checkNull(
             "mappingObject",
             mappingObject);
 
         Class metafacadeClass = null;
         try
         {
             metafacadeClass = this.metafacadeImpls.getMetafacadeImplClass(interfaceName);
             return this.createMetafacade(
                 mappingObject,
                 context,
                 metafacadeClass);
         }
         catch (final Throwable throwable)
         {
             final String message =
                 "Failed to construct a meta facade of type '" + metafacadeClass + "' with mappingObject of type --> '" +
                 mappingObject.getClass().getName() + '\'';
             this.getLogger().error(message);
             throw new MetafacadeFactoryException(message, throwable);
         }
     }
 
     /**
      * Returns a metafacade for each mappingObject, contained within the
      * <code>mappingObjects</code> collection depending on its
      * <code>mappingClass</code> and (optionally) its <code>stereotypes</code>,
      * and <code>contextName</code>.
      *
      * @param mappingObjects the meta model element.
      * @param contextName the name of the context the meta model element is
      *        registered under.
      * @return the Collection of newly created Metafacades.
      */
     protected Collection<MetafacadeBase> createMetafacades(
         final Collection mappingObjects,
         final String contextName)
     {
         final Collection<MetafacadeBase> metafacades = new ArrayList<MetafacadeBase>();
         if (mappingObjects != null && !mappingObjects.isEmpty())
         {
             for (final Object mappingObject : mappingObjects)
             {
                 if (this.getLogger().isDebugEnabled())
                 {
                     this.getLogger().debug("MetafacadeFactory createMetafacade for namespace " + this.getNamespace() + " model " + this.getModel() + " contextName " + contextName + " mappingObject " + mappingObject);
                 }
                 metafacades.add(this.createMetafacade(
                         mappingObject,
                         contextName,
                         null));
             }
         }
         return metafacades;
     }
 
     /**
      * Returns a metafacade for each mappingObject, contained within the
      * <code>mappingObjects</code> collection depending on its
      * <code>mappingClass</code>.
      *
      * @param mappingObjects the objects used to map the metafacades (can be a
      *        meta model element or an actual metafacade itself).
      * @return Collection of metafacades
      */
     public Collection<MetafacadeBase> createMetafacades(final Collection mappingObjects)
     {
         return this.createMetafacades(
             mappingObjects,
             null);
     }
 
     /**
      * The model facade which provides access to the underlying meta model.
      */
     private ModelAccessFacade model;
 
     /**
      * Gets the model which provides access to the underlying model and is used
      * to construct metafacades.
      *
      * @return the model access facade.
      */
     public ModelAccessFacade getModel()
     {
         if (this.model == null)
         {
             throw new MetafacadeFactoryException("This metafacade factory's model must be populated before " +
                 "metafacade construction can occur");
         }
         return this.model;
     }
 
     /**
      * The shared metafacade impls instance.
      */
     private MetafacadeImpls metafacadeImpls = MetafacadeImpls.instance();
 
     /**
      * Stores the namespace that contains the metafacade model implementation.
      */
     private String metafacadeModelNamespace;
 
     /**
      * The model access facade instance (provides access to the meta model).
      *
      * @param model the model
      * @param metafacadeModelNamespace the namespace that contains the metafacade facade implementation.
      */
     public void setModel(
         final ModelAccessFacade model,
         final String metafacadeModelNamespace)
     {
         this.metafacadeModelNamespace = metafacadeModelNamespace;
 
         // - set the model type as the namespace for the metafacade impls so we have
         //   access to the correct metafacade classes
         this.metafacadeImpls.setMetafacadeModelNamespace(metafacadeModelNamespace);
         this.model = model;
     }
 
     /**
      * Gets the correct logger based on whether or not an namespace logger should be used
      *
      * @return the logger
      */
     final Logger getLogger()
     {
         return AndroMDALogger.getNamespaceLogger(this.getNamespace());
     }
 
     /**
      * Registers a property with the specified <code>name</code> in the given
      * <code>namespace</code>.
      *
      * @param namespace the namespace in which the property is stored.
      * @param metafacadeName the name of the metafacade under which the property is registered
      * @param name the name of the property
      * @param value to give the property
      */
     final void registerProperty(
         final String namespace,
         final String metafacadeName,
         final String name,
         final Object value)
     {
         ExceptionUtils.checkEmpty(
             "name",
             name);
         Map<String, Map<String, Object>> metafacadeNamespace = this.metafacadeNamespaces.get(namespace);
         if (metafacadeNamespace == null)
         {
             metafacadeNamespace = new LinkedHashMap<String, Map<String, Object>>();
             this.metafacadeNamespaces.put(
                 namespace,
                 metafacadeNamespace);
         }
         Map<String, Object> propertyNamespace = metafacadeNamespace.get(metafacadeName);
         if (propertyNamespace == null)
         {
             propertyNamespace = new LinkedHashMap<String, Object>();
             metafacadeNamespace.put(
                 metafacadeName,
                 propertyNamespace);
         }
         propertyNamespace.put(
             name,
             value);
     }
 
     /**
      * Registers a property with the specified <code>name</code> in the namespace
      * that is currently set within the factory.
      *
      * @param metafacadeName the name of the metafacade under which the property is registered
      * @param name the name of the property
      * @param value to give the property
      */
     final void registerProperty(
         final String metafacadeName,
         final String name,
         final Object value)
     {
         this.registerProperty(
             this.getNamespace(),
             metafacadeName,
             name,
             value);
     }
 
     /**
      * Gets the metafacade's property namespace (or returns null if hasn't be registered).
      *
      * @param metafacade the metafacade
      * @return the metafacade's namespace
      */
     private Map<String, Object> getMetafacadePropertyNamespace(final MetafacadeBase metafacade)
     {
         Map<String, Object> metafacadeNamespace = null;
         if (metafacade != null)
         {
             Map<String, Map<String, Object>> namespace = this.metafacadeNamespaces.get(this.getNamespace());
             if (namespace != null)
             {
                 metafacadeNamespace = namespace.get(metafacade.getMetafacadeName());
             }
         }
         return metafacadeNamespace;
     }
 
     /**
      * Returns true if this property is registered under the given
      * <code>namespace</code>, false otherwise.
      *
      * @param metafacade the metafacade to search.
      * @param name the name of the property.
      * @return true if the property is registered, false otherwise.
      */
     final boolean isPropertyRegistered(
         final MetafacadeBase metafacade,
         final String name)
     {
         final Map<String, Object> propertyNamespace = this.getMetafacadePropertyNamespace(metafacade);
         return propertyNamespace != null && propertyNamespace.containsKey(name);
     }
 
     /**
      * Finds the first property having the given <code>namespaces</code>, or
      * <code>null</code> if the property can <strong>NOT </strong> be found.
      *
      * @param metafacade the metafacade to search.
      * @param name the name of the property to find.
      * @return the property or null if it can't be found.
      */
     private Object findProperty(
         final MetafacadeBase metafacade,
         final String name)
     {
         final Map<String, Object> propertyNamespace = this.getMetafacadePropertyNamespace(metafacade); //final Map<String, Map>
         return propertyNamespace != null ? propertyNamespace.get(name) : null;
     }
 
     /**
      * Gets the registered property registered under the <code>namespace</code>
      * with the <code>name</code>
      *
      * @param metafacade the metafacade to search
      * @param name the name of the property to check.
      * @return the registered property
      */
     final Object getRegisteredProperty(
         final MetafacadeBase metafacade,
         final String name)
     {
         final String methodName = "MetafacadeFactory.getRegisteredProperty";
         final Object registeredProperty = this.findProperty(
                 metafacade,
                 name);
         if (registeredProperty == null && !this.isPropertyRegistered(
                 metafacade,
                 name))
         {
             throw new MetafacadeFactoryException(methodName + " - no property '" + name +
                 "' registered under metafacade '" + metafacade.getMetafacadeName() + "' for namespace '" + this.getNamespace() +
                     '\'');
         }
         return registeredProperty;
     }
 
     /**
      * The validation messages that have been collected during the
      * execution of this factory.
      */
     private final Collection<ModelValidationMessage> validationMessages = new LinkedHashSet<ModelValidationMessage>();
 
     /**
      * Gets the list of all validation messages collection during model processing.
      *
      * @return Returns the validationMessages.
      * @see #validateAllMetafacades()
      */
     public List<ModelValidationMessage> getValidationMessages()
     {
         return new ArrayList<ModelValidationMessage>(this.validationMessages);
     }
 
     /**
      * Stores the collection of all metafacades for
      * each namespace.
      */
     private final Map<String, Collection<MetafacadeBase>> allMetafacades = new LinkedHashMap<String, Collection<MetafacadeBase>>();
 
     /**
      * <p>
      * Gets all metafacades for the entire model for the
      * current namespace set within the factory.
      * </p>
      * <p>
      * <strong>NOTE:</strong> The model package filter is applied
      * before returning the results (if defined within the factory).
      * </p>
      *
      * @return all metafacades
      */
     public Collection<MetafacadeBase> getAllMetafacades()
     {
         final String namespace = this.getNamespace();
         Collection<MetafacadeBase> metafacades = null;
         if (this.getModel() != null)
         {
             metafacades = allMetafacades.get(namespace);
             if (metafacades == null)
             {
                 metafacades = this.createMetafacades(this.getModel().getModelElements());
                 allMetafacades.put(
                     namespace,
                     metafacades);
             }
             if (metafacades != null)
             {
                 metafacades = new ArrayList<MetafacadeBase>(metafacades);
             }
         }
         return metafacades;
     }
 
     /**
      * Caches the metafacades by stereotype.
      */
     private final Map<String, Map<String, Collection<MetafacadeBase>>> metafacadesByStereotype
     = new LinkedHashMap<String, Map<String, Collection<MetafacadeBase>>>();
 
     /**
      * <p>
      * Gets all metafacades for the entire model having the given
      * stereotype.
      * </p>
      * <p>
      * <strong>NOTE:</strong> The model package filter is applied
      * before returning the results (if defined within the factory).
      * </p>
      *
      * @param stereotype the stereotype by which to perform the search.
      * @return the metafacades having the given <code>stereotype</code>.
      */
     public Collection<MetafacadeBase> getMetafacadesByStereotype(final String stereotype)
     {
         final String namespace = this.getNamespace();
         Collection<MetafacadeBase> metafacades = null;
         if (this.getModel() != null)
         {
             Map<String, Collection<MetafacadeBase>> stereotypeMetafacades = this.metafacadesByStereotype.get(namespace);
             if (stereotypeMetafacades == null)
             {
                 stereotypeMetafacades = new LinkedHashMap<String, Collection<MetafacadeBase>>();
             }
             metafacades = stereotypeMetafacades.get(stereotype);
             if (metafacades == null)
             {
                 metafacades = this.createMetafacades(this.getModel().findByStereotype(stereotype));
                 stereotypeMetafacades.put(
                     stereotype,
                     metafacades);
                 this.metafacadesByStereotype.put(
                     namespace,
                     stereotypeMetafacades);
             }
             if (metafacades != null)
             {
                 metafacades = new ArrayList<MetafacadeBase>(metafacades);
             }
         }
         return metafacades;
     }
 
     /**
      * Performs shutdown procedures for the factory. This should be called <strong>ONLY</strong> when model processing has
      * completed.
      */
     public void shutdown()
     {
         this.clearCaches();
         this.metafacadeNamespaces.clear();
         this.mappings.shutdown();
         this.model = null;
         MetafacadeFactory.instance = null;
 
         // - shutdown the profile instance
         this.profile.shutdown();
     }
 
     /**
      * Registers all namespace properties (if required).
      */
     private void registerNamespaceProperties()
     {
         // - only register them if they already aren't registered
         if (this.metafacadeNamespaces.isEmpty())
         {
             if (StringUtils.isNotBlank(this.metafacadeModelNamespace))
             {
                 final MetafacadeMappings modelMappings = this.getModelMetafacadeMappings();
                 if (modelMappings != null)
                 {
                     modelMappings.registerAllProperties();
                 }
             }
         }
     }
 
     /**
      * Entirely resets all the internal resources within this factory instance (such
      * as the caches, etc).
      */
     public void reset()
     {
         // - refresh the profile
         this.profile.refresh();
 
         // - clear out the namespace properties so we can re-register them next run
         this.metafacadeNamespaces.clear();
 
         // - re-register the namespace properties (if we're running again)
         this.registerNamespaceProperties();
 
         // - clear out the rest of the factory's caches
         this.clearCaches();
     }
 
     /**
      * Clears out the factory's internal caches (other
      * than namespace properties, which can be cleared by
      * calling {@link org.andromda.core.configuration.Namespaces#clear()}.
      */
     public void clearCaches()
     {
         this.validationMessages.clear();
         this.allMetafacades.clear();
         this.metafacadesByStereotype.clear();
         this.cache.clear();
         this.metafacadesInCreation.clear();
     }
 }