package org.andromda.core.metafacade;
   
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.List;
   import org.apache.commons.lang.StringUtils;
   import org.apache.commons.lang.builder.ToStringBuilder;
   import org.apache.log4j.Logger;
  
  /**
   * Base class for all metafacades.
   *
   * @author <a href="http://www.mbohlen.de">Matthias Bohlen </a>
   * @author Chad Brandon
   * @author Wouter Zoons
   * @author Bob Fields
   */
  public class MetafacadeBase implements Serializable, Comparable
  {
      private static final long serialVersionUID = 34L;
      /**
       * The meta object which this metafacade wraps.
       */
      private Object metaObject;
  
      /**
       * Constructs a new instance of this class with the given <code>metaObject</code>
       * and <code>context</code>.  The metaObject is the meta model element which
       * this metafacade insulates. The <code>context</code> is the name of the
       * context for this metafacade instance.
       *
       * @param metaObjectIn the meta object.
       * @param contextIn the context of this meta object.
       */
      public MetafacadeBase(
          final Object metaObjectIn,
          final String contextIn)
      {
          this.metaObject = metaObjectIn;
          this.context = contextIn;
      }
  
      /**
       * Retrieves the <code>owner</code> of this metafacade (for example: an operation owns its parameters, a class owns
       * its attributes).
       * <p>
       * By default <code>null</code> is returned, however this method is overridden by subclasses which have a
       * <code>parent</code> or <code>owner</code>. This is used to give the model validation messages more context as to
       * where the validation error occurred. </p>
       *
       * @return the owner of this metafacade.
       */
      public Object getValidationOwner()
      {
          return null;
      }
  
      /**
       * Retrieves the <code>name</code> of this metafacade used within the validation messages.
       * <p>
       * By default <code>null</code> is returned, however this method is overridden by subclasses model elements that do
       * have a name. </p>
       *
       * @return the owner of this metafacade.
       */
      public String getValidationName()
      {
          return null;
      }
  
      /**
       * Stores whether or not this metafacade has
       * been initialized.
       */
      private boolean initialized = false;
  
      /**
       * Sets the flag indicating this metafacade has been initialized.
       */
      final void setInitialized()
      {
          this.initialized = true;
      }
  
      /**
       * Indicates if this metafacade has been initialized.
       *
       * @return true/false
       */
      final boolean isInitialized()
      {
          return this.initialized;
      }
  
      /**
       * Validates that this facade's meta object is in a valid state.
       * <p>
       * Validate is called during metafacade creation by the factory. In the lifecycle of a metafacade it is validated
      * only once, this is enforced by the caching within the metafacade factory.</p>
      *
      * @param validationMessages any messages generated during validation.
      */
     public final void validate(final Collection<ModelValidationMessage> validationMessages)
     {
         this.validateInvariants(validationMessages);
     }
 
     /**
      * <p>
      * The logic of modeled OCL invariants from derived metafacades will be generated into this method and validation
      * messages created and collected into the <code>messages</code> collection. This method is called by {@link #validate(Collection validationMessages)}
      * </p>
      * By default this method is empty. </p>
      * @param messages Collection of org.andromda.core.metafacade.ModelValidationMessage
      */
     public void validateInvariants(final Collection<ModelValidationMessage> messages)
     {
         // By default this does nothing
     }
 
     /**
      * A lifecycle method, providing the ability for sub classes to take any action after the factory has completely
      * initialized a metafacade, but before it has been validated for completeness.
      */
     public void initialize()
     {
         // By default this does nothing
     }
 
     /**
      * Returns one facade for a particular metaObject. Contacts the MetafacadeFactory to manufacture the proper
      * metafacade. In certain cases <code>metaObject</code> can also be a metafacade instance; in that case the actual
      * meta model element is retrieved from the metafacade and a metafacade is constructed from that.
      *
      * @param metaObjectIn the underlying meta model element. A metafacade is created for each.
      * @return MetafacadeBase the facade
      * @see MetafacadeFactory
      */
     protected MetafacadeBase shieldedElement(final Object metaObjectIn)
     {
         MetafacadeBase metafacade = null;
         if (metaObjectIn != null)
         {
             final String contextIn = this.getContext();
             metafacade = MetafacadeFactory.getInstance().createMetafacade(
                     metaObjectIn,
                     contextIn);
 
             // - The metafacade we've just got may have been found in the cache.
             //   If so, it can have an arbitrary context (because it's cached).
             //   We now need to set the context once again, so that all
             //   other metafacade mappings based on the context work as expected.
             if(metafacade != null)
             {
                 metafacade.resetMetafacadeContext(contextIn);
             }
         }
         return metafacade;
     }
 
     /**
      * Returns a collection of facades for a collection of metaobjects. Contacts the MetafacadeFactory to manufacture
      * the proper facades.
      *
      * @param metaobjects the objects to decorate
      * @return Collection of MetafacadeBase-derived objects
      * @see MetafacadeFactory
      */
     protected List shieldedElements(final Collection metaobjects)
     {
         final List metafacades = new ArrayList();
         if (metaobjects != null)
         {
             for (final Object metaobject : metaobjects)
             {
                 metafacades.add(this.shieldedElement(metaobject));
             }
         }
         return metafacades;
     }
 
     /**
      * Stores the context for this metafacade
      */
     private String context = null;
 
     /**
      * Gets the context for this metafacade.
      *
      * @return the context name.
      */
     final String getContext()
     {
         String contextIn = this.context;
         if (StringUtils.isBlank(contextIn))
         {
             contextIn = this.getMetafacadeName();
         }
         return contextIn;
     }
 
     /**
      * Sets the context for this metafacade. This is used to pass the context along from a metafacade specializing this
      * metafacade (since we use delegate inheritance between shared and non-shared metafacades), as well as to pass the
      * context to a metafacade being created within another.
      *
      * @param contextIn the metafacade interface name representing the context.
      * @see MetafacadeMapping#isContextRoot()
      */
     public void setMetafacadeContext(final String contextIn)
     {
         this.context = contextIn;
     }
 
     /**
      * Resets the metafacade context after the metafacade was retrieved from the metafacade cache.
      * DO NOT CALL THIS METHOD BY HAND, it is reserved for use in the MetafacadeFactory.
      * @see org.andromda.core.metafacade.MetafacadeFactory
      * @param contextIn the context defined by MetafacadeFactory
      */
     public void resetMetafacadeContext(String contextIn)
     {
         throw new IllegalStateException("Method resetMetafacadeContext() must be overridden by concrete metafacade class (" + this.getClass().getName() + ")! Please re-generate your metafacades using the new andromda-meta cartridge.");
     }
 
     /**
      * Stores the namespace for this metafacade
      */
     private String metafacadeNamespace = null;
 
     /**
      * Gets the current namespace for this metafacade
      *
      * @return String
      */
     final String getMetafacadeNamespace()
     {
         return this.metafacadeNamespace;
     }
 
     /**
      * Sets the namespace for this metafacade.
      *
      * @param namespaceIn
      */
     final void setNamespace(final String namespaceIn)
     {
         this.metafacadeNamespace = namespaceIn;
     }
 
     /**
      * Returns true or false depending on whether the <code>property</code> is registered or not.
      *
      * @param property the name of the property to check.
      * @return true/false on whether or not its registered.
      */
     protected boolean isConfiguredProperty(final String property)
     {
         return MetafacadeFactory.getInstance().isPropertyRegistered(
             this,
             property);
     }
 
     /**
      * Gets a configured property from the container. Note that the configured property must be registered first.
      * Needs to be public so that a metafacade reference passed to a utility class can call this method.
      *
      * @param property the property name
      * @return Object the configured property instance (mappings, etc)
      */
     public Object getConfiguredProperty(final String property)
     {
         return MetafacadeFactory.getInstance().getRegisteredProperty(
             this,
             property);
     }
 
     /**
      * Attempts to set the property with <code>name</code> having the specified <code>value</code> on this metafacade.
      * @param nameIn
      * @param value
      */
     protected void setProperty(
         final String nameIn,
         final Object value)
     {
         MetafacadeFactory.getInstance().registerProperty(
             this.getMetafacadeName(),
             nameIn,
             value);
     }
 
     /**
      * Gets the current meta model object for this metafacade. This is used from {@link MetafacadeFactory} when
      * attempting to construct a metafacade from a metafacade. This allows us to get the meta object for this metafacade
      * so that the meta object can be used instead.
      *
      * @return the underlying model's meta object instance.
      */
     public final Object getMetaObject()
     {
         return this.metaObject;
     }
 
     /**
      * The metafacade logger instance.
      */
     protected Logger logger;
 
     /**
      * Package-local setter, called by facade factory. Sets the logger to use inside the facade's code.
      *
      * @param loggerIn the logger to set
      */
     final void setLogger(final Logger loggerIn)
     {
         this.logger = loggerIn;
     }
 
     /**
      * The flag indicating whether or not this metafacade is a context root.
      */
     protected boolean contextRoot = false;
 
     /**
      * Sets whether or not this metafacade represents a contextRoot. If it does represent a context root, then {@link
      * #getMetafacadeContext()}returns the metafacade interface for this metafacade, otherwise the regular
      * <code>context</code> is returned.
      *
      * @param contextRootIn
      */
     final void setContextRoot(final boolean contextRootIn)
     {
         this.contextRoot = contextRootIn;
     }
 
     /**
      * Gets the <code>context</code> for this metafacade. This is either the <code>contextRoot</code> (if one exists),
      * or the regular <code>context</code>.
      *
      * @return the metafacade's context.
      */
     public String getMetafacadeContext()
     {
         String metafacadeContext = this.getContext();
         if (this.contextRoot)
         {
             metafacadeContext = this.getMetafacadeName();
         }
         return metafacadeContext;
     }
 
     /**
      * Stores the name of the interface for this metafacade
      */
     private String metafacadeName = null;
 
     /**
      * Gets the name for this metafacade.
      *
      * @return the metafacade's name.
      */
     final String getMetafacadeName()
     {
         if (this.metafacadeName == null)
         {
             this.metafacadeName = MetafacadeImpls.instance().getMetafacadeClass(this.getClass().getName()).getName();
         }
         return this.metafacadeName;
     }
 
     /**
      * @see Object#equals(Object)
      */
     @Override
     public boolean equals(Object object)
     {
         boolean equals = false;
         if (object instanceof MetafacadeBase)
         {
             MetafacadeBase that = (MetafacadeBase)object;
             equals = this.metaObject.equals(that.metaObject);
         }
         return equals;
     }
 
     /**
      * @see Object#hashCode()
      */
     @Override
     public int hashCode()
     {
         return this.metaObject.hashCode();
     }
 
     /**
      * In order to speed up the check for this property (which will happen many times), we cache it :-)
      */
     private Boolean metafacadePropertyCachingEnabled = null;
 
     /**
      * A check to verify whether or not to make use of metafacade property caching. This method check if the {@link
      * MetafacadeProperties#ENABLE_METAFACADE_PROPERTY_CACHING} namespace property has been set, if this is not the case
      * then the caching will be enabled by default.
      * @return this.metafacadePropertyCachingEnabled.booleanValue()
      */
     public final boolean isMetafacadePropertyCachingEnabled()
     {
         if (this.metafacadePropertyCachingEnabled == null)
         {
             final String enableCache =
                 (String)this.getConfiguredProperty(MetafacadeProperties.ENABLE_METAFACADE_PROPERTY_CACHING);
             this.metafacadePropertyCachingEnabled = Boolean.valueOf(enableCache);
         }
         return this.metafacadePropertyCachingEnabled;
     }
 
     /**
      * The instance of this class as the appropriate metafacade instance.
      */
     private MetafacadeBase THIS = null;
 
     /**
      * The metafacade instance of <code>this</code>.  This should be used when
      * you'd need to check if <code>this</code> was an instance of a given metafacade.
      * For example: <code>THIS() instanceof SomeMetafacade</code>.
      *
      * This <strong>MUST</strong> be used instead of <em>this</em> in order to access the correct
      * metafacade instance in the hierarchy (since we use delegate inheritance).
      * @return this.shieldedElement(this.metaObject)
      */
     protected final MetafacadeBase THIS()
     {
         return this.THIS == null ? this.THIS = this.shieldedElement(this.metaObject) : this.THIS;
     }
 
     /**
      * @see Object#toString()
      */
     @Override
     public String toString()
     {
         return super.toString() + '[' + this.metafacadeName + ": " + this.metaObject.getClass().getName() + ']';
     }
 
     /**
      * Allow sorting and use in TreeSet. ValidationName is overridden in descendants.
      * @see Comparable#compareTo(Object)
      */
     public int compareTo(Object object)
     {
         if (object==null || !(object instanceof MetafacadeBase))
         {
             return -1;
         }
         MetafacadeBase metafacade = (MetafacadeBase)object;
         if (metafacade.getValidationName()==null)
         {
             return -1;
         }
         return metafacade.getValidationName().compareTo(this.getValidationName());
     }
 
     /**
      * For debug purposes, when we need more than just class and metaclass name
      * @return String representation of all properties including metaObject info
      * @see Object#toString()
      */
     public String getDebug()
     {
         return ToStringBuilder.reflectionToString(this) + '[' + this.metafacadeName + ": " + this.metaObject.getClass().getName() + ": " + ToStringBuilder.reflectionToString(this.metaObject) + ']';
     }
 }