/*

  * 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.MalformedURLException;

 import java.net.URL;

 import java.net.URLClassLoader;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 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.ConfigurationRepositoryManagement;

 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.config.domain.key.ConfigurationKey;

 import de.smartics.properties.api.core.domain.PropertiesContext;

 import de.smartics.properties.api.core.domain.PropertyDescriptor;

 import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;

 import de.smartics.properties.api.core.security.PropertyValueSecurity;

 import de.smartics.properties.spi.config.definition.DefinitionKeyHelper;

 import de.smartics.properties.spi.core.classpath.PropertiesFilesLoader;

 import de.smartics.properties.spi.core.classpath.PropertySetClassesLoader;

 import de.smartics.properties.spi.core.metadata.PropertyMetaDataParser;

 import de.smartics.properties.spi.core.registry.InMemoryPropertyDescriptorRegistry;

 import de.smartics.properties.spi.core.util.ClassLoaderUtils;

 import de.smartics.util.lang.Arg;

 import de.smartics.util.lang.NullArgumentException;

 import de.smartics.util.lang.classpath.ClassPathContext;

 /**

  * Loads property descriptors and properties files found on the class path.

  *

  * @param <T> the concrete type of the returned configuration properties.

  */

 @NotThreadSafe

 public final class ClassPathLoader<T extends ConfigurationPropertiesManagement>

 { // NOPMD

   // ********************************* Fields *********************************

   // --- constants ------------------------------------------------------------

   /**

    * Reference to the logger for this class.

    */

   private static final Logger LOG = LoggerFactory

       .getLogger(ClassPathLoader.class);

   // --- members --------------------------------------------------------------

   /**

    * The cache to create and cache new configuration properties instances.

    */

   private final FactoryCache<T> factoryCache;

   /**

    * The class root URLs to search for property descriptors and properties

    * files.

    */

   private final Collection<URL> rootUrls = new ArrayList<URL>();

   /**

    * The root URLs to search for additional properties files. These URLs are

    * always considered for properties files.

    */

   private final Collection<URL> additionalRootUrls = new ArrayList<URL>();

   /**

    * The additional properties added by other means than loading them from the

    * class path.

    */

   private final Collection<PropertyProvider> rootPropertyProviders =

       new ArrayList<PropertyProvider>();

   /**

    * The flag indicates that configuration problems are not signaled by

    * exceptions.

    */

   private final boolean lenient;

   /**

    * The flag indicates that loading properties form the class path is to be

    * skipped.

    */

   private final boolean skipPropertyLoading;

   /**

    * The helper to decrypt secured property values.

    */

   private final PropertyValueSecurity decrypter;

   // ****************************** Initializer *******************************

   // ****************************** Constructors ******************************

   /**

    * Default constructor.

    *

    * @param factoryCache the cache to create and cache new configuration

    *          properties instances.

    * @param lenient the flag indicates that configuration problems are not

    *          signaled by exceptions.

    * @param skipPropertyLoading the flag indicates that loading properties from

    *          the class path is to be skipped.

    * @param decrypter the helper to decrypt secured property values.

    * @throws NullArgumentException if {@code factoryCache} or {@code decrypter}

    *           is <code>null</code>.

    */

   public ClassPathLoader(final FactoryCache<T> factoryCache,

       final boolean lenient, final boolean skipPropertyLoading,

       final PropertyValueSecurity decrypter) throws NullArgumentException

   {

     this.factoryCache = Arg.checkNotNull("factoryCache", factoryCache);

     this.lenient = lenient;

     this.skipPropertyLoading = skipPropertyLoading;

     this.decrypter = Arg.checkNotNull("decrypter", decrypter);

   }

   // ****************************** Inner Classes *****************************

   // ********************************* Methods ********************************

   // --- init -----------------------------------------------------------------

   // --- get&set --------------------------------------------------------------

   /**

    * Adds the given URL to the set of class path root URLs.

    *

    * @param rootUrl the URL to add as a class path root URL.

    * @throws NullArgumentException if {@code rootUrl} is <code>null</code>.

    */

   public void addRootUrl(final URL rootUrl) throws NullArgumentException

   {

     Arg.checkNotNull("rootUrl", rootUrl);

     if (!rootUrls.contains(rootUrl))

     {

       rootUrls.add(rootUrl);

     }

   }

   /**

    * Adds the root URL of the given {@code exemplar} to the set of class path

    * root URLs.

    *

    * @param exemplar a sample class to derive the root URL from.

    * @throws NullArgumentException if {@code exemplar} is <code>null</code>.

    */

   public void addRootUrl(final Class<?> exemplar) throws NullArgumentException

   {

     Arg.checkNotNull("exemplar", exemplar);

     addRootUrl(Thread.currentThread().getContextClassLoader());

   }

   /**

    * Adds the relevant root URL of the given {@code classLoader} to the set of

    * class path root URLs.

    * <p>

    * Only archives that contain the

    * <code>{@value de.smartics.properties.api.core.domain.PropertiesContext#META_INF_HOME}</code>

    * are relevant and therefore added.

    * </p>

    *

    * @param classLoader the class loader whose class roots are added.

    * @throws NullArgumentException if {@code exemplar} is <code>null</code>.

    */

   public void addRootUrl(final ClassLoader classLoader)

     throws NullArgumentException

   {

     Arg.checkNotNull("classLoader", classLoader);

     try

     {

       addResources(classLoader);

     }

     catch (final IOException e)

     {

       LOG.warn("Cannot determine class path roots for the given class loader.",

           e);

     }

   }

   private void addResources(final ClassLoader classLoader) throws IOException

   {

     for (final URL url : Collections.list(UrlUtil.getResourceUrlsFromFolder(

         classLoader, PropertiesContext.META_INF_HOME)))

     {

       addRootUrl(url);

     }

   }

   // --- 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 ConfigurationRepositoryManagement load()

     throws CompoundConfigurationException

   {

     final Set<Class<?>> propertyDescriptorTypes = loadPropertyDescriptors();

     final Map<Class<?>, List<PropertyDescriptor>> descriptors =

         calcDescriptors(propertyDescriptorTypes);

     factoryCache.registerDescriptors(descriptors);

     final MultiSourcePropertiesManager propertiesManager = loadProperties();

     try

     {

       for (final MultiSourceProperties properties : propertiesManager

           .getProperties())

       {

         final List<ConfigurationException> exceptions =

             properties.getExceptions();

         if (!exceptions.isEmpty())

         {

           throw new CompoundConfigurationException(

               properties.getConfigurationKey(), exceptions);

         }

         addProperties(descriptors, properties);

       }

     }

     finally

     {

       propertiesManager.release();

     }

     return factoryCache.getCache();

   }

   private Set<Class<?>> loadPropertyDescriptors()

   {

     final PropertySetClassesLoader loader = new PropertySetClassesLoader();

     final Set<Class<?>> propertyDescriptorTypes =

         loader.getPropertySetTypes(rootUrls);

     return propertyDescriptorTypes;

   }

   private MultiSourcePropertiesManager loadProperties()

   {

     final MultiSourcePropertiesManager allPropertiesManager =

         new MultiSourcePropertiesManager(lenient, rootPropertyProviders);

     loadProperties(allPropertiesManager);

     if (skipPropertyLoading)

     {

       allPropertiesManager.create();

     }

     return allPropertiesManager;

   }

   private void loadProperties(

       final MultiSourcePropertiesManager allPropertiesManager)

   {

     final Collection<URL> propertiesUrls = createPropertiesUrls();

     if (!propertiesUrls.isEmpty())

     {

       final PropertiesFilesLoader loader = new PropertiesFilesLoader();

       LOG.debug("Loading properties/Root location URLs: {}", propertiesUrls);

       final Set<String> propertiesFiles =

           loader.getPropertiesFiles(propertiesUrls);

       final ClassLoader classLoader =

           new URLClassLoader(propertiesUrls.toArray(new URL[propertiesUrls

               .size()]), Thread.currentThread().getContextClassLoader());

       for (final String propertiesFile : propertiesFiles)

       {

         if (propertiesFile.contains("META-INF"))

         {

           continue;

         }

         final ClassPathContext context =

             ClassLoaderUtils

                 .createClassPathContext(classLoader, propertiesFile);

         if (!isDefintionsArchive(context))

         {

           continue;

         }

         final DefinitionKeyHelper helper =

             allPropertiesManager.getDefinition(context);

         if (helper != null)

         {

           addProperties(allPropertiesManager, classLoader, propertiesFile,

               helper);

         }

         else

         {

           LOG.warn("Skipping '" + propertiesFile + "' since no '"

                    + PropertiesContext.META_INF_HOME + "' provided.");

         }

       }

     }

   }

   private static boolean isDefintionsArchive(final ClassPathContext context)

   {

     final URL url = context.getResource(PropertiesContext.DEFINITION_FILE);

     return url != null;

   }

   private Collection<URL> createPropertiesUrls()

   {

     if (skipPropertyLoading)

     {

       return this.additionalRootUrls;

     }

     else

     {

       final Collection<URL> urls =

           new ArrayList<URL>(additionalRootUrls.size() + rootUrls.size());

       urls.addAll(additionalRootUrls);

       urls.addAll(rootUrls);

       return urls;

     }

   }

   private void addProperties(

       final MultiSourcePropertiesManager allPropertiesManager,

       final ClassLoader classLoader, final String propertiesFile,

       final DefinitionKeyHelper helper) throws IllegalArgumentException

   {

     final ConfigurationKey<?> key = helper.parse(propertiesFile);

     final MultiSourceProperties allProperties =

         allPropertiesManager.create(key);

     final PropertyLocation location =

         new PropertyLocationHelper().createPropertyLocation(classLoader,

             propertiesFile);

     final Properties properties = loadProperties(classLoader, propertiesFile);

     allProperties.add(location, properties);

   }

   private Properties loadProperties(final ClassLoader classLoader,

       final String propertiesFile)

   {

     // TODO: There is a similar method in PropertiesHelper: 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 Map<Class<?>, List<PropertyDescriptor>> calcDescriptors(

       final Set<Class<?>> propertyDescriptorTypes)

   {

     final Map<Class<?>, List<PropertyDescriptor>> map =

         new HashMap<Class<?>, List<PropertyDescriptor>>();

     for (final Class<?> type : propertyDescriptorTypes)

     {

       final PropertiesContext context = factoryCache.getContext(type);

       if (context == null)

       {

         LOG.debug("Cannot find context for type '" + type.getName()

                   + "'. Skipping.");

         continue;

       }

       final PropertyMetaDataParser propertyDescriptorParser =

           PropertyMetaDataParser.create(context);

       final List<PropertyDescriptor> descriptors =

           propertyDescriptorParser.readDescriptors(type);

       map.put(type, descriptors);

     }

     return map;

   }

   private void addProperties(

       final Map<Class<?>, List<PropertyDescriptor>> descriptorMap,

       final MultiSourceProperties compositeProperties)

   {

     final Properties properties = new Properties();

     for (final Entry<Class<?>, List<PropertyDescriptor>> entry : descriptorMap

         .entrySet())

     {

       final List<PropertyDescriptor> descriptors = entry.getValue();

       for (final PropertyDescriptor descriptor : descriptors)

       {

         final String propertyKey = descriptor.getKey().toString();

         final Property property =

             compositeProperties.getValue(propertyKey, true);

         if (property != null && property.getValue() != null)

         {

           properties.put(propertyKey, property);

         }

       }

     }

     final ConfigurationKey<?> key = compositeProperties.getConfigurationKey();

     final ConfigurationPropertiesManagement configuration =

         factoryCache.ensureManagement(key);

     final PropertyProvider provider =

         new PropertiesPropertyProvider(key, new PropertyLocation(

             "classpath-various"), properties);

     configuration.addDefinitions(provider);

   }

   /**

    * Adds all class path root URLs provided by the context class loader of the

    * current thread.

    */

   public void addDefaultRootUrls()

   {

     addBootRootUrls();

     addRootUrl(Thread.currentThread().getContextClassLoader());

   }

   private void addBootRootUrls()

   {

     final PropertyDescriptorRegistry registry =

         new InMemoryPropertyDescriptorRegistry();

     final BootConfigurationProperties initBootConfiguration =

         new BootConfigurationProperties(registry, decrypter);

     final BootLoader bootLoader =

         new BootLoader(initBootConfiguration, Thread.currentThread()

             .getContextClassLoader());

     final ConfigurationPropertiesManagement bootConfiguration =

         bootLoader.loadAndValidate();

     final BootProperties confProperties =

         bootConfiguration.getProperties(BootProperties.class);

     final List<URL> urls = confProperties.additionalPropertiesLocations();

     if (urls != null)

     {

       for (final URL url : urls)

       {

         final URL normalized = normalize(url);

         addAdditionalRootUrl(normalized);

       }

     }

   }

   private void addAdditionalRootUrl(final URL rootUrl)

   {

     Arg.checkNotNull("rootUrl", rootUrl);

     if (!additionalRootUrls.contains(rootUrl))

     {

       additionalRootUrls.add(rootUrl);

     }

   }

   private static URL normalize(final URL url)

   {

     final String urlString = url.toExternalForm();

     if (urlString.indexOf(urlString.length() - 1) != '/')

     {

       try

       {

         return new URL(urlString + '/');

       }

       catch (final MalformedURLException e)

       {

         LOG.warn("Cannot append '/' to '" + urlString

                  + "' for normalization. Using unnormalized URL instead.", e);

       }

     }

     return url;

   }

   /**

    * Adds the given root URLs to the collection of class path roots managed by

    * this class loader. The root locations are used for searching property

    * declarations and property definitions.

    *

    * @param rootLocations the additional root locations to search for property

    *          declarations and definitions.

    */

   public void addRootUrls(final List<URL> rootLocations)

   {

     this.rootUrls.addAll(rootLocations);

   }

   /**

    * Adds the given property providers as additional property definitions.

    * Values provided by these instances are taken into account similar to any

    * property definitions found on the class path.

    * <p>

    * Property values provided by these providers take precedence over any

    * property values found on the class path.

    * </p>

    *

    * @param rootPropertyProviders the additional property definitions to add.

    */

   public void addRootProperties(

       final List<PropertyProvider> rootPropertyProviders)

   {

     this.rootPropertyProviders.addAll(rootPropertyProviders);

   }

   // --- 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();

     final char returnChar = '\n';

     buffer.append("== Root URLs:");

     for (final URL url : rootUrls)

     {

       buffer.append(returnChar).append("  ").append(url.toExternalForm());

     }

     buffer.append(returnChar).append("== Additional root URLs:");

     for (final URL url : additionalRootUrls)

     {

       buffer.append(returnChar).append("  ").append(url.toExternalForm());

     }

     buffer.append(returnChar).append("\n== Root Property Providers:");

     for (final PropertyProvider provider : rootPropertyProviders)

     {

       buffer.append(returnChar).append("  ").append(provider);

     }

     buffer.append(returnChar).append("== Factory Cache:\n");

     buffer.append(factoryCache);

     buffer.append(returnChar).append("== Properties:");

     buffer.append(returnChar).append("  Lenient validation  : ")

         .append(lenient);

     buffer.append(returnChar).append("  Skip propertyLoading: ")

         .append(skipPropertyLoading);

     return buffer.toString();

   }

 }