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);

     }

 }