/*
    * 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.validation;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  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.UnknownProperties;
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyException;
  import de.smartics.util.lang.Arguments;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Helper to validate sets of properties. Helpful for
   * {@link de.smartics.properties.api.config.domain.ConfigurationProperties}.
   */
  public final class ConfigurationValidator implements Serializable
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory
        .getLogger(ConfigurationValidator.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The configuration to validate.
     */
    private final ConfigurationPropertiesManagement configuration;
  
    /**
     * The lenient flag that tells the validation process to handle unknown
     * properties gracefully if set to <code>true</code>. If the value is
     * <code>false</code> unknown properties are reported as validation failures.
     */
    private final boolean lenient;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor for non-lenient validation.
     *
     * @param configuration the configuration to validate.
     */
    public ConfigurationValidator(
        final ConfigurationPropertiesManagement configuration)
    {
      this(configuration, false);
    }
  
    /**
     * Default constructor.
     *
     * @param configuration the configuration to validate.
     * @param lenient the lenient flag that tells the validation process to handle
     *          unknown properties gracefully if set to <code>true</code>.
     */
    public ConfigurationValidator(
        final ConfigurationPropertiesManagement configuration,
        final boolean lenient)
    {
      this.configuration = configuration;
      this.lenient = lenient;
    }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   // CHECKSTYLE:OFF
   /**
    * Validates the given properties.
    *
    * @param properties the properties to validate.
    * @throws NullArgumentException if {@code properties} is <code>null</code>.
    * @throws ConfigurationValidationException if validation fails.
    */
   public void validate(final PropertyCollection properties) // NOPMD
     throws NullArgumentException, ConfigurationValidationException
   {// CHECKSTYLE:ON
     Arguments.checkNotNull("properties", properties);
 
     final List<PropertyException> propertyViolations =
         new ArrayList<PropertyException>();
     final UnknownProperties unvalidatedProperties = new UnknownProperties();
     final List<PropertyDescriptor> mandatoryProperties =
         configuration.getMandatoryPropertyDescriptors();
 
     for (final Property property : properties)
     {
       final String key = property.getName();
 
       try
       {
         final PropertyDescriptor descriptor = configuration.getDescriptor(key);
 
         try
         {
           configuration.getPropertyValue(descriptor);
           mandatoryProperties.remove(descriptor);
         }
         catch (final PropertyException e)
         {
           if (property.getValue() != null)
           {
             propertyViolations.add(e);
           }
         }
       }
       catch (final UnknownPropertyException e)
       {
         unvalidatedProperties.add(property);
       }
     }
 
     if (isExceptionToBeThrown(propertyViolations, mandatoryProperties,
         unvalidatedProperties))
     {
       throw new ConfigurationValidationException(configuration.getKey(),
           propertyViolations, mandatoryProperties, unvalidatedProperties);
     }
 
     if (!unvalidatedProperties.isEmpty() && !lenient)
     {
       LOG.warn("Encountered unknown properies: {}", unvalidatedProperties);
     }
   }
 
   private boolean isExceptionToBeThrown(
       final List<PropertyException> propertyViolations,
       final List<PropertyDescriptor> mandatoryProperties,
       final UnknownProperties unvalidatedProperties)
   {
     boolean exceptional =
         !(propertyViolations.isEmpty() && mandatoryProperties.isEmpty());
     if (!exceptional)
     {
       exceptional = !(lenient || unvalidatedProperties.isEmpty());
     }
     return exceptional;
   }
 
   // --- object basics --------------------------------------------------------
 
 }