package com.sourceforge.jpatterns.patterns;
   
   import com.sourceforge.jpatterns.core.configuration.exceptions.JPConfigException;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigsBean;
   import com.sourceforge.jpatterns.patterns.factory.JPFactoryImpl;
   import com.sourceforge.jpatterns.schema.CastorNameScopePriorityType;
   import com.sourceforge.jpatterns.schema.CastorSectionType;
   import com.sourceforge.jpatterns.schema.Item;
   import com.zmicer.utils.InputArgumentUtils;
  import com.zmicer.utils.LoggingUtils;
  import com.zmicer.utils.ObjectStateUtils;
  import com.zmicer.utils.ReflexionUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  
  /**
   * The abstratc class to implement the IJPattern - provides base facilities for all the IJPattern implementations.
   *
   * todo [zmicer]: tests redesign - move from JPFactoryImpl to this class test
   *
   * $Author::                    $<br/>
   * $Rev::                       $<br/>
   * $Date::                      $<br/>
   */
  public abstract class PatternBase implements IJPattern
  {
      /**
       * Logger instance.
       */
      final public static Logger LOG = Logger.getLogger(PatternBase.class);
  
      /**
       * The castor config object used for the storing business info.
       * <br>
       * For now we use only the name of the section which is get from this castor object, still it is necessary for us in any case -
       * potentially we could start use it but not the {@link JPatternsConfigsBean} which is the JPatterns consumer configuration entry point.
       */
      protected CastorSectionType m_castorSection = null;
  
      /**
       * The config bean - is a wrapper under the Factory castor config bean. We would use it for all the "get" operations. It is convenient
       * as allow us access the sections and business items using the path: section name and business item name.
       */
      protected JPatternsConfigsBean m_configBean = null;
  
      /**
       * @see com.sourceforge.jpatterns.patterns.IJPattern#checkCastorConfig(com.sourceforge.jpatterns.schema.CastorSectionType)
       */
      public abstract boolean checkCastorConfig(CastorSectionType castorSectionType);
  
      /**
       * @see IJPattern#init(com.sourceforge.jpatterns.schema.CastorSectionType,
          com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigsBean)
       */
      public void init(CastorSectionType castorSectionType, JPatternsConfigsBean configBean)
      {
          InputArgumentUtils.checkObjects(castorSectionType, configBean);
          if (!(checkCastorConfig(castorSectionType)))
          {
              final String errorMessage = "Error during initializing the pattern - the provided CastorSectionType object is not of " +
                  "appropriate type. It's scope [" + castorSectionType.getScope() + "], name [" + castorSectionType.getName() + "].";
              LoggingUtils.error(LOG, JPFactoryImpl.class, errorMessage);
              throw new JPConfigException(errorMessage);
          }
          m_castorSection = castorSectionType;
          m_configBean = configBean;
      }
  
      /**
       * @see com.zmicer.utils.model.ICheckable#check()
       */
      public boolean check()
      {
          return (null != m_castorSection && null != m_configBean &&
              !StringUtils.isBlank(m_castorSection.getName()) && !StringUtils.isBlank(m_castorSection.getScope()));
      }
  
      /**
       * Get the actual scope. In the case the provided scope variable is not null - it would be returned, otherwise - the scope of the
       * provided CastorSectionType.
       *
       * @param scope   the scope variable to be checked. Could be null, in this case we would deal with the scope of the section type
       * @param section the castor section scope of which would be used (in any case this object and its scope can not be null)
       *
       * @return the actual scope to be used
       */
      protected String getActualScope(final String scope, final CastorSectionType section)
      {
          InputArgumentUtils.checkObjects(section, section.getScope());
          return (StringUtils.isNotBlank(scope)) ? scope : section.getScope();
      }
  
  
      /**
       * Retrieve the item object from the castor factory storing in this model factory object using the provided information:
       * the name of the business item and the scope provided. In the case scope is blank we use the default scope defined at the
       * castor factory type.
       * note [zmicer]: the CastorNameScopePriorityType item is got here is validated (it has not blank name). The composition of validation
       * could be adjusted.
      *
      * @param nameStorage the name of the Item to be retrieved. Can not be null (otherwise <code>IllegalArgumentException</code> would
      *                    appear).
      * @param scope       the scope we need to use, could be <code>null</code>.
      *
      * @return the Item we would use later for the concrete IJPFactory implementation
      */
     protected Item retrieveItem(final Object nameStorage, final String scope)
     {
         InputArgumentUtils.checkObjects(nameStorage);
         if (!(nameStorage instanceof String) && !(nameStorage instanceof Class))
         {
             logAndThrow("Smth. wrong at the com.sourceforge.jpatterns.patterns.factory.JPFactoryImpl.retrieveItem. Wrong " +
                 "storage for the name is passed. Check the algorithm");
         }
         if (nameStorage instanceof String)
         {
             InputArgumentUtils.checkStrings(true, (String) nameStorage);
         }
         ObjectStateUtils.strongCheck(this);
         final String baseName = (nameStorage instanceof String) ? (String) nameStorage : ReflexionUtils.getBaseName((Class) nameStorage);
         String workingScope = getActualScope(scope, m_castorSection);
 
         final CastorNameScopePriorityType castorNameScopePriorityType =
             m_configBean.getBusinessItem(m_castorSection.getScope(), m_castorSection.getName(), workingScope, baseName);
         if (!(castorNameScopePriorityType instanceof Item))
         {
             throw new JPConfigException("Factory should contains items of Item type inside.");
         }
         if (StringUtils.isBlank(castorNameScopePriorityType.getName()))
         {
             throw new JPConfigException("Smth. wrong with the configuration as the name of the CastorNameScopePriorityType type is " +
                 "required.");
         }
         return (Item) castorNameScopePriorityType;
     }
 
     /**
      * Log the message and then throw it.
      *
      * todo [zmicer]: possible it would be adjusted as it should throw the exception of the two types - depending on the category
      *
      * @param message the not emopty message to be thrown and logged
      *
      * @throws JPConfigException always, using message
      */
     protected void logAndThrow(final String message) throws JPConfigException
     {
         InputArgumentUtils.checkStrings(true, message);
         LoggingUtils.error(LOG, JPFactoryImpl.class, message);
         throw new JPConfigException(message);
     }
 }