package com.sourceforge.jpatterns.core;

 import com.sourceforge.jpatterns.core.configuration.PropertiesBasedFactory;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPConfigException;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPConsumerConfigException;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPFrameworkConfigException;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPInitializationException;

 import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigsBean;

 import com.sourceforge.jpatterns.patterns.IJPattern;

 import com.sourceforge.jpatterns.patterns.config.IJPConfig;

 import com.sourceforge.jpatterns.patterns.factory.IJPFactory;

 import com.sourceforge.jpatterns.schema.CastorSectionType;

 import com.sourceforge.jpatterns.schema.Factory;

 import com.zmicer.utils.InputArgumentUtils;

 import com.zmicer.utils.LoggingUtils;

 import com.zmicer.utils.ReflexionUtils;

 import org.apache.log4j.Logger;

 /**

  * The concrete, JPatterns "default" implementation.

  * <p/>

  * $Author:: zmicer             $<br/>

  * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>

  * $Date:: 2007-08-28 21:37:07 #$<br/>

  */

 public class JPEngineImpl implements IJPEngine

 {

     /**

      * Logger instance.

      */

     final public static Logger LOG = Logger.getLogger(JPConstants.LoggingCategory.OBTAIN_PATTERNS.toString());

     /**

      * Category to be set.

      */

     private JPConstants.EngineConfigCaregory m_category;

     /**

      * The instance of the factory would be used for the plugins

      */

     private IJPFactory m_pluginFactory = null;

     /**

      * Default public constructor.

      */

     public JPEngineImpl()

     {

         super();

     }

     /**

      * @see IJPEngine#init(com.sourceforge.jpatterns.core.JPConstants.EngineConfigCaregory)

      */

     public void init(JPConstants.EngineConfigCaregory category)

     {

         InputArgumentUtils.checkObjects(category);

         m_category = category;

     }

     /**

      * @see IJPEngine#init(com.sourceforge.jpatterns.core.JPConstants.EngineConfigCaregory)

      */

     public JPConstants.EngineConfigCaregory getCategory()

     {

         return m_category;

     }

     /**

      * @see IJPEngine#isInitialized()

      */

     public boolean isInitialized()

     {

         return (m_category != null);

     }

     /**

      * @see IJPEngine#getFactory(java.lang.String,java.lang.String)

      */

     public IJPFactory getFactory(final String factoryName, final String scope)

     {

         final CastorSectionType castorObject = getCastorSectionType(factoryName, scope);

         if (!(castorObject instanceof Factory))

         {

             logAndThrow("The CastorSectionType found using the provided name and scope is not of the type " +

                 "of Factory - please check the JPatterns configuration. The actual class name is [" +

                 castorObject.getClass().getName() + "]");

         }

         final JPatternsConfigsBean bean = getCategoryJPatternsConfigsBean();

         IJPFactory factory = PropertiesBasedFactory.getInstance().instantiateFactory();

         factory.init((Factory) castorObject, bean);

         LoggingUtils.debug(LOG, JPEngineImpl.class, "Factory for the parameters factory name [" + factoryName + "], scope [" +

             scope + "] was onbtained succesfully");

         return factory;

     }

     /**

      * @see com.sourceforge.jpatterns.core.IJPEngine#getPattern(String,String)

      */

     public IJPattern getPattern(final String patternName, final String scope)

     {

         // 1: get the necessary object to proceed later with

         final JPatternsConfigsBean bean = getCategoryJPatternsConfigsBean();

         final CastorSectionType castorObject = getCastorSectionType(patternName, scope);

         // 2: retrieve the pattern, make all the necessary validations

         final Object patternObject =

             getPluginFactory().getImplementation(JPConstants.FrameworkConfigEntities.ITEM_JPATTERNS_PLUGIN,

                 ReflexionUtils.getBaseName(castorObject.getClass()).toLowerCase(), null);

         final String message = "name [" + patternName + "], scope [" + scope + "], configuration type [" +

             ReflexionUtils.getBaseName(castorObject.getClass()).toLowerCase() + "].";

         if (null == patternObject)

         {

             logAndThrow("Can not retrive the pattern for the " + message);

         }

         if (!(patternObject instanceof IJPattern))

         {

             logAndThrow("The pattern with " + message + " is not of the type IJPattern.");

         }

         // 3: cast to the pattern, init and return the pattern

         final IJPattern pattern = (IJPattern) patternObject;

         pattern.checkCastorConfig(castorObject);

         pattern.init(castorObject, bean);

         LoggingUtils.debug(LOG, JPEngineImpl.class, "IJPattern for the parameters factory name [" + patternName + "], scope [" +

             scope + "] was onbtained succesfully");

         return pattern;

     }

     /**

      * @see IJPEngine#getConfig(java.lang.String, java.lang.String)

      */

     public IJPConfig getConfig(final String configName, final String scope)

     {

         // 1: get pattern

         final IJPattern pattern = getPattern(configName, scope);

         // 2: validate it has the necssary type

         if (!(pattern instanceof IJPConfig))

         {

             logAndThrow("The found IJPattern is not of the IJPConfig type. Config name [" + configName + "], scope [" + scope + "]");

         }

         return (IJPConfig) pattern;

     }

     /**

      * Get the castor section type using the provided input data

      *

      * @param name  the name of the section to be retrived, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param scope the name of the scope to be retrived, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      *

      * @return the castor section type to be used.

      */

     protected CastorSectionType getCastorSectionType(final String name, final String scope)

     {

         checkIsInitialized();

         InputArgumentUtils.checkStrings(true, name);

         final String actualScope = (null == scope || "".equals(scope)) ? JPConstants.DEFAULT_SCOPE_NAME : scope;

         LoggingUtils.debug(LOG, JPEngineImpl.class, "Trying to obtain the pattern using factory name [" + name + "], scope [" +

             actualScope + "].");

         final JPatternsConfigsBean bean = getCategoryJPatternsConfigsBean();

         CastorSectionType castorObject = bean.getSection(actualScope, name);

         if (null == castorObject)

         {

             logAndThrow("Have not found the configuration for the pattern name [" + name + "], scope [" + actualScope + "].");

         }

         return castorObject;

     }

     /**

      * Get factory is used for the retriving the plugin configurations

      *

      * @return the instance of IJPFactory.

      */

     protected IJPFactory getPluginFactory()

     {

         if (null != m_pluginFactory)

         {

             return m_pluginFactory;

         }

         // obtain the factory we need

         m_pluginFactory = JPEngineFactory.getJPEngine(JPConstants.EngineConfigCaregory.FRAMEWORK).

             getFactory(JPConstants.FrameworkConfigEntities.FACTORY_JPATTERNS_CORE, null);

         if (null == m_pluginFactory)

         {

             logAndThrow("Can not instantiate plugin factory. The factory name we use [" + JPConstants.EngineConfigCaregory.FRAMEWORK + "], " +

                 "default scope");

         }

         return m_pluginFactory;

     }

     /**

      * @return the {@link JPatternsConfigsBean specific for the pointed category}

      */

     protected JPatternsConfigsBean getCategoryJPatternsConfigsBean()

     {

         checkIsInitialized();

         if (m_category.equals(JPConstants.EngineConfigCaregory.CONSUMER))

         {

             return PropertiesBasedFactory.getInstance().getJPConfigurator().getJPatternsConsumerConfiguration();

         }

         else if (m_category.equals(JPConstants.EngineConfigCaregory.FRAMEWORK))

         {

             return PropertiesBasedFactory.getInstance().getJPConfigurator().getJPatternsFrameworkConfiguration();

         }

         logAndThrow("Can'not obtain the JPatternsConfigsBean to be used");

         return null;

     }

     /**

      * Check if the instance of initialized.

      */

     protected void checkIsInitialized()

     {

         if (!isInitialized())

         {

             final String message = "The instance of the Engine is not initialized.";

             LoggingUtils.error(LOG, JPEngineImpl.class, message);

             throw new JPInitializationException(message);

         }

     }

     /**

      * Log the message and then throw it.

      *

      * @param message the not emopty message to be thrown and logged

      *

      * @throws com.sourceforge.jpatterns.core.configuration.exceptions.JPConfigException

      *          always, using message

      */

     protected void logAndThrow(final String message) throws JPConfigException

     {

         checkIsInitialized();

         InputArgumentUtils.checkStrings(true, message);

         LoggingUtils.error(LOG, JPEngineImpl.class, message);

         if (m_category.equals(JPConstants.EngineConfigCaregory.CONSUMER))

         {

             throw new JPConsumerConfigException(message);

         }

         else if (m_category.equals(JPConstants.EngineConfigCaregory.FRAMEWORK))

         {

             throw new JPFrameworkConfigException(message);

         }

         else

         {

             throw new JPConfigException(message);

         }

     }

 }