/*
    * 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.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.util.ClassLoaderUtils;
  import de.smartics.util.lang.Arguments;
  import de.smartics.util.lang.ClassPathContext;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * 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 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;
 
   // ****************************** 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.
    * @throws NullArgumentException if {@code factoryCache} is <code>null</code>
    *           .
    */
   public ClassPathLoader(final FactoryCache<T> factoryCache,
       final boolean lenient, final boolean skipPropertyLoading)
     throws NullArgumentException
   {
     Arguments.checkNotNull("factoryCache", factoryCache);
 
     this.factoryCache = factoryCache;
     this.lenient = lenient;
     this.skipPropertyLoading = skipPropertyLoading;
   }
 
   // ****************************** 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
   {
     Arguments.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
   {
     Arguments.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
   {
     Arguments.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();
 
     for (final MultiSourceProperties properties : propertiesManager
         .getProperties())
     {
       final List<ConfigurationException> exceptions =
           properties.getExceptions();
       if (!exceptions.isEmpty())
       {
         throw new CompoundConfigurationException(
             properties.getConfigurationKey(), exceptions);
       }
 
       addProperties(descriptors, properties);
     }
 
     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);
 
     if (!skipPropertyLoading)
     {
       final PropertiesFilesLoader loader = new PropertiesFilesLoader();
       LOG.debug("Loading properties/Root location URLs: {}", rootUrls);
       final Set<String> propertiesFiles = loader.getPropertiesFiles(rootUrls);
 
       final ClassLoader classLoader =
           new URLClassLoader(rootUrls.toArray(new URL[rootUrls.size()]), Thread
               .currentThread().getContextClassLoader());
       for (final String propertiesFile : propertiesFiles)
       {
         if (propertiesFile.contains("META-INF"))
         {
           continue;
         }
 
         final ClassPathContext context =
             ClassLoaderUtils
                 .createClassPathContext(classLoader, propertiesFile);
         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.");
         }
       }
     }
     else
     {
       allPropertiesManager.create();
     }
 
     return allPropertiesManager;
   }
 
   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 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 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);
         if (property != null && property.getValue() != null)
         {
           properties.put(propertyKey, property);
         }
       }
 
       final ConfigurationKey key = compositeProperties.getConfigurationKey();
       final ConfigurationPropertiesManagement configuration =
           factoryCache.ensureManagement(key);
       configuration.addDefinitions(properties);
     }
   }
 
   /**
    * Adds all class path root URLs provided by the context class loader of the
    * current thread.
    *
    * @param registry the registry to resolve property descriptors.
    * @throws NullPointerException of either {@code key} or {@code registry} is
    *           <code>null</code>.
    */
   public void addDefaultRootUrls(final PropertyDescriptorRegistry registry)
     throws NullPointerException
   {
     Arguments.checkNotNull("registry", registry);
 
     addBootRootUrls(registry);
     addRootUrl(Thread.currentThread().getContextClassLoader());
   }
 
   private void addBootRootUrls(final PropertyDescriptorRegistry registry)
   {
     final BootConfigurationProperties initBootConfiguration =
         new BootConfigurationProperties(registry);
     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);
         addRootUrl(normalized);
       }
     }
   }
 
   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 --------------------------------------------------------
 
 }