package com.sourceforge.jpatterns.core.configuration;
   
   import com.sourceforge.jpatterns.core.JPConstants;
   import com.sourceforge.jpatterns.core.configuration.exceptions.JPInitializationException;
   import com.sourceforge.jpatterns.core.configuration.model.IJPatternsConfigBeansBuilder;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigBaseBean;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigBean;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigsBean;
   import com.sourceforge.jpatterns.schema.JPatternsConfig;
  import com.sourceforge.jpatterns.utils.CastorUtils;
  import com.zmicer.utils.ClassPathUtils;
  import com.zmicer.utils.FileUtils;
  import com.zmicer.utils.InputArgumentUtils;
  import com.zmicer.utils.ResourceUtils;
  import org.apache.log4j.Logger;
  
  import java.io.File;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * The default implementation of the <code>IJPConfiguration</code> interface.
   * <br/>
   * The instance we need to use is configured at the
   * properties file, so there is a way for the developer to override this implementation by the custom one.
   * <br/>
   * Be noticed the consumer custom dir could be rather complicated: use the
   * <code>System.getProperty(PATH_SEPARATOR_KEY)</code> to specify the complicated pathes. it could be provided using JVM parameter (first
   * priority) and props key/value (the second priority). Please review the following constants to be involved into it:
   * {@link com.sourceforge.jpatterns.core.JPConstants.XMLConfigFilesConstants.CUSTOM_XML_CONSUMER_CONFIG_DIR_NAME_JVM_PARAM}
   * {@link com.sourceforge.jpatterns.core.JPConstants.XMLConfigFilesConstants.CUSTOM_XML_CONSUMER_CONFIG_DIR_NAME_PROPS_PARAM}
   * <br/>
   * Please review the following Java Docs to understand the concepts of overriding:
   * {@link com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_FRAMEWORK_XML}
   * {@link com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_CONSUMER_XML}
   * todo: [zmicer] add the possibility to set the values for the custom framework/consumer configuration at the properties file.
   *
   * <br/>
   * note [zmicer]: please review the class members - there are lots of them, they are necessary for the storing the information we may be
   * intersted in the future - so we would be able easily to extend the interface with another method.
   * todo [zmicer]: please reconsider the interface <code>IJPConfigurator</code> methods - seems to be some of them are not necessary.
   *
   * note [zmicer]: check if it is possible to make the reload of the JPatterns configuration on the flight? It could be really necessary for
   * the building some web services related functionality (when the configuration is specified and provided by the web service, and we need
   * to shedule the reloading).
   *
   * $Author:: zmicer             $<br/>
   * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
   * $Date:: 2007-08-28 21:37:07 #$<br/>
   */
  public class JPConfiguratorImpl implements IJPConfigurator
  {
      /**
       * Logger instance.
       */
      final public static Logger LOG = Logger.getLogger(JPConfiguratorImpl.class);
  
      /**
       * The castor based bean stored the configuration of the framework itself (default configuration).
       */
      private JPatternsConfigBean m_defaultFrameworkConfig = null;
  
      /**
       * The castor based bean stored the configuration of the framework itself (custom configuration).
       * <br/>
       * We are storing both configurations for the following reasons:
       * 1. potentially methods could be added are able to deal with the both configurations
       * 2. unit tests for the JPCOnfigurationImpl would use this functionality to check everything properly
       */
      private JPatternsConfigBean m_customFrameworkConfig = null;
  
      /**
       * The castor based bean stored the configuration of the framework itself (merged configuration).
       */
      private JPatternsConfigsBean m_mergedFrameworkConfig = null;
  
      /**
       * The castor based bean stored the configuration of the consumer settings themself (merged default configuration).
       * <br/>
       * One instance of JPatternsConfig - includes all the settings from {@link m_defaultConsumerConfigs}
       */
      private JPatternsConfigsBean m_mergedDefaultConsumerConfig = null;
  
      /**
       * The castor based bean stores the configuration of the consumer settings themself (merged custom configuration).
       * <br/>
       * One instance of JPatternsConfig - includes all the settings from {@link m_customConsumerConfigs}
       */
      private JPatternsConfigsBean m_mergedCustomConsumerConfig = null;
  
      /**
       * Merged consumer config ready to be used.
       */
      private JPatternsConfigsBean m_mergedConsumerConfig = null;
  
      /**
       * Stores the List of the String object - names of the consumer configuration XML files names. It was decided to store this in any case
       * (could be useful for tests and debugging of the framework)
      */
     private List<File> m_consumerConfigurationFiles = new ArrayList<File>();
 
     /**
      * Stores the List of the String object - names of the consumer configuration XML files names. It was decided to store this in any case
      * (could be useful for tests and debugging of the framework)
      */
     private List<File> m_consumerConfigurationCustomFiles = new ArrayList<File>();
 
     /**
      * The value of the property useOnlyCustomFrameworkConfigIfPresent
      */
     private static Boolean useOnlyCustomFrameworkConfigIfPresent = null;
 
     /**
      * The value of the property useOnlyCustomConsumerConfigIfPresent
      */
     private static Boolean useOnlyCustomConsumerConfigIfPresent = null;
 
     /**
      * Default public constructor to allow this functionality to be consructed using the factory and IoC.
      * <br/>
      * The constructor is public to allow instantiating the JPCOnfigurationImpl using the properties files
      *
      * todo [zmicer]: think if this is correct way to initialize the configuration. The init method is not defined at the interface.
      * Also this class could not be called "strong" singleton implementation, so there are ways to hack it. Please investigate and adjust.
      */
     public JPConfiguratorImpl()
     {
         super();
         initConfiguration();
     }
 
     /**
      * Init xml configuration. Please be noticed it is called at the construction time. So it should initialize all the fields of this class
      * before starting using other methods.
      *
      */
     protected void initConfiguration()
     {
         // init static fields we would use later for determining the behaviour of the JPConfiguratorImpl
         final IPropertiesManager manager = PropertiesBasedFactory.getInstance().getPropertiesManager();
         final PropertiesProvider propsProvider = PropertiesProvider.getInstance(manager, false);        
         useOnlyCustomFrameworkConfigIfPresent =
             propsProvider.getBooleanProperty(PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_FRAMEWORK_XML);
         useOnlyCustomConsumerConfigIfPresent =
             propsProvider.getBooleanProperty(PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_CONSUMER_XML);
 
         initFrameworkConfiguration();
         initConsumerConfiguration();
     }
 
     /**
      * Init the framework configuration.
      */
     protected void initFrameworkConfiguration()
     {
         m_defaultFrameworkConfig = obtainJPatternsConfig(getJPatternsFrameworkConfigurationFileName());
         m_customFrameworkConfig = obtainJPatternsConfig(getJPatternsFrameworkCustomConfigurationFileName());
         mergeFrameworkConfigurations();
     }
 
     /**
      * Perform the merging of the framework configurations.
      * <br/>
      * the following rules have power here:
      * 1. in the case custom configuration is not present the default configuration would be used as the merged one.
      * 2. in the case default configuration is not present - the exception appeared.
      * 3. in the case both configurations present and the value of the property
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_FRAMEWORK_XML</code> is true -
      * the custom configuration is used as the merged one.
      * 4. in the case the property is not defined - we consider its value is <code>false</code>
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_FRAMEWORK_XML</code>
      * 5. in the case both configurations present and the value of the property
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_FRAMEWORK_XML</code> is
      * <code>false</code> - configurations are merged using the implementation of the JPatternsConfigBeansBuilder.
      */
     protected void mergeFrameworkConfigurations()
     {
         final IJPatternsConfigBeansBuilder builder = PropertiesBasedFactory.getInstance().getJPatternsConfigBaseBeanBuilder();
         // 01:
         if (!defaultJPatternsFrameworkConfigurationPresents())
         {
             throw new IllegalStateException("The default framework configuration should be present.");
         }
         if (!customJPatternsFrameworkConfigurationPresents())
         {
             if (defaultJPatternsFrameworkConfigurationPresents())
             {
                 final List<JPatternsConfigBaseBean> beans = new ArrayList<JPatternsConfigBaseBean>();
                 beans.add(m_defaultFrameworkConfig);
                 m_mergedFrameworkConfig = builder.build(beans);
                 return;
             }
             else
             {
                 // 02:
                 throw new IllegalStateException("The default framework configuration should be present.");
             }
         }
         // 03:
         if (customJPatternsFrameworkConfigurationPresents() && defaultJPatternsFrameworkConfigurationPresents() &&
             null != useOnlyCustomFrameworkConfigIfPresent && useOnlyCustomFrameworkConfigIfPresent)
         {
             final List<JPatternsConfigBaseBean> beans = new ArrayList<JPatternsConfigBaseBean>();
             beans.add(m_customFrameworkConfig);
             m_mergedFrameworkConfig = builder.build(beans);
             return;
         }
         // 04, 05:
         if ((null != useOnlyCustomFrameworkConfigIfPresent && !useOnlyCustomFrameworkConfigIfPresent) ||
             null == useOnlyCustomFrameworkConfigIfPresent)
         {
             // need to merge the properties. The custom one would override the default framework configuration.
             CastorUtils.makePrioritized(m_customFrameworkConfig.getCastorConfig());
             final List<JPatternsConfigBaseBean> beans = new ArrayList<JPatternsConfigBaseBean>();
             beans.add(m_customFrameworkConfig);
             beans.add(m_defaultFrameworkConfig);
             m_mergedFrameworkConfig = builder.build(beans);
         }
     }
 
     /**
      * Init (obtain, merge etc.) the consumer based configuration.
      * <br/>
      * Be noticed the consumer custom dir could be rather complicated: use the
      * <code>System.getProperty(PATH_SEPARATOR_KEY)</code> to specify the complicated pathes.
      * todo [zmicer]: implement the opportunity to set the directory where the default JPatterns consumer configuration to obtain
      */
     protected void initConsumerConfiguration()
     {
         final IJPatternsConfigBeansBuilder builder = PropertiesBasedFactory.getInstance().getJPatternsConfigBaseBeanBuilder();
         // the todo above placement.
         // 00: init the consumer default configuration (was found at the classpath)
         final String defaultConsumerDir = getJPatternsConsumerConfigurationDirName();
         List<String> classPathesStrings = null;
         if (null != defaultConsumerDir && defaultConsumerDir.length() != 0)
         {
             classPathesStrings = ClassPathUtils.getClassPathes(defaultConsumerDir);
         }
         else
         {
             classPathesStrings = ClassPathUtils.getClassPathes();
         }
 
         if (null == classPathesStrings || classPathesStrings.isEmpty())
         {
             throw new IllegalStateException("The class path is not set correctly.");
         }
         m_consumerConfigurationFiles = FileUtils.findFilesByREInClassPath(classPathesStrings, JPConstants.PATTERN);
 
         // 01: use the consumer custom configuration
         final String consumerCustomDir = getJPatternsConsumerCustomConfigurationDirName();
         if (null == consumerCustomDir)
         {
             LOG.debug("The consumer custom configuration is not provided. The appropriate JPatternsConfig object are not initialized.");
         }
         else
         {
             final List<String> customClassPathesStrings = ClassPathUtils.getClassPathes(consumerCustomDir);
             if (null == customClassPathesStrings || customClassPathesStrings.isEmpty())
             {
                 // custom consumer classpath could be set to the null/empty string etc.
                 return;
             }
             m_consumerConfigurationCustomFiles = FileUtils.findFilesByREInClassPath(customClassPathesStrings, JPConstants.PATTERN);
         }
 
         // 02: set the merged default consumer configuration.
         if (null != m_consumerConfigurationFiles)
         {
             final List<JPatternsConfig> configs = obtainJPatternsConfigs(m_consumerConfigurationFiles);
             final List<JPatternsConfigBaseBean> defaultConsumerConfigs = new ArrayList<JPatternsConfigBaseBean>();
             for (JPatternsConfig config : configs)
             {
                 defaultConsumerConfigs.add(builder.build(config));
             }
             m_mergedDefaultConsumerConfig = builder.build(defaultConsumerConfigs);
         }
 
         // 03: set the custom consumer configuration.
         if (null != m_consumerConfigurationCustomFiles)
         {
             final List<JPatternsConfig> customConfigs = obtainJPatternsConfigs(m_consumerConfigurationCustomFiles);
 
             final List<JPatternsConfigBaseBean> customConsumerConfigs = new ArrayList<JPatternsConfigBaseBean>();
             for (JPatternsConfig config : customConfigs)
             {
                 customConsumerConfigs.add(builder.build(config));
             }
             m_mergedCustomConsumerConfig = builder.build(customConsumerConfigs);
         }
 
         if (null == m_mergedDefaultConsumerConfig && null == m_mergedCustomConsumerConfig)
         {
             throw new JPInitializationException("There is not consumer configuration provided. It is incorrect state for the JPatterns.");
         }
 
         // 04: merge these configurations
         mergeConsumerConfigurations();
     }
 
     /**
      * Perform the merging of the consumer configurations.
      * <br/>
      * the following rules have power here:
      * 1. in the case custom configuration is not present the default configuration would be used as the merged one.
      * 2. in the case default configuration is not present - the exception appeared.
      * 3. in the case both configurations present and the value of the property
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_CONSUMER_XML</code> is true -
      * the custom configuration is used as the merged one.
      * 4. in the case the property is not defined - we consider its value is <code>false</code>
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_CONSUMER_XML</code>
      * 5. in the case both configurations present and the value of the property
      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.USE_ONLY_CUSTOM_CONSUMER_XML</code> is
      * <code>false</code> - configurations are merged using the implementation of the JPatternsConfigBeansBuilder.
      */
     protected void mergeConsumerConfigurations()
     {
         // 01:
         if (!customJPatternsConsumerConfigurationPresents())
         {
             if (defaultJPatternsConsumerConfigurationPresents())
             {
                 m_mergedConsumerConfig = m_mergedDefaultConsumerConfig;
             }
             else
             {
                 // 02:
                 throw new IllegalStateException("The default consumer configuration should be present.");
             }
         }
         // 03:
         if (customJPatternsConsumerConfigurationPresents() && defaultJPatternsConsumerConfigurationPresents() &&
             null != useOnlyCustomConsumerConfigIfPresent && useOnlyCustomConsumerConfigIfPresent)
         {
             m_mergedConsumerConfig = m_mergedCustomConsumerConfig;
         }
         // 04, 05:
         if ((null != useOnlyCustomConsumerConfigIfPresent && !useOnlyCustomConsumerConfigIfPresent) ||
             null == useOnlyCustomConsumerConfigIfPresent)
         {
             // need to merge the properties. The custom one would override the default framework configuration.
             CastorUtils.makePrioritized(m_mergedCustomConsumerConfig);
             final List<JPatternsConfigBaseBean> beans = new ArrayList<JPatternsConfigBaseBean>();
             beans.add(m_mergedCustomConsumerConfig);
             beans.add(m_mergedDefaultConsumerConfig);
             final IJPatternsConfigBeansBuilder builder = PropertiesBasedFactory.getInstance().getJPatternsConfigBaseBeanBuilder();
             m_mergedConsumerConfig = builder.build(beans);
         }
     }
 
     /**
      * Obtain the List of {@link JPatternsConfig} objects by the List of the File objects specified.
      *
      * @param files the List of the File objects Can not be null (otherwise <code>IllegalArgumentException</code> would appear).
      * @return the List of JPatternsConfig objects
      */
     protected List<JPatternsConfig> obtainJPatternsConfigs(final List<File> files)
     {
         if (null == files)
         {
             throw new IllegalArgumentException("The List of File objects can not be null.");
         }
         final List<JPatternsConfig> result = new ArrayList<JPatternsConfig>();
         for (final File file : files)
         {
             final JPatternsConfig config = CastorUtils.getJPatternsConfig(file);
             if (null != config)
             {
                 result.add(config);
             }
         }
         return result;
     }
 
     /**
      * Obtain the <code>JPatternsConfig</code> using the provided file name (it could be: 1. just file name without passes,
      * 2. the full file name 3. relative name)
      * <br/>
      * The following order for obtaining this {@link com.sourceforge.jpatterns.schema.JPatternsConfig} class is used:
      * <ul>
      * <li>Using the classloaders</li>
      * <li>Trying to open the file with the provided name using <code>File</code></li>
      * </ul>
      *
      * @param name the name of the file to be obtain. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).
      * @return the castor <code>JPatternsConfig</code> woth the settings we need for the further working.
      */
     protected JPatternsConfigBean obtainJPatternsConfig(final String name)
     {
         InputArgumentUtils.checkStrings(true, name);
         JPatternsConfig result = null;
         final IJPatternsConfigBeansBuilder builder = PropertiesBasedFactory.getInstance().getJPatternsConfigBaseBeanBuilder();
         //00 classloaders
         final URL url = ResourceUtils.getResource(name);
         if (url != null)
         {
             final File file = new File(url.getFile());
             result = CastorUtils.getJPatternsConfig(file);
             if (null != result)
             {
                 LOG.debug("The JPatterns configuration was obtained using the classloaders (ResourceUtils.getResource) for the name " +
                     name);
                 if (null == builder)
                 {
                     throw new IllegalStateException("The IJPatternsConfigBeansBuilder instance can not be null.");
                 }
                 return builder.build(result);
             }
         }
         // 01 just thinking it is the full file name
         final File file = new File(name);
         if (file.isFile())
         {
             // the case when e.g. JVM param was set to the full/relative path to override the default one
             result = CastorUtils.getJPatternsConfig(file);
             if (null != result)
             {
                 LOG.debug("The JPatterns configuration was obtained using the File for the name " +
                     name);
                 return builder.build(result);
             }
         }
         return null;
     }
 
     /**
      * @see IJPConfigurator#getJPatternsFrameworkConfigurationFileName()
      *      <br/>
      *      The way this name is obtained:
      *      1. In the case JVM parameter is specified - it is returns. Please be noticed the JVM parameter could specify both file name and
      *      full pathed file name
      * todo [zmicer]: check if this item is fully supported here.
      *      2. Then the properties based value is checked.
      *      <code>JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME_PROPS_PARAM<code>
      *      3. Then the default name {@link JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME} is returned.
      */
     public String getJPatternsFrameworkConfigurationFileName()
     {
         final String jvmDefault = System.getProperty(JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME_JVM_PARAM);
         if (null != jvmDefault && !"".equals(jvmDefault.trim()))
         {
             LOG.debug("Please be noticed the JVM param based value for the default XML is used. This value is : " + jvmDefault);
             return jvmDefault;
         }
         final IPropertiesManager propsManager = PropertiesBasedFactory.getInstance().getPropertiesManager();
         if (null == propsManager)
         {
             throw new IllegalStateException("Smth. wrong with the core initialization. Properties manager can not be null.");
         }
         final String propsValue =
             propsManager.getBundle(JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME_PROPS_PARAM);
         if (null != propsValue && !"".equals(propsValue.trim()))
         {
             LOG.debug("The properties defined value is used for the JPatterns framework default configuration.");
             return propsValue;
         }
         LOG.debug("The default not JVM based value is used : " +
             JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME);
         return JPConstants.XMLConfigFilesConstants.DEFAULT_XML_FRAMEWORK_CONFIG_FILE_NAME;
     }
 
     /**
      * @see IJPConfigurator#getJPatternsFrameworkCustomConfigurationFileName()
      * <br/>
      * Take an attention at this above method: getJPatternsFrameworkConfigurationFileName
      */
     public String getJPatternsFrameworkCustomConfigurationFileName()
     {
         final String jvmDefault = System.getProperty(JPConstants.XMLConfigFilesConstants.CUSTOM_XML_FRAMEWORK_CONFIG_FILE_NAME_JVM_PARAM);
         if (null != jvmDefault && !"".equals(jvmDefault.trim()))
         {
             LOG.debug("Please be noticed the JVM param based value for the default custom XML is used. This value is : " + jvmDefault);
             return jvmDefault;
         }
         final IPropertiesManager propsManager = PropertiesBasedFactory.getInstance().getPropertiesManager();
         if (null == propsManager)
         {
             throw new IllegalStateException("Smth. wrong with the core initialization. Properties manager can not be null.");
         }
         final String propsValue =
             propsManager.getBundle(JPConstants.XMLConfigFilesConstants.CUSTOM_XML_FRAMEWORK_CONFIG_FILE_NAME_PROPS_PARAM);
         if (null != propsValue && !"".equals(propsValue.trim()))
         {
             LOG.debug("The properties defined value is used for the JPatterns framework custom configuration.");
             return propsValue;
         }
         LOG.debug("The default custom not JVM based value is used : " +
             JPConstants.XMLConfigFilesConstants.CUSTOM_XML_FRAMEWORK_CONFIG_FILE_NAME);
         return JPConstants.XMLConfigFilesConstants.CUSTOM_XML_FRAMEWORK_CONFIG_FILE_NAME;
     }
 
     /**
      * @see com.sourceforge.jpatterns.core.configuration.IJPConfigurator#getJPatternsConsumerConfigurationFiles()
      */
     public List<File> getJPatternsConsumerConfigurationFiles()
     {
         return m_consumerConfigurationFiles;
     }
 
     /**
      * @see com.sourceforge.jpatterns.core.configuration.IJPConfigurator#getJPatternsConsumerCustomConfigurationFiles()
      */
     public List<File> getJPatternsConsumerCustomConfigurationFiles()
     {
         return m_consumerConfigurationCustomFiles;
     }
 
     /**
      * The first priority takes the JVM parameter, then - the properties file value.
      * <br/>
      * Please be noticed this string could be either dir or the list of dirs or the list of dirs and xml files. Please review the
      * <code>com.zmicer.utils.ClassPathUtils#getClassPathes()</code> for it. Also
      * <code>com.zmicer.utils.FileUtils#findFilesByREInClassPath(java.util.List<java.lang.String>, java.util.regex.Pattern)</code>
      * could help in providing the info.
      *
      * @return the String value pointing to the dir where the consumer specific custom configuration (not the xml pointed at the
      * classpath) are present.
      */
     public String getJPatternsConsumerCustomConfigurationDirName()
     {
         final String jvmDefautlt = System.getProperty(JPConstants.XMLConfigFilesConstants.CUSTOM_XML_CONSUMER_CONFIG_DIR_NAME_JVM_PARAM);
         if (null != jvmDefautlt && !"".equals(jvmDefautlt.trim()))
         {
             LOG.debug("Please be noticed the JVM param based value for the custom consumer XML is used. This value is : " + jvmDefautlt);
             return jvmDefautlt;
         }
         final IPropertiesManager propsManager = PropertiesBasedFactory.getInstance().getPropertiesManager();
         if (null == propsManager)
         {
             throw new IllegalStateException("Smth. wrong with the core initialization. Properties manager can not be null.");
         }
         final String propsValue =
             propsManager.getBundle(JPConstants.XMLConfigFilesConstants.CUSTOM_XML_CONSUMER_CONFIG_DIR_NAME_PROPS_PARAM);
         if (null != propsValue && !"".equals(propsValue.trim()))
         {
             LOG.debug("The properties defined value is used for the consumer custom configuration.");
             return propsValue;
         }
         LOG.debug("The consumer custom configuration is not provided.");
         return null;
     }
 
     /**
      * The first priority takes the JVM parameter, then - the properties file value.
      * <br/>
      * Please be noticed this string could be either dir or the list of dirs or the list of dirs and xml files. Please review the
      * <code>com.zmicer.utils.ClassPathUtils#getClassPathes()</code> for it. Also
      * <code>com.zmicer.utils.FileUtils#findFilesByREInClassPath(java.util.List<java.lang.String>, java.util.regex.Pattern)</code>
      * could help in providing the info.
      *
      * @return the String value pointing to the dir where the consumer specific custom configuration (not the xml pointed at the
      * classpath) are present.
      */
     public String getJPatternsConsumerConfigurationDirName()
     {
         final String jvmDefautlt = System.getProperty(JPConstants.XMLConfigFilesConstants.DEFAULT_XML_CONSUMER_CONFIG_DIR_NAME_JVM_PARAM);
         if (null != jvmDefautlt && !"".equals(jvmDefautlt.trim()))
         {
             LOG.debug("Please be noticed the JVM param based value for the default consumer XML is used. This value is : " + jvmDefautlt);
             return jvmDefautlt;
         }
         final IPropertiesManager propsManager = PropertiesBasedFactory.getInstance().getPropertiesManager();
         if (null == propsManager)
         {
             throw new IllegalStateException("Smth. wrong with the core initialization. Properties manager can not be null.");
         }
         final String propsValue =
             propsManager.getBundle(JPConstants.XMLConfigFilesConstants.DEFAULT_XML_CONSUMER_CONFIG_DIR_NAME_PROPS_PARAM);
         if (null != propsValue && !"".equals(propsValue.trim()))
         {
             LOG.debug("The properties defined value is used for the consumer custom configuration.");
             return propsValue;
         }
         LOG.debug("The consumer custom configuration is not provided.");
         return null;
     }
 
     /**
      * @see IJPConfigurator#defaultJPatternsFrameworkConfigurationPresents()
      */
     public boolean defaultJPatternsFrameworkConfigurationPresents()
     {
         return (m_defaultFrameworkConfig != null);
     }
 
     /**
      * @see IJPConfigurator#customJPatternsConsumerConfigurationPresents()
      */
     public boolean customJPatternsFrameworkConfigurationPresents()
     {
         return (m_customFrameworkConfig != null);
     }
 
     /**
      * @see IJPConfigurator#defaultJPatternsConsumerConfigurationPresents()
      */
     public boolean defaultJPatternsConsumerConfigurationPresents()
     {
         return (m_mergedDefaultConsumerConfig != null && null != m_mergedDefaultConsumerConfig.getListOfSectionItems() &&
             !m_mergedDefaultConsumerConfig.getListOfSectionItems().isEmpty());
     }
 
     /**
      * @see IJPConfigurator#customJPatternsConsumerConfigurationPresents()
      */
     public boolean customJPatternsConsumerConfigurationPresents()
     {
         return (m_mergedCustomConsumerConfig != null && null != m_mergedCustomConsumerConfig.getListOfSectionItems() &&
             !m_mergedCustomConsumerConfig.getListOfSectionItems().isEmpty());
     }
 
     /**
      * @see com.sourceforge.jpatterns.core.configuration.IJPConfigurator#getJPatternsFrameworkConfiguration()
      */
     public JPatternsConfigsBean getJPatternsFrameworkConfiguration()
     {
         return m_mergedFrameworkConfig;
     }
 
     /**
      * @see com.sourceforge.jpatterns.core.configuration.IJPConfigurator#getJPatternsConsumerConfiguration()
      */
     public JPatternsConfigsBean getJPatternsConsumerConfiguration()
     {
         return m_mergedConsumerConfig;
     }
 
     /**
      * Set the value for the property useOnlyCustomFrameworkConfigIfPresent
      *
      * @param value the value to be set to this property. Could be null - it means that the property is not defined at all.
      */
     protected static void setUseOnlyCustomFrameworkConfigIfPresent(final Boolean value)
     {
         useOnlyCustomFrameworkConfigIfPresent = value;
     }
 }