/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.properties.spi.config.support;
  
  import java.io.InputStream;
  import java.util.Properties;
  
  import javax.annotation.CheckForNull;
  import javax.annotation.concurrent.ThreadSafe;
  
  import de.smartics.properties.api.config.domain.ConfigurationLoadingException;
  import de.smartics.properties.api.config.domain.ConfigurationNotFoundException;
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyCollection;
  import de.smartics.properties.api.config.domain.PropertyLocation;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.PropertyStoreAccessor;
  import de.smartics.properties.api.config.domain.SerializableConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  import de.smartics.properties.api.core.domain.ReadOnlyPropertyException;
  import de.smartics.properties.api.core.security.PropertyValueSecurity;
  import de.smartics.util.lang.Arg;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * An implementation that stores all properties in-memory.
   */
  @ThreadSafe
  public abstract class AbstractInMemoryConfigurationProperties extends
      AbstractConfigurationPropertiesManagement implements
      SerializableConfigurationPropertiesManagement
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The class version identifier.
     * <p>
     * The value of this constant is {@value}.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * The management of the properties.
     *
     * @serial
     */
    private final InMemoryPropertiesManager properties;
  
    /**
     * The flag controls the behavior on not finding default properties on the
     * classpath. If the value is <code>true</code> not finding the properties
     * file on the class path signals an exception, if set to <code>false</code>
     * the properties are not required to exist. In the latter case the properties
     * may be set purely programatically.
     *
     * @serial
     */
    private final boolean requiresDefaultOnClassPath;
  
    /**
     * The helper to access properties in a property store directly.
     *
     * @serial
     */
    private final PropertyStoreAccessor propertyStoreAccessor =
        new InMemoryPropertyStoreAccessor();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor requiring that a properties file with the same name
     * as the properties set class exists on the class path.
     *
     * @param key the key that identifies the configuration.
     * @param registry the registry to resolve property descriptors.
     * @param decrypter the helper to decrypt secured property values.
     * @throws NullArgumentException if {@code key}, {@code registry} or
     *           {@code decrypter} is <code>null</code>.
    */
   public AbstractInMemoryConfigurationProperties(final ConfigurationKey<?> key,
       final PropertyDescriptorRegistry registry,
       final PropertyValueSecurity decrypter) throws NullArgumentException
   {
     this(key, registry, true, decrypter);
   }
 
   /**
    * Default constructor requiring that a properties file with the same name as
    * the properties set class exists on the class path.
    *
    * @param key the key that identifies the configuration.
    * @param registry the registry to resolve property descriptors.
    * @param requiresDefaultOnClassPath the flag controls the behavior on not
    *          finding default properties on the classpath.
    * @param decrypter the helper to decrypt secured property values.
    * @throws NullArgumentException if {@code key}, {@code registry} or
    *           {@code decrypter} is <code>null</code>.
    */
   public AbstractInMemoryConfigurationProperties(final ConfigurationKey<?> key,
       final PropertyDescriptorRegistry registry,
       final boolean requiresDefaultOnClassPath,
       final PropertyValueSecurity decrypter) throws NullArgumentException
   {
     super(key, registry, decrypter);
 
     properties = new InMemoryPropertiesManager(key);
     this.requiresDefaultOnClassPath = requiresDefaultOnClassPath;
   }
 
   // ****************************** Inner Classes *****************************
 
   /**
    * Provides direct access to the properties in the property store.
    */
   private final class InMemoryPropertyStoreAccessor implements
       PropertyStoreAccessor
   {
     /**
      * The class version identifier.
      * <p>
      * The value of this constant is {@value}.
      * </p>
      */
     private static final long serialVersionUID = 1L;
 
     @Override
     public Property getPropertyFromStore(final String name)
     {
       try
       {
         return properties.getProperty(name);
       }
       catch (final IllegalArgumentException e)
       {
         return new Property(properties.getSourceId(), name, null);
       }
     }
 
     @Override
     public Property setPropertyToStore(final String key, final String value)
       throws PropertyValidationException, ReadOnlyPropertyException
     {
       final Property property = ensureProperty(key, value);
       final Property oldValue = properties.setProperty(property);
       return oldValue;
     }
 
     @Override
     public Property deletePropertyInStore(final String name)
     {
       return properties.removeProperty(name);
     }
 
     @Override
     public PropertyCollection getPropertyCollectionFromStore()
     {
       return properties.getProperties();
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   @Override
   public final PropertyStoreAccessor getPropertyStoreAccessor()
   {
     return propertyStoreAccessor;
   }
 
   // --- business -------------------------------------------------------------
 
   @Override
   protected final void addDefinitionsToStore(final PropertyProvider properties)
   {
     setPropertiesToStore(properties);
   }
 
   /**
    * Allows to store all properties efficiently by subclasses. The default
    * implementation simply iterates.
    *
    * @param provider the provider with the properties to be stored.
    */
   protected final void setPropertiesToStore(final PropertyProvider provider)
   {
     for (final Property property : provider.getProperties())
     {
       setPropertyToStore(property.getName(), property.getValue());
     }
   }
 
   /**
    * Loads the properties for the given properties interface from the class
    * path.
    * <p>
    * The properties file is expected to be at the same location with a name
    * identical to the interface plus the file extension <code>.properties</code>
    * .
    * </p>
    *
    * @param propertiesInterface the properties defining interface whose
    *          properties are loaded.
    * @return a reference to this configuration for chaining.
    * @throws NullArgumentException if {@code propertiesInterface} is
    *           <code>null</code>.
    * @throws ConfigurationLoadingException if the properties file cannot be
    *           loaded.
    */
   public final AbstractInMemoryConfigurationProperties addClassPathProperties(
       final Class<?> propertiesInterface) throws NullArgumentException,
     ConfigurationLoadingException
   {
     Arg.checkNotNull("propertiesInterface", propertiesInterface);
 
     final PropertyProvider properties = loadDefault(propertiesInterface);
     addDescriptors(propertiesInterface);
     if (properties != null)
     {
       addDefinitions(properties);
     }
     return this;
   }
 
   @CheckForNull
   private PropertyProvider loadDefault(final Class<?> descriptorDefinition)
     throws ConfigurationLoadingException
   {
     final String name = descriptorDefinition.getSimpleName() + ".properties";
 
     final InputStream in = descriptorDefinition.getResourceAsStream(name);
     if (in != null)
     {
       final PropertiesHelper utils = new PropertiesHelper(getKey());
       final Properties properties = utils.readProperties(name, in);
       final PropertyProvider provider =
           new PropertiesPropertyProvider(getKey(), new PropertyLocation(name),
               properties);
       return provider;
     }
 
     if (requiresDefaultOnClassPath)
     {
       throw new ConfigurationNotFoundException(getKey(), name);
     }
     else
     {
       return null;
     }
   }
 
   private Property ensureProperty(final String name, final Object value)
   {
     final Property property;
     if (value instanceof Property)
     {
       property = (Property) value;
     }
     else
     {
       property = new Property(properties.getSourceId(), name, value);
     }
     return property;
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Returns the string representation of the object.
    *
    * @return the string representation of the object.
    */
   @Override
   public String toString()
   {
     return super.toString() + "Properties:\n" + properties.toString();
   }
 }