/*
    * 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 java.util.Map.Entry;
  import java.util.Properties;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import org.apache.commons.lang.ObjectUtils;
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.ConfigurationValidationException;
  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.PropertyValidationWithSourceException;
  import de.smartics.properties.api.config.domain.PropertyValueConversionWithSourceException;
  import de.smartics.properties.api.config.domain.PropertyValueResolveWithSourceException;
  import de.smartics.properties.api.config.domain.ResolvedProperty;
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.DuplicatePropertyDeclarationsException;
  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.PropertyKey;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  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.spi.config.validation.ConfigurationValidator;
  import de.smartics.util.lang.Arguments;
  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
      AbstractConfigurationProperties implements
      ConfigurationPropertiesManagement, ConfigurationPropertiesManagementSpi
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Constructor for serializable subclasses.
     */
    protected AbstractConfigurationPropertiesManagement()
    {
      super();
    }
  
    /**
     * Default constructor.
     *
     * @param key the key that identifies the configuration.
     * @param registry the registry to resolve property descriptors.
     * @throws NullArgumentException if {@code key} or {@code registry} is
     *           <code>null</code>.
     */
    protected AbstractConfigurationPropertiesManagement(
        final ConfigurationKey key, final PropertyDescriptorRegistry registry)
      throws NullArgumentException
    {
      super(key, registry);
    }
  
    // ****************************** 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 Properties properties) throws NullPointerException
   {
     for (final Entry<Object, Object> entry : properties.entrySet())
     {
       final String name = ObjectUtils.toString(entry.getKey(), null);
       if (StringUtils.isNotBlank(name))
       {
         final String stringValue = unwrapValue(entry.getValue());
         setPropertyToStore(name, stringValue);
       }
     }
     return this;
   }
 
   // ... managing properties ..................................................
 
   @Override
   public final Property getProperty(final String key, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException
   {
     final PropertyDescriptor descriptor = getDescriptor(key);
     return getProperty(descriptor, defaultValue);
   }
 
   @Override
   public final Property getProperty(final PropertyDescriptor descriptor,
       final Object defaultValue) throws IllegalArgumentException,
     UnknownPropertyException
   {
     final String name = descriptor.getKey().toString();
     final Property property = getPropertyFromStore(name);
     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.
       // TODO: Check if we want to be here more strict. In this case every
       // property has to be registered with a "null" value, if it is not
       // explicitly provided.
 
       throw new UnknownPropertyException(getKey(), name);
     }
 
     return property;
   }
 
   @Override
   public final ResolvedProperty getResolvedProperty(
       final PropertyDescriptor descriptor, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException,
     PropertyValidationException
   {
     final Property property = getProperty(descriptor, defaultValue);
 
     final Object plainValue = property.getValue();
     try
     {
       final Object resolvedValue =
           resolveAndConvert(descriptor, defaultValue, plainValue);
       return new ResolvedProperty(property, 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
   {
     Arguments.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 Property oldProperty = setPropertyToStore(name, value);
     firePropertyChange(name, oldProperty != null ? oldProperty.getValue()
         : null, value);
     return oldProperty;
   }
 
   @Override
   public final Property unsetProperty(final PropertyKey key)
     throws NullPointerException, ReadOnlyPropertyException
   {
     Arguments.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)
     throws ConfigurationValidationException
   {
     final ConfigurationValidator validator =
         new ConfigurationValidator(this, lenient);
     final PropertyCollection propertyCollection =
         getPropertyCollectionFromStore();
     validator.validate(propertyCollection);
   }
 
   // ... 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 abstract Property setPropertyToStore(final String name,
       final String value) throws NullPointerException;
 
   /**
    * 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 abstract PropertyCollection 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 abstract Property deletePropertyInStore(final String 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 abstract Property getPropertyFromStore(final String 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
   {
     final PropertyDescriptor descriptor = getDescriptor(key);
 
     if (!descriptor.isRuntimeMutable())
     {
       final String currentValue = getPropertyValueAsString(descriptor);
       throw new ReadOnlyPropertyException(descriptor, currentValue, value);
     }
   }
 
   /**
    * Checks if the given {@code value} is an instance of {@link Property} and
    * unwraps the {@code value} if it is.
    *
    * @param value the value to check and unwrap.
    * @return the {@code value} or the unwrapped {@code value} dependent on the
    *         type of the {@code value}.
    */
   private String unwrapValue(final Object value)
   {
     if (value instanceof Property)
     {
       return ((Property) value).getValue();
     }
     return ObjectUtils.toString(value, null);
   }
 
   private static PropertyValueResolveException wrapWithPropertyValueSourceInformation(
       final PropertyValueResolveException e,
       final PropertyDescriptor descriptor, final Property property)
   {
     final PropertyValueResolveException cause =
         isResolvementFailureOfPlaceholder(e, property)
             ? new PropertyValueResolveException(e, descriptor,
                 property.getValue()) : e;
 
     if (!(cause instanceof PropertyValueResolveWithSourceException))
     {
       final PropertyLocation source = property.getSource();
       return new PropertyValueResolveWithSourceException(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(e, source);
   }
 
   private static PropertyValidationException wrapWithPropertyValueSourceInformation(
       final PropertyValidationException e, final Property property)
   {
     final PropertyLocation source = property.getSource();
     return new PropertyValidationWithSourceException(e, source);
   }
 
   // --- object basics --------------------------------------------------------
 
 }