package com.sourceforge.jpatterns.utils;
   
   import com.sourceforge.jpatterns.core.JPConstants;
   import com.sourceforge.jpatterns.core.configuration.IPropertiesManager;
   import com.sourceforge.jpatterns.core.configuration.PropertiesManagerImpl;
   import com.zmicer.utils.LoggingUtils;
   import com.zmicer.utils.ReflexionUtils;
   import com.zmicer.utils.ResourceUtils;
   import com.zmicer.utils.ZmicerUtilsConstants;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  
  import java.util.ResourceBundle;
  
  /**
   * This class the common JPatterns based methods for working with property files.
   *
   * $Author:: zmicer             $<br/>
   * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
   * @forversion 1.0.1
   */
  public class JPatternsPropsUtils
  {
      /**
       * Logger instance.
       */
      final public static Logger LOG = Logger.getLogger(ZmicerUtilsConstants.LoggingCategory.PROPERTIES_RELATED.toString());
  
      /**
       * The default bundle to be used.
       */
      public static ResourceBundle defaultBundle;
  
      /**
       * The custom bundle to be used.
       */
      public static ResourceBundle customBundle;
  
      /**
       * @return the name of the resource bundle file should be used for the default JPatterns properties configuration.
       * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
       */
      public static String getDefaultBundleName()
      {
          final String jvmDefautlt = System.getProperty(JPConstants.PropertiesConfigFilesConstants.DEFAULT_PROPERTIES_FILE_NAME_JVM_PARAM);
          if (null != jvmDefautlt && !"".equals(jvmDefautlt.trim()))
          {
              LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "Please be noticed the JVM provided value for the default props is used [" +
                  jvmDefautlt + "]");
              return jvmDefautlt;
          }
          LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "The default (not JVM based) value is used [" +
              JPConstants.PropertiesConfigFilesConstants.DEFAULT_PROPERTIES_FILE_NAME + "]");
          return JPConstants.PropertiesConfigFilesConstants.DEFAULT_PROPERTIES_BASE_NAME;
      }
  
      /**
       * @return the name of the resource bundle file should be used for the custom JPatterns properties configuration.
       * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
       */
      public static String getCustomBundleName()
      {
          final String jvmCustom = System.getProperty(JPConstants.PropertiesConfigFilesConstants.CUSTOM_PROPERTIES_FILE_NAME_JVM_PARAM);
          if (null != jvmCustom && !"".equals(jvmCustom.trim()))
          {
              LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "Please be noticed the JVM param value is used for custom props [" +
                  jvmCustom + "]");
              return jvmCustom;
          }
          LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "The default (not JVM based value is used for custom props file name [" +
              JPConstants.PropertiesConfigFilesConstants.CUSTOM_PROPERTIES_FILE_NAME + "]");
          return JPConstants.PropertiesConfigFilesConstants.CUSTOM_PROPERTIES_BASE_NAME;
      }
  
      /**
       * Return the implementation of the IPropertiesManager. For this we would obtain default/custom bundles. Pleaes be noticed they would
       * be stored to {@link m_defaultBundle} and {@link m_customBundle} to be able to use them later by the implementation of the
       * PropertiesManagerImpl without additional retrieving of the bundles.
       *
       * @return the implementation of the IPropertiesManager using the default/custom properties files. First of all the custom would be
       *         checked, then the default one, and then if the implementation is not specified - default implementation would be obtained
       *         (<code>PropertiesManagerImpl class</code>)
       * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
       */
      public static IPropertiesManager getPropertiesManagerImplementation()
      {
          final String defaultProps = JPatternsPropsUtils.getDefaultBundleName();
          final String customProps = JPatternsPropsUtils.getCustomBundleName();
          if (null == defaultProps)
          {
              throw new IllegalStateException("The name of default configuration can not be null.");
          }
          defaultBundle = ResourceUtils.getResourceBundle(defaultProps);
          customBundle = ResourceUtils.getResourceBundle(customProps);
          String className = null;
          if (null != customBundle)
          {
              try
              {
                 className = customBundle.getString(ReflexionUtils.getBaseName(IPropertiesManager.class));
             }
             catch (Exception ex)
             {
                 // just nothing
             }
             if (null != className)
             {
                 LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "The implementation of IPropertiesManager was found at the custom " +
                     "properties file [" + customProps + "], implementation is [" + className + "]");
             }
         }
         if (StringUtils.isBlank(className) && null != defaultBundle)
         {
             try
             {
                 className = defaultBundle.getString(ReflexionUtils.getBaseName(IPropertiesManager.class));
             }
             catch (Exception ex)
             {
                 // just nothing
             }
             if (null != className)
             {
                 LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "The implementation of IPropertiesManager was found at the default " +
                     "properties file [" + defaultProps + "]," + "implementation is [" + className + "]");
             }
         }
         if (StringUtils.isBlank(className))
         {
             LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "The default PropertiesManagerImpl implementation of the " +
                 "IPropertiesManager is used [" + ReflexionUtils.getBaseName(PropertiesManagerImpl.class) + "]");
             return new PropertiesManagerImpl();
         }
         else
         {
             final Object object = ReflexionUtils.reflectObject(className, true);
             if (null == object || !(object instanceof IPropertiesManager))
             {
                 LoggingUtils.debug(LOG, JPatternsPropsUtils.class, "Can not instantiate the implementation of the IPropertiesManager " +
                     "using class name [" + className + "]. The returned object type [" +
                     ((null != object) ? object.getClass().getName() : "null was returned") + "]");
                 return null;
             }
             else
             {
                 return (IPropertiesManager) object;
             }
         }
     }
 
 
     public static ResourceBundle getDefaultBundle()
     {
         return defaultBundle;
     }
 
     public static void setDefaultBundle(ResourceBundle defaultBundle)
     {
         JPatternsPropsUtils.defaultBundle = defaultBundle;
     }
 
     public static ResourceBundle getCustomBundle()
     {
         return customBundle;
     }
 
     public static void setCustomBundle(ResourceBundle customBundle)
     {
         JPatternsPropsUtils.customBundle = customBundle;
     }
 }