/*
    * Copyright (C) 2006  Tom Gibara
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package com.tomgibara.pronto.config.impl;
  
  import static java.util.logging.Level.WARNING;
  import static java.util.logging.Level.FINER;
  import static java.util.logging.Level.FINEST;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.logging.Logger;
  
  import com.tomgibara.pronto.config.Config;
  import com.tomgibara.pronto.config.ConfigPolicy;
  import com.tomgibara.pronto.config.ConfigSource;
  import com.tomgibara.pronto.config.DefaultConfigPolicy;
  import com.tomgibara.pronto.config.ProntoConfigException;
  import com.tomgibara.pronto.util.Arguments;
  import com.tomgibara.pronto.util.Classes;
  import com.tomgibara.pronto.util.Objects;
  import com.tomgibara.pronto.util.Strings;
  
  /**
   * Standard implementation of Config interface.
   * 
   * @author Tom Gibara
   * 
   */
  
  // TODO consider adding support for fields which are interfaces, or concrete
  // classes (constructors or setters)
  class ConfigImpl implements Config {
  
      // statics
  
      /**
       * The policy to be used if none (or null) is specified.
       */
  
      private static final ConfigPolicy DEFAULT_POLICY = new DefaultConfigPolicy();
  
      /**
       * The log for exceptions and other log worthy events.
       */
  
      private static final Logger LOGGER = Logger.getLogger(ConfigImpl.class.getPackage().getName());
  
      // fields
  
      /**
       * A lock synchronizing access to the source and properties fields.
       */
      private final Object lock = new Object();
  
      /**
       * A key factory which is used for generating keys during population of the
       * properties map. Access to this field requires the lock.
       */
      private final ConfigKeyFactory factory = new ConfigKeyFactory();
  
      /**
       * Maps parameterizations to the proxies they generate. Access to this field
       * requires the lock.
       */
      private final HashMap<Params, Object> proxies;
  
      /**
       * The class loader to be used for creating proxies and the values returned
       * from them.
       */
      private final ClassLoader classLoader;
  
      /**
      * The object which provides the raw properties.
      */
     private final ConfigSource source;
 
     /**
      * The policy for this config.
      */
     private ConfigPolicy policy;
 
     /**
      * Maps keys to the properties last obtained from the source. Access to this
      * field requires the lock.
      */
     private HashMap<ConfigKey, String> properties;
 
     /**
      * The time at which the current properties were declared to have been
      * modified by the source. Access to this field requires the lock.
      */
     private long lastModified;
 
     /**
      * The time at which the source was last checked for changes in its
      * properties. Access to this field requires the lock.
      */
     private long lastCheck;
 
     // constructors
 
     /**
      * A constructor which clones an existing config.
      * 
      * @param that
      *            the config to be cloned
      */
 
     private ConfigImpl(final ConfigImpl that) {
         this.policy = that.policy;
         this.source = that.source;
         this.classLoader = that.classLoader;
         synchronized (that.lock) {
             this.properties = that.properties;
             this.proxies = new HashMap<Params, Object>(that.proxies);
             this.lastModified = that.lastModified;
             this.lastCheck = that.lastCheck;
         }
     }
 
     /**
      * A constructor which clones an existing config and specifies a different
      * class loader to use.
      * 
      * @param that
      *            the config to be cloned
      * @param classLoader
      *            the classLoader to be used this object, may be null
      */
 
     private ConfigImpl(final ConfigImpl that, final ClassLoader classLoader) {
         this.policy = that.policy;
         this.source = that.source;
         this.classLoader = classLoader;
         synchronized (that.lock) {
             this.properties = that.properties;
             this.proxies = new HashMap<Params, Object>(); // lose their cache
             // - possibly
             // different class
             // loader made them
             this.lastModified = that.lastModified;
             this.lastCheck = that.lastCheck;
         }
     }
 
     /**
      * Constructs a new config.
      * 
      * @param source
      *            the source of configuration properties, not null
      * @param classLoader
      *            the class loader for creating interface implementations and
      *            value objects, may be null
      * 
      * @throws ProntoConfigException
      *             if the properties could not be accessed and the policy is to
      *             throw exceptions
      */
 
     public ConfigImpl(final ConfigSource source, final ClassLoader classLoader) throws ProntoConfigException {
         Arguments.notNull(source, "source");
         this.source = source;
         this.classLoader = classLoader;
         policy = DEFAULT_POLICY;
         proxies = new HashMap<Params, Object>();
         lastModified = -1;
         lastCheck = -1;
         readProperties();
     }
 
     // accessors
 
     public void setPolicy(ConfigPolicy policy) {
         if (policy == null) policy = DEFAULT_POLICY;
         this.policy = policy;
     }
 
     public ConfigPolicy getPolicy() {
         return policy;
     }
 
     public ClassLoader getClassLoader() {
         return classLoader;
     }
 
     public ConfigSource getSource() {
         return source;
     }
 
     // methods
 
     public <T> T adaptSettings(String domain, boolean inherit, Class<T> iface) throws IllegalArgumentException {
         Arguments.notNull(iface, "iface");
         if (!iface.isInterface()) throw new IllegalArgumentException(String.format("iface not an interface: %s", iface));
 
         synchronized (lock) {
             ConfigKey key = domain == null ? null : factory.newKey(domain);
             return checkCreateImpl(key, inherit, iface);
         }
     }
 
     public String getProperty(String name) throws ProntoConfigException {
         synchronized (lock) {
             checkProperties();
             // optimization: factory will not create a new key if the key is
             // unknown
             ConfigKey key = factory.newKey(name);
             String value = key == null ? null : properties.get(key);
             if (LOGGER.isLoggable(FINEST)) LOGGER.log(FINEST, "{0}={1}", new Object[] { name, value });
             return value;
         }
     }
 
     public ConfigImpl forClassLoader(ClassLoader classLoader) {
         return classLoader == this.classLoader ? this : new ConfigImpl(this, classLoader);
     }
 
     // object methods
 
     public ConfigImpl clone() {
         return new ConfigImpl(this);
     }
 
     // private methods
 
     /**
      * If the minimum read period has elapsed, checks whether the properties
      * have changed. The lock must be held when calling this method.
      * 
      * @throws ProntoConfigException
      *             if the properties could not be accessed and the policy is to
      *             throw exceptions
      */
 
     private void checkProperties() throws ProntoConfigException {
         long now = System.currentTimeMillis();
         if (LOGGER.isLoggable(FINEST)) LOGGER.log(FINEST, "checking properties");
         if (lastCheck == -1 || now - lastCheck > policy.getMinReadPeriod()) {
             lastCheck = now;
             readProperties();
         }
     }
 
     /**
      * Obtains the timestamp and, if desired by the policy, new properties from
      * the source.
      * 
      * The lock must be held when calling this method.
      * 
      * @throws ProntoConfigException
      *             if the properties could not be accessed and the policy is to
      *             throw exceptions
      */
 
     private void readProperties() throws ProntoConfigException {
         if (LOGGER.isLoggable(FINER)) LOGGER.log(FINER, "reading properties");
         // initially set the timestamp to the last modified time, just in case
         // an exception's raised
         long timestamp;
         try {
             timestamp = source.lastModified();
             if (timestamp < 0L) throw new IllegalArgumentException(String.format(
                     "Negative timestamp returned from source: %d", timestamp));
         } catch (RuntimeException e) {
             if (policy.isExceptionLogged() && LOGGER.isLoggable(WARNING)) LOGGER.log(WARNING, null, e);
             if (policy.isExceptionThrown()) throw new ProntoConfigException(e);
             timestamp = lastModified;
         }
         if (lastModified == -1L || policy.isTimestampNewer(timestamp, lastModified)) {
             Map<String, String> tmp = null;
             try {
                 tmp = source.getProperties();
                 if (tmp == null) throw new NullPointerException("Configuration source returned null properties.");
             } catch (RuntimeException e) {
                 if (policy.isExceptionLogged() && LOGGER.isLoggable(WARNING)) LOGGER.log(WARNING, null, e);
                 if (policy.isExceptionThrown()) throw new ProntoConfigException(e);
                 tmp = Collections.emptyMap();
             }
             createProperties(tmp);
             lastModified = timestamp;
         }
     }
 
     /**
      * Updates the properties and factory fields by remapping the source
      * properties using config keys. The lock must be held when calling this
      * method.
      * 
      * @param sourceProps
      *            the properties supplied by the source
      * @throws ProntoConfigException
      *             if any property supplied by the source was not a string
      */
 
     private void createProperties(final Map<String, String> sourceProps) throws ProntoConfigException {
         factory.reset();
         properties = new HashMap<ConfigKey, String>();
         for (Map.Entry<String, String> entry : sourceProps.entrySet()) {
             try {
                 ConfigKey key = factory.newKey(entry.getKey());
                 properties.put(key, entry.getValue());
             } catch (ClassCastException e) { // due to erasure, we may have
                 // been passed a non-string
                 // object
                 throw new ProntoConfigException(e);
             }
         }
         factory.setReadOnly(true);
     }
 
     /**
      * Returns an implementation which matches the specified parameters, by
      * first looking in a cache for a matching implementation. The lock must be
      * held when calling this method.
      * 
      * @param <T>
      *            the interface type being satisfied
      * @param domain
      *            the domain of properties, may be null
      * @param inherit
      *            true iff the properties should be inherited by the interface
      *            implementation
      * @param clss
      *            the interface class to be satsified
      * @return a satisfaction of the clss interface
      * 
      */
 
     @SuppressWarnings("unchecked")
     private <T> T checkCreateImpl(final ConfigKey domain, final boolean inherit, final Class<T> clss) {
         Params<T> params = new Params<T>(domain, inherit, clss);
         T impl = (T) proxies.get(params);
         if (impl == null) {
             impl = createImpl(params);
             proxies.put(params, impl);
         }
         return impl;
     }
 
     /**
      * Creates a dynamic interface proxy for the supplied parameters. The lock
      * must be held when calling this method.
      * 
      * @param <T>
      *            the interface being satisfied
      * @param params
      *            the parameters which define the mapping to configuration
      *            properties
      * @return an implementation of the interface specified by the parameters
      */
 
     @SuppressWarnings("unchecked")
     private <T> T createImpl(final Params<T> params) {
         return (T) Proxy.newProxyInstance(getActiveClassLoader(), new Class[] {params.iface}, new SettingsHandler(
                 params));
     }
 
     /**
      * Return the class loader which will be used to create class instances.
      * This is the first non-null of: the specified classLoader, the context
      * class loader and this class's class loader
      * 
      * @return the class loader which will be used to create class instances.
      */
 
     private ClassLoader getActiveClassLoader() {
         if (classLoader != null) return classLoader;
         ClassLoader tmp = Thread.currentThread().getContextClassLoader();
         if (tmp != null) return tmp;
         return getClass().getClassLoader();
     }
 
     // inner classes
 
     /**
      * This class collects together the parameters which control the creation of
      * a mapping between a java interface and live configuration parameters.
      * 
      * @param <T>
      *            the interface satisfied by a mapping generated with these
      *            parameters
      * 
      * @author Tom Gibara
      */
 
     private static final class Params<T> {
 
         /**
          * The domain from which properties will be drawn to satisfy the
          * interface.
          */
         private final ConfigKey domain;
 
         /**
          * Indicates whether the interface will inherit properties for its
          * satisfaction.
          */
         private final boolean inherit;
 
         /**
          * The interface which is to be implemented using configuration values.
          */
         private final Class<T> iface;
 
         /**
          * Constructs a new Params object.
          * 
          * @param domain
          *            the domain of properties
          * @param inherit
          *            whether properties are inherited
          * @param iface
          *            the interface to implement
          */
 
         private Params(final ConfigKey domain, final boolean inherit, final Class<T> iface) {
             this.domain = domain;
             this.inherit = inherit;
             this.iface = iface;
         }
 
         /**
          * Two Params instances are equal if all their fields are equal.
          * 
          * @param obj
          *            any object, possibly null
          * 
          * @return true if the fields are equal
          */
 
         public boolean equals(final Object obj) {
             if (obj == this) return true;
             if (!(obj instanceof Params)) return false;
             Params that = (Params) obj;
             if (this.iface != that.iface) return false;
             if (this.inherit != that.inherit) return false;
             if (Objects.notEqual(this.domain, that.domain)) return false;
             return true;
         }
 
         /**
          * @return a hash code consistent with equality
          */
 
         public int hashCode() {
             return Objects.hashCode(domain) ^ iface.hashCode() ^ Boolean.valueOf(inherit).hashCode();
         }
 
         /**
          * A string representation of the parameters, useful for identifying
          * proxies.
          * 
          * @return a human readable string representation of this object
          */
 
         public String toString() {
             return String.format("[Params domain=%s, inherit=%b, iface=%s]", domain, inherit, iface);
         }
     }
 
     /**
      * This class is delegated to via Java's reflective proxy class to satisfy
      * calls to accessor methods on the interface defined by its
      * parameterization.
      * 
      * @author Tom Gibara
      * 
      */
 
     private final class SettingsHandler implements InvocationHandler {
 
         /**
          * Maps method names to the object values to be returned for calls to
          * those method.
          */
         private final HashMap<String, Object> objects = new HashMap<String, Object>(); // caching
         // config
         // objects
 
         /**
          * The parameters which define the mapping imposed by this handler.
          */
         private final Params params;
 
         /**
          * A reference to the config's properties so that values can be searched
          * for without causing undue contention on the config's lock.
          */
         private HashMap<ConfigKey, String> properties;
 
         /**
          * The time at which this handler's copy of the properties map was last
          * modifed. This value is used to 'enliven' this handler's map as
          * necessary.
          */
         private long lastModified = -1L;
 
         /**
          * Constructs a new parameterized handler.
          * 
          * @param params
          *            the handler's operational parameters, not null
          */
 
         private SettingsHandler(final Params params) {
             Arguments.notNull(params, "params");
             this.params = params;
         }
 
         /**
          * @param proxy
          *            used only to implement equals
          * @param method
          *            the method being invoked
          * @param args
          *            the arguments to the method - should be empty
          * 
          * @throws Throwable
          *             if any exception is raised during the execution of the
          *             method
          * 
          * @return the value for an accessor, or the appropriate value for an
          *         object method
          */
 
         public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
             final String methodName = method.getName();
             // deal with object methods first
             if (methodName.equals("equals")) return Boolean.valueOf(args[0] == proxy);
             if (methodName.equals("hashCode")) return new Integer(hashCode());
             if (methodName.equals("toString")) return String.format("[%s dynamically implemented for: %s]", method
                     .getClass(), params);
             // identify the method return type
             final Class clss = method.getReturnType();
             // optimization - return immediately if return type is void, there's
             // nothing to do
             if (clss == Void.TYPE) return null;
 
             synchronized (lock) {
                 // check for reload
                 checkProperties();
                 if (ConfigImpl.this.lastModified != this.lastModified) {
                     if (LOGGER.isLoggable(FINER)) LOGGER.log(FINER, "{0} updated properties", this);
                     // properties have changed so our object cache is invalid
                     objects.clear();
                     // get our own reference to the config's properties so we
                     // don't need to lock
                     this.properties = ConfigImpl.this.properties;
                     // record the last modified date so we know if it happens
                     // again
                     this.lastModified = ConfigImpl.this.lastModified;
                 }
             }
 
             synchronized (this) {
                 try {
                     final Object value;
                     // check for already created value
                     if (objects.containsKey(methodName)) {
                         value = objects.get(methodName);
                     } else {
                         // deduce the property name
                         final String name = policy.propertyFromMethod(methodName);
                         // create proper key value
                         // can't use factory since key may not be pre-existing
                         // but still valid due to inheritence
                         // using factory only in case of non-inheritence adds
                         // complexity for very little apparent gain?
                         final ConfigKey key = new ConfigKey(params.domain, name);
                         String propertyValue = lookupProperty(key);
                         if (propertyValue == null) { // default value case
                             value = policy.defaultForClass(clss);
                             if (clss.isPrimitive() && value == null) throw new NullPointerException(String.format(
                                     "Null value supplied for primitive: %s", clss));
                             if (policy.isDefaultsCached()) objects.put(methodName, value);
                         } else { // convert string to object
                             Class tmp = clss.isPrimitive() ? Classes.classForPrimitive(clss) : clss;
                             value = convertValue(propertyValue, tmp, methodName);
                             if (classLoader != null || policy.isCachingEager()) objects.put(methodName, value);
                         }
                     }
                     if (LOGGER.isLoggable(FINEST)) LOGGER.log(FINEST, "{0}()={1}", new Object[] {methodName, value});
                     return value;
                 } catch (RuntimeException e) {
                     // deal with exception
                     if (policy.isExceptionLogged() && LOGGER.isLoggable(WARNING)) LOGGER.log(WARNING, null, e);
                     if (policy.isExceptionThrown()) throw new ProntoConfigException(e);
                     Object value = policy.defaultForClass(clss);
                     // at this point we know that the policy is not to pass
                     // exceptions back to the client code
                     // so we automatically limit ourselves to logging any
                     // mistake by the policy
                     if (clss.isPrimitive() && value == null && LOGGER.isLoggable(WARNING)) LOGGER.log(WARNING, null,
                             new ProntoConfigException(String.format(
                                     "Null value supplied for primitive %s in call to method %s", clss, method)));
                     return value;
                 }
             }
         }
 
         /**
          * Coerces a property value in the form of a string, into the a value
          * with the correct type to be returned by a specific interface method.
          * 
          * @param propertyValue
          *            the value of the property as a string, not null
          * @param clss
          *            the class, not null and not primitive
          * @param methodName
          *            the name of the method being invoked on the proxy (used
          *            for error reporting purposes)
          * @return the converted value
          * 
          * @throws ProntoConfigException
          *             if an exception occurs converting the property value into
          *             an object
          */
 
         @SuppressWarnings("unchecked")
         private Object convertValue(final String propertyValue, final Class clss, final String methodName)
                 throws ProntoConfigException {
             Exception ex;
             try {
                 // we have a cachable value
                 if (clss == String.class) {
                     // they want a string - no processing to do
                     return propertyValue;
                 }
 
                 if (Enum.class.isAssignableFrom(clss)) {
                     return Enum.valueOf(clss, propertyValue);
                 }
 
                 if (clss == Set.class || clss == Collection.class) {
                     return Collections.unmodifiableSet(new LinkedHashSet<String>(Strings.splitCommas(propertyValue)));
                 }
 
                 if (clss == List.class) {
                     return Collections.unmodifiableList(Strings.splitCommas(propertyValue));
                 }
 
                 if (clss == Map.class) {
                     return Collections.unmodifiableMap(Strings.parseProperties(propertyValue));
                 }
 
                 if (clss == Class.class) {
                     return getActiveClassLoader().loadClass(propertyValue);
                 }
 
                 if (clss.isArray()) {
                     Class c = clss.getComponentType();
                     List<String> strings = Strings.splitCommas(propertyValue);
                     Object[] a = (Object[]) Array.newInstance(c, strings.size());
                     int i = 0;
                     for (String string : strings) {
                         a[i++] = convertValue(string, c, methodName);
                     }
                     return a;
                 }
 
                 // attempt to create value from string contstructor
                 Constructor cons = clss.getConstructor(new Class[] {String.class});
                 return cons.newInstance(new Object[] {propertyValue});
 
             } catch (SecurityException e) {
                 ex = e;
             } catch (ClassNotFoundException e) {
                 ex = e;
             } catch (NoSuchMethodException e) {
                 ex = e;
             } catch (IllegalArgumentException e) {
                 ex = e;
             } catch (InstantiationException e) {
                 ex = e;
             } catch (IllegalAccessException e) {
                 ex = e;
             } catch (InvocationTargetException e) {
                 ex = e;
             }
             throw new ProntoConfigException(String.format("Error converting value for method %s: %s", methodName, ex
                     .getMessage()), ex);
         }
 
         // object methods
 
         /**
          * @return a human readable representation of this object
          */
         @Override
         public String toString() {
             return String.format("[SettingsHandler for %s]", params);
         }
 
         // private methods
 
         /**
          * Looks for a property which matches the supplied key, recursing up the
          * inherited keys (if necessary) until a value is found or there are no
          * more inherited keys.
          * 
          * @param key
          *            the key to the value sought
          * @return the property for that key, or null
          */
         private String lookupProperty(final ConfigKey key) {
             if (properties.containsKey(key)) return properties.get(key);
             else if (!params.inherit) return null;
             else {
                 ConfigKey next = getInheritedKey(key);
                 return next == null ? null : lookupProperty(next);
             }
         }
 
         /**
          * Returns the key from which a specified key inherits its value, or
          * null if the key has no parent.
          * 
          * @param key
          *            the key for which the inherited key is sought
          * @return the key from which the specified key inherits its value, or
          *         null
          */
 
         private ConfigKey getInheritedKey(final ConfigKey key) {
             ConfigKey parent = key.getParent();
             if (parent == null) return null;
             return new ConfigKey(parent.getParent(), key.getName());
         }
 
     }
 }