/*
    * 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.util.List;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.ConfigurationValidationException;
  import de.smartics.properties.api.config.domain.DescribedProperty;
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyCollection;
  import de.smartics.properties.api.config.domain.PropertyExpressionWithSourceMessageBean;
  import de.smartics.properties.api.config.domain.PropertyLocation;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.PropertyStoreException;
  import de.smartics.properties.api.config.domain.PropertyValidationWithSourceException;
  import de.smartics.properties.api.config.domain.PropertyValidationWithSourceMessageBean;
  import de.smartics.properties.api.config.domain.PropertyValueConversionWithSourceException;
  import de.smartics.properties.api.config.domain.PropertyValueResolveWithSourceException;
  import de.smartics.properties.api.config.domain.PropertyValueWithSourceMessageBean;
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.config.domain.ValidatedProperty;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.app.PropertyRootException;
  import de.smartics.properties.api.core.domain.DuplicatePropertyDeclarationsException;
  import de.smartics.properties.api.core.domain.PropertyCode;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;
  import de.smartics.properties.api.core.domain.PropertyExpression;
  import de.smartics.properties.api.core.domain.PropertyExpressionMessageBean;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  import de.smartics.properties.api.core.domain.PropertyValidationMessageBean;
  import de.smartics.properties.api.core.domain.PropertyValueChangeMessageBean;
  import de.smartics.properties.api.core.domain.PropertyValueConversionException;
  import de.smartics.properties.api.core.domain.PropertyValueResolveException;
  import de.smartics.properties.api.core.domain.ReadOnlyPropertyException;
  import de.smartics.properties.api.core.security.PropertyValueSecurity;
  import de.smartics.properties.api.core.security.SecurityException;
  import de.smartics.properties.spi.config.validation.ConfigurationValidator;
  import de.smartics.util.lang.Arg;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Abstract implementation of the
   * {@link de.smartics.properties.api.config.domain.ConfigurationProperties}
   * interface.
   */
  @ThreadSafe
  public abstract class AbstractConfigurationPropertiesManagement extends
      AbstractAdminModeConfigurationProperties implements
      ConfigurationPropertiesManagement, ConfigurationPropertiesManagementSpi
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The properties associated to override.
     *
     * @serial
     */
    private final MultiSourceProperties properties;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Constructor for serializable subclasses.
     */
    protected AbstractConfigurationPropertiesManagement()
    {
      super();
      this.properties = null;
    }
  
    /**
     * Default constructor.
     *
     * @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>.
    */
   protected AbstractConfigurationPropertiesManagement(
       final ConfigurationKey<?> key, final PropertyDescriptorRegistry registry,
       final PropertyValueSecurity decrypter) throws NullArgumentException
   {
     super(key, registry, decrypter);
 
     this.properties = new MultiSourceProperties(key);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   // ... descriptor handling ..................................................
 
   @Override
   public final PropertyDescriptor getDescriptor(final String key)
     throws UnknownPropertyException
   {
     final PropertyDescriptor descriptor = getRegistry().get(key);
 
     if (descriptor == null)
     {
       throw new UnknownPropertyException(getKey(), key);
     }
 
     return descriptor;
   }
 
   @Override
   public final PropertyDescriptor getDescriptor(final PropertyKey key)
     throws UnknownPropertyException
   {
     return getDescriptor(key.toString());
   }
 
   @Override
   public final void addDescriptors(final Class<?> propertySetType)
     throws DuplicatePropertyDeclarationsException
   {
     getRegistry().addDescriptors(propertySetType);
   }
 
   @Override
   public final List<PropertyDescriptor> getMandatoryPropertyDescriptors()
   {
     return getRegistry().createMandatoryProperties();
   }
 
   @Override
   public final ConfigurationPropertiesManagement addDefinitions(
       final PropertyProvider properties) throws NullPointerException
   {
     this.properties.addProvider(properties);
     addDefinitionsToStore(properties);
     return this;
   }
 
   /**
    * Implementations decide whether or not registered definitions should be
    * written to the store. This is the default and subclasses may override to
    * implement another strategy.
    * <p>
    * Usually configurations that are backed up by an external (e.g. persistent)
    * store do not want to store definitions here. So they override this method
    * with a no-op.
    * </p>
    *
    * @param properties the properties that are to be registered as definitions.
    * @throws PropertyStoreException if any property cannot be stored. The
    *           already stored properties will not be rolled back.
    */
   protected abstract void addDefinitionsToStore(
       final PropertyProvider properties) throws PropertyStoreException;
 
   /**
    * Allows to store all properties efficiently by subclasses. The default
    * implementation simply iterates.
    *
    * @param provider the provider with the properties to be stored.
    * @throws PropertyStoreException if any property cannot be stored. The
    *           already stored properties will not be rolled back.
    */
   protected abstract void setPropertiesToStore(final PropertyProvider provider)
     throws PropertyStoreException;
 
   // ... managing properties ..................................................
 
   @Override
   public final DescribedProperty getProperty(final String key,
       final Object defaultValue) throws IllegalArgumentException,
     UnknownPropertyException
   {
     final PropertyDescriptor descriptor = getDescriptor(key);
     return getProperty(descriptor, defaultValue);
   }
 
   @Override
   public final DescribedProperty getProperty(
       final PropertyDescriptor descriptor, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException
   {
     final DescribedProperty property = getPropertyInternal(descriptor);
 
     return property;
   }
 
   private DescribedProperty getPropertyInternal(
       final PropertyDescriptor descriptor)
   {
     final String name = descriptor.getKey().toString();
     final Property property = getPropertyFromStore(name);
     // if (property == null || property.getValue() == null)
     // { // if alternative lookups have to be provided, the 'properties' have to
     // be updated on every change.
     // final Property alt = properties.getValue(name);
     // property = alt != null ? alt : property;
     // }
 
     final DescribedProperty describedProperty =
         new DescribedProperty(this.getKey(), descriptor, property);
 
     return describedProperty;
   }
 
   @Override
   public Object getPropertyAsType(final PropertyDescriptor descriptor)
     throws IllegalArgumentException, PropertyValueConversionException,
     SecurityException, PropertyRootException
   {
     final Property property = getProperty(descriptor);
     final String plainValue = property.getValue();
     final Object resolvedValue =
         resolveAndConvert(descriptor, plainValue, null);
     return resolvedValue;
   }
 
   @Override
   public final ValidatedProperty getValidatedProperty(
       final PropertyDescriptor descriptor, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException,
     PropertyValidationException, SecurityException
   {
     final Property property = getProperty(descriptor, defaultValue);
 
     final Object plainValue = property.getValue();
     if (plainValue == null && defaultValue == null && descriptor.isMandatory())
     {
       // We do not required that properties with a value of 'null' are specified
       // explicitly. Therefore we must signal an unknown property only if it is
       // mandatory.
 
       final PropertyValidationMessageBean message =
           new PropertyValidationMessageBean(descriptor,
               descriptor.getConstraints(), plainValue);
       throw new PropertyValidationException(message);
     }
 
     try
     {
       final Object resolvedValue =
           resolveAndConvertAndValidate(descriptor, defaultValue, plainValue);
       final DescribedProperty describedProperty =
           new DescribedProperty(getKey(), descriptor, property);
       return new ValidatedProperty(describedProperty,
           getExpression(descriptor), resolvedValue);
     }
     catch (final PropertyValueResolveException e)
     {
       throw wrapWithPropertyValueSourceInformation(e, descriptor, property);
     }
     catch (final PropertyValueConversionException e)
     {
       throw wrapWithPropertyValueSourceInformation(e, property);
     }
     catch (final PropertyValidationException e)
     {
       throw wrapWithPropertyValueSourceInformation(e, property);
     }
   }
 
   private static String getExpression(final PropertyDescriptor descriptor)
   {
     final PropertyExpression expression = descriptor.getDefaultExpression();
     return expression != null ? expression.getExpression() : null;
   }
 
   @Override
   public final Property setProperty(final PropertyKey key, final String value)
     throws NullPointerException, PropertyValidationException,
     ReadOnlyPropertyException
   {
     Arg.checkNotNull("key", key);
     checkWritable(key, value);
 
     final String name = key.toString();
     return setPropertyAndFireEvent(name, value);
   }
 
   private Property setPropertyAndFireEvent(final String name, final String value)
     throws NullPointerException, PropertyValidationException,
     ReadOnlyPropertyException
   {
     final String normalized = provideSecurity(name, value);
     final Property oldProperty = setPropertyToStore(name, normalized);
     firePropertyChange(name, oldProperty != null ? oldProperty.getValue()
         : null, normalized);
     return oldProperty;
   }
 
   private String provideSecurity(final String name, final String value)
   {
     if (value != null)
     {
       final PropertyDescriptor descriptor = getRegistry().get(name);
       if (descriptor.isSecured())
       {
         final String encryptedValue =
             getPropertyValueSecurity().encrypt(descriptor, value);
         return encryptedValue;
       }
     }
 
     return value;
   }
 
   @Override
   public final Property unsetProperty(final PropertyKey key)
     throws NullPointerException, ReadOnlyPropertyException
   {
     Arg.checkNotNull("key", key);
     checkWritable(key, null);
 
     final String name = key.toString();
     final Property oldProperty = deletePropertyInStore(name);
     firePropertyChange(name, oldProperty.getValue(), null);
     return oldProperty;
   }
 
   @Override
   public final void validate(final boolean lenient, final Class<?>... groups)
     throws ConfigurationValidationException
   {
     final ConfigurationValidator validator =
         new ConfigurationValidator(this, lenient);
     final PropertyCollection propertyCollection =
         getPropertyCollectionFromStore();
     validator.validate(propertyCollection, groups);
   }
 
   @Override
   public final void validate(final PropertyDescriptor descriptor,
       final Class<?>... ifInOneOfTheseGroups)
     throws ConfigurationValidationException
   {
     final Object value = getPropertyValue(descriptor);
     validate(descriptor, value, ifInOneOfTheseGroups);
   }
 
   @Override
   public final void validate(final PropertyDescriptor descriptor,
       final String value, final Class<?>... ifInOneOfTheseGroups)
     throws ConfigurationValidationException
   {
     final ConfigurationValidator validator =
         new ConfigurationValidator(this, false);
     final Object valueAsType = resolveAndConvert(descriptor, value, null);
 
     validator.validate(descriptor, valueAsType, ifInOneOfTheseGroups);
   }
 
   // ... configuration management .............................................
 
   /**
    * {@inheritDoc}
    * <p>
    * This implementation does nothing on a flush. Should be overridden by
    * implementations that do want to take actions on a flush.
    * </p>
    */
   @Override
   public void flush()
   {
   }
 
   // ... property store access ................................................
 
   /**
    * Sets the property to the given value.
    *
    * @param name the name of the property to set.
    * @param value the value to the property.
    * @return the old property. Must not be <code>null</code> (although the value
    *         of the property may be <code>null</code>).
    * @throws NullPointerException if {@code name} is <code>null</code>.
    * @impl No property change listeners are informed here. This is solely the
    *       call to the underlying store.
    */
   protected final Property setPropertyToStore(final String name,
       final String value) throws NullPointerException
   {
     return getPropertyStoreAccessor().setPropertyToStore(name, value);
   }
 
   /**
    * Returns a collection to iterate over all properties of the configuration.
    *
    * @return a collection to iterate over all properties of the configuration.
    * @impl No property change listeners are informed here. This is solely the
    *       call to the underlying store.
    */
   protected final PropertyCollection getPropertyCollectionFromStore()
   {
     return getPropertyStoreAccessor().getPropertyCollectionFromStore();
   }
 
   /**
    * Deletes the property with the given name.
    *
    * @param name the name of the property to delete.
    * @return the value of the deleted property.
    * @impl No property change listeners are informed here. This is solely the
    *       call to the underlying store.
    */
   protected final Property deletePropertyInStore(final String name)
   {
     return getPropertyStoreAccessor().deletePropertyInStore(name);
   }
 
   /**
    * Fetches the property from the store by the given name.
    *
    * @param name the name of the property to fetch.
    * @return the property value. Must not be <code>null</code> (although the
    *         value of the property may be <code>null</code>).
    * @impl No property change listeners are informed here. This is solely the
    *       call to the underlying store.
    */
   protected final Property getPropertyFromStore(final String name)
   {
     return getPropertyStoreAccessor().getPropertyFromStore(name);
   }
 
   // ... helpers ..............................................................
 
   /**
    * Checks if the property identified by the given key is writable.
    *
    * @param key the key to identify the property.
    * @param value the new value (only used in case of an exception).
    * @throws ReadOnlyPropertyException if the property is read-only.
    * @throws UnknownPropertyException if the property referenced by {@code key}
    *           is not known.
    */
   private void checkWritable(final PropertyKey key, final Object value)
     throws ReadOnlyPropertyException, UnknownPropertyException
   {
     if (isInAdminMode())
     {
       return;
     }
 
     final PropertyDescriptor descriptor = getDescriptor(key);
 
     if (!descriptor.isRuntimeMutable())
     {
       final Object currentValue = getPropertyAsType(descriptor);
       throw new ReadOnlyPropertyException(new PropertyValueChangeMessageBean(
           PropertyCode.READ_ONLY, descriptor, currentValue, value));
     }
   }
 
   private static PropertyValueResolveException wrapWithPropertyValueSourceInformation(
       final PropertyValueResolveException e,
       final PropertyDescriptor descriptor, final Property property)
   {
     final PropertyValueResolveException cause =
         isResolvementFailureOfPlaceholder(e, property)
             ? new PropertyValueResolveException(
                 new PropertyExpressionMessageBean(e, descriptor,
                     property.getValue())) : e;
 
     if (!(cause instanceof PropertyValueResolveWithSourceException))
     {
       final PropertyLocation source = property.getSource();
       return new PropertyValueResolveWithSourceException(
           new PropertyExpressionWithSourceMessageBean(cause, source));
     }
 
     return e;
   }
 
   private static boolean isResolvementFailureOfPlaceholder(
       final PropertyValueResolveException e, final Property property)
   {
     return !property.getName().equals(e.getPropertyKey().getName());
   }
 
   private static PropertyValueConversionException wrapWithPropertyValueSourceInformation(
       final PropertyValueConversionException e, final Property property)
   {
     final PropertyLocation source = property.getSource();
     return new PropertyValueConversionWithSourceException(
         new PropertyValueWithSourceMessageBean(e, source));
   }
 
   private static PropertyValidationException wrapWithPropertyValueSourceInformation(
       final PropertyValidationException e, final Property property)
   {
     final PropertyLocation source = property.getSource();
     return new PropertyValidationWithSourceException(
         new PropertyValidationWithSourceMessageBean(e, source));
   }
 
   // --- object basics --------------------------------------------------------
 
 }