/*
    * 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.properties.spi.core.validate.PropertyValidator;
  import de.smartics.util.lang.Arg;
  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,
       final Class<?>... groups) // NOPMD
     throws NullArgumentException, ConfigurationValidationException
   {// CHECKSTYLE:ON
     Arg.checkNotNull("properties", properties);
 
     final List<PropertyException> propertyViolations =
         new ArrayList<PropertyException>();
     final UnknownProperties unvalidatedProperties = new UnknownProperties();
     final List<PropertyDescriptor> mandatoryProperties =
         configuration.getMandatoryPropertyDescriptors();
 
     try
     {
       for (final Class<?> group : calcGroups(groups))
       {
         for (final Property property : properties)
         {
           final String key = property.getName();
 
           try
           {
             final PropertyDescriptor descriptor =
                 configuration.getDescriptor(key);
 
             try
             {
               final Object value = configuration.getPropertyAsType(descriptor);
               validate(descriptor, value, group);
               mandatoryProperties.remove(descriptor);
             }
             catch (final PropertyException e)
             {
               if (property.getValue() != null)
               {
                 propertyViolations.add(e);
               }
             }
           }
           catch (final UnknownPropertyException e)
           {
             unvalidatedProperties.add(property);
           }
         }
       }
     }
     finally
     {
       properties.close();
     }
 
     if (isExceptionToBeThrown(propertyViolations, mandatoryProperties,
         unvalidatedProperties))
     {
       throw new ConfigurationValidationException(configuration.getKey(),
           propertyViolations, mandatoryProperties, unvalidatedProperties);
     }
 
     if (!unvalidatedProperties.isEmpty() && !lenient)
     {
       LOG.warn("Encountered unknown properies: {}", unvalidatedProperties);
     }
   }
 
   private Class<?>[] calcGroups(final Class<?>[] groups)
   {
     if (groups != null && groups.length > 0)
     {
       return groups;
     }
     return new Class[] { null };
   }
 
   /**
    * Validates the given value for the given descriptor and groups.
    *
    * @param descriptor the descriptor to determine the constraints to check.
    * @param value the value to check.
    * @param groups the constraint groups to consider. If empty or
    *          <code>null</code> only the constraints in the default are checked.
    */
   public void validate(final PropertyDescriptor descriptor, final Object value,
       final Class<?>... groups)
   {
     final PropertyValidator validator =
         new PropertyValidator(configuration.isInAdminMode());
     validator.validate(descriptor, value, groups);
   }
 
   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 --------------------------------------------------------
 
 }