/*
    * 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(classLoader
         .getResources(PropertiesContext.META_INF_HOME)))
     {
       final URL rootUrl = truncateUrl(url);
       addRootUrl(rootUrl);
     }
   }
 
   private static URL truncateUrl(final URL url)
   {
     final String urlString = url.toExternalForm();
     final boolean isJar = "jar".equals(url.getProtocol());
     final int last;
     if (isJar)
     {
       last = urlString.indexOf('!') + 2;
     }
     else
     {
       last = urlString.length() - PropertiesContext.META_INF_HOME.length() - 1;
     }
 
     final String urlStringTruncated = urlString.substring(0, last);
     URL urlTruncated;
     try
     {
       urlTruncated = new URL(urlStringTruncated);
       return urlTruncated;
     }
     catch (final MalformedURLException e)
     {
       LOG.warn("Cannot use URL '{}' in its truncated form '{}'.", url,
           urlStringTruncated);
       return 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();
   }
 }