/*
    * 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.ArrayList;
  import java.util.List;
  
  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.PropertyStoreAccessor;
  import de.smartics.properties.api.config.domain.PropertyStoreCode;
  import de.smartics.properties.api.config.domain.PropertyStoreException;
  import de.smartics.properties.api.config.domain.PropertyStoreMessageBean;
  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.SerializableConfigurationPropertiesManagement;
  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.PropertyDescriptor;
  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.PropertyValueConversionException;
  import de.smartics.properties.api.core.domain.PropertyValueResolveException;
  import de.smartics.properties.api.core.domain.ReadOnlyPropertyException;
  import de.smartics.properties.api.core.security.SecurityException;
  import de.smartics.properties.spi.config.validation.ConfigurationValidator;
  
  /**
   * A configuration properties instance that contains the main configuration
   * properties, which matches the key, and all the defaults that have a partial
   * representation of the key.
   * <p>
   * This implementation is thread-safe as long as the passed in instances of
   * {@link ConfigurationPropertiesManagement} are thread-safe.
   * </p>
   */
  public final class ConfigurationPropertiesManagementWithDefaults extends
      AbstractConfigurationProperties implements
      SerializableConfigurationPropertiesManagement
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * The list of configuration properties to consult on requests.
     *
     * @serial
     */
    private final List<SerializableConfigurationPropertiesManagement> configurationProperties;
  
    /**
     * The helper to access properties in a property store directly.
     *
     * @serial
     */
    private final PropertyStoreAccessor propertyStoreAccessor =
        new MultiPropertyStoreAccessor();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
    * Default constructor.
    *
    * @param configurationProperties the list of configuration properties to
    *          consult on requests.
    * @throws IllegalArgumentException if {@code configurationProperties} is
    *           <code>null</code> or empty.
    */
   public ConfigurationPropertiesManagementWithDefaults(
       final List<ConfigurationPropertiesManagement> configurationProperties)
     throws IllegalArgumentException
   {
     super(getConfigurationKey(configurationProperties), configurationProperties
         .get(0).getRegistry(), configurationProperties.get(0)
         .getPropertyValueSecurity());
 
     this.configurationProperties = toSerializable(configurationProperties);
   }
 
   // ****************************** Inner Classes *****************************
 
   /**
    * Provides direct access to the properties in the property store.
    */
   private final class MultiPropertyStoreAccessor 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)
       throws PropertyStoreException
     {
       for (final ConfigurationPropertiesManagement instance : configurationProperties)
       {
         final PropertyStoreAccessor accessor =
             instance.getPropertyStoreAccessor();
         final Property property = accessor.getPropertyFromStore(name);
         if (property.getValue() != null)
         {
           return property;
         }
       }
 
       throw new PropertyStoreException(
           new PropertyStoreMessageBean(
               PropertyStoreCode.CANNOT_GET_PROPERTY,
               new IllegalStateException(
                   "The list of configuration properties is empty."
                       + " It is required that there is at least one element in it."),
               getKey(), name));
     }
 
     @Override
     public Property setPropertyToStore(final String name, final String value)
       throws PropertyValidationException, ReadOnlyPropertyException
     {
       return representative().getPropertyStoreAccessor().setPropertyToStore(
           name, value);
     }
 
     @Override
     public Property deletePropertyInStore(final String name)
     {
       return representative().getPropertyStoreAccessor().deletePropertyInStore(
           name);
     }
 
     @Override
     public PropertyCollection getPropertyCollectionFromStore()
     {
       final MultiPropertyCollection collections = new MultiPropertyCollection();
       for (final ConfigurationPropertiesManagement instance : configurationProperties)
       {
         final PropertyStoreAccessor accessor =
             instance.getPropertyStoreAccessor();
 
         final PropertyCollection collection =
             accessor.getPropertyCollectionFromStore();
         collections.add(collection);
       }
 
       return collections;
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static ConfigurationKey<?> getConfigurationKey(
       final List<ConfigurationPropertiesManagement> configurationProperties)
   {
     if (configurationProperties == null || configurationProperties.isEmpty())
     {
       throw new IllegalArgumentException(
           "The configurationProperties must not be empty.");
     }
     return configurationProperties.get(0).getKey();
   }
 
   private static List<SerializableConfigurationPropertiesManagement> toSerializable(
       final List<ConfigurationPropertiesManagement> configurationProperties)
   {
     final List<SerializableConfigurationPropertiesManagement> list =
         new ArrayList<SerializableConfigurationPropertiesManagement>();
     for (final ConfigurationPropertiesManagement instance : configurationProperties)
     {
       final SerializableConfigurationPropertiesManagement serial =
           instance.toSerializable();
       list.add(serial);
     }
     return list;
   }
 
   // --- get&set --------------------------------------------------------------
 
   @Override
   public boolean isInAdminMode()
   {
     return representative().isInAdminMode();
   }
 
   @Override
   public void setToAdminMode(final boolean newMode)
   {
     synchronized (configurationProperties)
     {
       for (final ConfigurationPropertiesManagement instance : configurationProperties)
       {
         instance.setToAdminMode(newMode);
       }
     }
   }
 
   @Override
   public PropertyStoreAccessor getPropertyStoreAccessor()
   {
     return propertyStoreAccessor;
   }
 
   // --- business -------------------------------------------------------------
 
   @Override
   public DescribedProperty getProperty(final PropertyDescriptor descriptor,
       final Object defaultValue) throws IllegalArgumentException,
     UnknownPropertyException
   {
     DescribedProperty property = null;
     for (final ConfigurationPropertiesManagement instance : configurationProperties)
     {
       try
       {
         property = instance.getProperty(descriptor, null);
         if (property != null && property.getValue() != null)
         {
           break;
         }
       }
       catch (final PropertyRootException e)
       {
         // continue to see if the next has a proper value.
       }
     }
 
     if (property == null || property.getValue() == null)
     {
       property = representative().getProperty(descriptor, defaultValue);
     }
 
     return property;
   }
 
   @Override
   public DescribedProperty getProperty(final String key,
       final Object defaultValue) throws IllegalArgumentException,
     UnknownPropertyException
   {
     DescribedProperty property = null;
     for (final ConfigurationPropertiesManagement instance : configurationProperties)
     {
       try
       {
         property = instance.getProperty(key, null);
         if (property != null)
         {
           break;
         }
       }
       catch (final PropertyRootException e)
       {
         // continue to see if the next has a proper value.
       }
     }
 
     if (property == null)
     {
       property = representative().getProperty(key, defaultValue);
     }
 
     return property;
   }
 
   @Override
   public Object getPropertyAsType(final PropertyDescriptor descriptor)
     throws IllegalArgumentException, UnknownPropertyException,
     PropertyValueConversionException, SecurityException, PropertyRootException
   {
     final String plainValue = getPropertyValueAsString(descriptor);
     final Object resolvedValue =
         resolveAndConvert(descriptor, plainValue, null);
     return resolvedValue;
   }
 
   // Duplicated from AbstractConfigurationPropertiesManagement
   @Override
   public ValidatedProperty getValidatedProperty(
       final PropertyDescriptor descriptor, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException,
     PropertyValidationException, SecurityException
   {
     final DescribedProperty property = getProperty(descriptor, defaultValue);
 
     final Object plainValue = property.getValue();
     if (plainValue == null && defaultValue == null && descriptor.isMandatory()
         && !isInAdminMode())
     {
       // 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);
 
       return new ValidatedProperty(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;
   }
 
   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().toString());
   }
 
   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));
   }
 
   @Override
   public void validate(final boolean lenient, final Class<?>... groups)
     throws ConfigurationValidationException
   {
     synchronized (configurationProperties)
     {
       final ConfigurationValidator validator =
           new ConfigurationValidator(this, lenient);
       final PropertyCollection propertyCollection =
           getPropertyStoreAccessor().getPropertyCollectionFromStore();
       validator.validate(propertyCollection, groups);
     }
   }
 
   @Override
   public void validate(final PropertyDescriptor descriptor,
       final Class<?>... groups) throws ConfigurationValidationException
   {
     final Object value = getPropertyValue(descriptor);
     validate(descriptor, value, groups);
   }
 
   @Override
   public void validate(final PropertyDescriptor descriptor, final String value,
       final Class<?>... groups) throws ConfigurationValidationException
   {
     final ConfigurationValidator validator =
         new ConfigurationValidator(this, false);
     final Object resolvedValue = resolveAndConvert(descriptor, value, null);
     validator.validate(descriptor, resolvedValue, groups);
   }
 
   @Override
   public void flush()
   {
     for (final ConfigurationPropertiesManagement instance : configurationProperties)
     {
       instance.flush();
     }
   }
 
   @Override
   public ConfigurationPropertiesManagement toRepresentative()
   {
     return representative();
   }
 
   @Override
   public SerializableConfigurationPropertiesManagement toSerializable()
   {
     return this;
   }
 
   // ... delegate to representative ...........................................
 
   private ConfigurationPropertiesManagement representative()
   {
     return configurationProperties.get(0);
   }
 
   @Override
   public ConfigurationPropertiesManagement addDefinitions(
       final PropertyProvider properties) throws NullPointerException
   {
     return representative().addDefinitions(properties);
   }
 
   /**
    * {@inheritDoc}
    * <p>
    * This method sets the property in the most defining representative. If the
    * client wants to change a value in a specific defaulting representation by
    * its configuration key, the client has to access this particular instance
    * and set it manually.
    * </p>
    */
   @Override
   public Property setProperty(final PropertyKey key, final String value)
     throws NullPointerException, PropertyValidationException,
     ReadOnlyPropertyException
   {
     return representative().setProperty(key, value);
   }
 
   /**
    * {@inheritDoc}
    * <p>
    * This method unsets the property in the most defining representative. If the
    * client wants to change a value in a specific defaulting representation by
    * its configuration key, the client has to access this particular instance
    * and unset it manually.
    * </p>
    */
   @Override
   public Property unsetProperty(final PropertyKey key)
     throws NullPointerException, ReadOnlyPropertyException
   {
     return representative().unsetProperty(key);
   }
 
   @Override
   public void addDescriptors(final Class<?> declaringType)
     throws DuplicatePropertyDeclarationsException
   {
     representative().addDescriptors(declaringType);
   }
 
   @Override
   public PropertyDescriptor getDescriptor(final String key)
     throws UnknownPropertyException
   {
     return representative().getDescriptor(key);
   }
 
   @Override
   public PropertyDescriptor getDescriptor(final PropertyKey key)
     throws UnknownPropertyException
   {
     return representative().getDescriptor(key);
   }
 
   @Override
   public List<PropertyDescriptor> getMandatoryPropertyDescriptors()
   {
     return representative().getMandatoryPropertyDescriptors();
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Returns the string representation of the object.
    *
    * @return the string representation of the object.
    */
   @Override
   public String toString()
   {
     final StringBuilder buffer = new StringBuilder();
 
     for (final SerializableConfigurationPropertiesManagement instance : configurationProperties)
     {
       buffer.append(instance).append("\n======================\n");
     }
 
     return buffer.toString();
   }
 }