/*
    * 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.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  
  import javax.annotation.concurrent.NotThreadSafe;
  
  import org.apache.commons.io.IOUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import de.smartics.properties.api.config.app.BootProperties;
  import de.smartics.properties.api.config.domain.CompoundConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationException;
  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.PropertyLocation;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.core.domain.PropertiesContext;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.spi.core.classpath.PropertiesFilesLoader;
  import de.smartics.properties.spi.core.metadata.PropertyMetaDataParser;
  import de.smartics.util.lang.Arg;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Loads boot properties that influence the loading of properties.
   */
  @NotThreadSafe
  public final class BootLoader
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory.getLogger(BootLoader.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The configuration to add properties to.
     */
    private final ConfigurationPropertiesManagement configuration;
  
    /**
     * The class root URLs to search for property descriptors and properties
     * files.
     */
    private final Collection<URL> rootUrls;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor to initialize class path root URLs.
     *
     * @param configuration the configuration to add properties to.
     * @param classLoader the class loader whose class roots are added.
     * @throws NullArgumentException if {@code configuration} or {@code rootUrls}
     *           is <code>null</code>.
     */
    public BootLoader(final ConfigurationPropertiesManagement configuration,
        final ClassLoader classLoader) throws NullArgumentException
    {
      this.configuration = Arg.checkNotNull("configuration", configuration);
      this.rootUrls = readRootUrls(Arg.checkNotNull("classLoader", classLoader));
    }
  
    // ****************************** Inner Classes *****************************
  
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static List<URL> readRootUrls(final ClassLoader classLoader)
     throws NullArgumentException
   {
     final List<URL> list = new ArrayList<URL>();
     try
     {
       final Enumeration<URL> rootUrls =
           UrlUtil.getResourceUrls(classLoader, "");
 
       while (rootUrls.hasMoreElements())
       {
         final URL rootUrl = rootUrls.nextElement();
         list.add(rootUrl);
       }
       extendClasspath(classLoader, list);
     }
     catch (final IOException e)
     {
       LOG.warn("Cannot determine class path roots for the given class loader.",
           e);
     }
 
     return list;
   }
 
   /**
    * Extends the classpath to contain more / all jars found in this classloader.
    *
    * @param classLoader the classloader in which more resources shall be
    *          searched for.
    * @param list the list to which the additional URLs are appended.
    * @throws IOException when the resources can not be read.
    */
   private static void extendClasspath(final ClassLoader classLoader,
       final List<URL> list) throws IOException
   {
     final Enumeration<URL> metaInfRootUrls =
         UrlUtil.getResourceUrls(classLoader, "/META-INF");
     while (metaInfRootUrls.hasMoreElements())
     {
       final URL rootUrl = metaInfRootUrls.nextElement();
       if (!list.contains(rootUrl))
       {
         list.add(rootUrl);
       }
     }
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Loads the configuration properties instance from information found on the
    * class path.
    *
    * @return the loaded configuration properties instance.
    * @throws CompoundConfigurationException if loading encountered problems.
    */
   public ConfigurationPropertiesManagement load()
     throws CompoundConfigurationException
   {
     final MultiSourceProperties properties = loadProperties();
 
     final List<ConfigurationException> exceptions = properties.getExceptions();
     if (!exceptions.isEmpty())
     {
       throw new CompoundConfigurationException(configuration.getKey(),
           exceptions);
     }
 
     addProperties(properties);
 
     return configuration;
   }
 
   /**
    * Loads the configuration properties instance from information found on the
    * class path.
    *
    * @return the loaded configuration properties instance.
    * @throws ConfigurationValidationException if the validation of the
    *           configuration failed.
    */
   public ConfigurationPropertiesManagement loadAndValidate()
     throws ConfigurationValidationException
   {
     load();
     configuration.validate(true);
 
     return configuration;
   }
 
   private MultiSourceProperties loadProperties()
   {
     final MultiSourceProperties allProperties =
         new MultiSourceProperties(configuration.getKey(),
             new ArrayList<ConfigurationException>());
 
     final PropertiesFilesLoader loader = new PropertiesFilesLoader();
     final Set<String> propertiesFiles = loader.getBootPropertiesFiles(rootUrls);
 
     final ClassLoader classLoader =
         new URLClassLoader(rootUrls.toArray(new URL[rootUrls.size()]), Thread
             .currentThread().getContextClassLoader());
     for (final String propertiesFile : propertiesFiles)
     {
       final Properties properties = loadProperties(classLoader, propertiesFile);
       final PropertyLocation location =
           new PropertyLocationHelper().createPropertyLocation(classLoader,
               propertiesFile);
       allProperties.add(location, properties);
     }
 
     return allProperties;
   }
 
   private Properties loadProperties(final ClassLoader classLoader,
       final String propertiesFile)
   {
     // TODO: There is a similar method in PropertiesUtils: Refactor
     final Properties properties = new Properties();
     InputStream in = classLoader.getResourceAsStream(propertiesFile);
     try
     {
       if (in != null)
       {
         in = new BufferedInputStream(in);
         properties.load(in);
       }
       else
       {
         LOG.warn("Cannot find properties '" + propertiesFile
                  + "' in class path.");
       }
     }
     catch (final IOException e)
     {
       LOG.warn("Cannot load properties from '" + propertiesFile + "'.");
     }
     finally
     {
       IOUtils.closeQuietly(in);
     }
 
     return properties;
   }
 
   private void addProperties(final MultiSourceProperties compositeProperties)
   {
     final Properties properties = new Properties();
     final Class<?> type = BootProperties.class;
 
     final PropertiesContext context = configuration.getContext(type);
     final PropertyMetaDataParser propertyDescriptorParser =
         PropertyMetaDataParser.create(context);
 
     final List<PropertyDescriptor> descriptors =
         propertyDescriptorParser.readDescriptors(type);
 
     for (final PropertyDescriptor descriptor : descriptors)
     {
       final String propertyKey = descriptor.getKey().toString();
       final Property property = compositeProperties.getValue(propertyKey);
       if (property != null && property.getValue() != null)
       {
         properties.put(propertyKey, property);
       }
       else
       {
         properties.remove(propertyKey);
       }
     }
 
     configuration.addDescriptors(type);
     final PropertyProvider provider =
         new PropertiesPropertyProvider(configuration.getKey(),
             new PropertyLocation("boot-various"), properties);
     configuration.addDefinitions(provider);
   }
 
   // --- object basics --------------------------------------------------------
 
 }