/*

  * Copyright 1999-2002,2004 The Apache Software Foundation.

  * 

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.latka;

 import java.io.InputStream;

 import java.io.IOException;

 import java.util.Properties;

 import org.apache.log4j.Category;

 /**

  * Stores properties for Latka.  This class is backed by a 

  * ThreadLocal variable, so every Thread is guaranteed to

  * get a unique Properties object.  Note, however, that

  * inside an environment utilizing a Thread pool, such

  * as many Servlet engines, it is possible for 

  * the Properties object to travel quite widely.  Use the

  * {@link #resetProperties()} method to reset the Properties

  * object for a Thread to its default values.

  * 

  * @author Morgan Delagrange

  * @author dIon Gillard (javadoc changes)

  */

 public class LatkaProperties {

     /** log4j category to append output to */

     protected static final Category _log =

         Category.getInstance(LatkaProperties.class);

     /** default Properties file for Latka */

     protected static Properties _initProps = loadDefaultProps();

     static {

         _initProps.putAll(loadUserProps());

     }

     /**

      * This ThreadLocal is automatically instantiated per thread

      * with a Properties object containing the default properties.

      */

     protected static ThreadLocal _propsThreadLocal =

         new LatkaThreadLocal(_initProps);

     /**

      * Returns the unique Properties object for the current

      * Thread.  The Properties object is initialized with

      * the default Latka Properties.

      * 

      * @return Latka Properties object 

      */

     public static Properties getProperties() {

         return (Properties) _propsThreadLocal.get();

     }

     /**

      * Resets the Latka properties to their initial value

      * (getProperties() will still return the same Object).

      * One use for this method is to reset state inside

      * a Thread-pooling environment.

      */

     public static void resetProperties() {

         Properties props = (Properties) _propsThreadLocal.get();

         props.clear();

         props.putAll(_initProps);

     }

     /**

      * Loads the default Properties from the 

      * first "latka.properties" file located encountered 

      * in the classpath.

      * 

      * @return A Properties object generated from the contents of the

      *         default property file

      */

     protected static Properties loadDefaultProps() {

         Properties properties  = new Properties();

         try {

             properties.putAll(

                        loadPropsFromClasspath("latka.properties.internal"));

         } catch (IOException e) {

             _log.error(

                 "Couldn't find latka.properties.internal file in the classpath",

                 e);

         }

         return properties;

     }

     /**

      * Load <em>latka.properties</em> from classpath

      * @return loaded properties

      */

     protected static Properties loadUserProps() {

         Properties properties  = new Properties();

         try {

             properties.putAll(loadPropsFromClasspath("latka.properties"));

         } catch (IOException e) {

             _log.debug(e);

             _log.warn(

              "No user-defined latka.properties file in the classpath (optional)"

                      );

         }

         return properties;

     }

     /**

      * Load properties specified from context class path

      * @param classpathLocation Resource name to load

      * @throws IOException from loading resource

      * @return initialized properties object

      */

     protected static Properties

                      loadPropsFromClasspath(String classpathLocation)

                      throws IOException {

         Properties properties  = new Properties();

         ClassLoader loader = Thread.currentThread().getContextClassLoader();

         if (loader == null) {

                 // there may not be a context class loader

                 loader = LatkaProperties.class.getClassLoader();

         }

         InputStream stream = loader.getResourceAsStream(classpathLocation);

         if (stream == null) {

             throw new IOException("Could not find this file in classpath: "

                 + classpathLocation);

         }

         properties.load(stream);

         return properties;

     }

     /**

      * Custom ThreadLocal class that automatically initialized

      * the default Properties for the Thread.

      * 

      * @author Morgan Delagrange

      */

     private static class LatkaThreadLocal extends ThreadLocal {

         /** default properties for the thread */

         protected Properties _initProps = null;

         /**

          * Constructor specifying the default Properties object

          * for Latka

          * 

          * @param initProps default Properties object

          */

         public LatkaThreadLocal(Properties initProps) {

             _initProps = initProps;

         }

         /**

          * Returns a clone of the default Properties file

          * for Latka

          * 

          * @return Latka Properties file for the current Thread

          */

         protected Object initialValue() {

             return _initProps.clone();

         }

     }

 }