/*
    * 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.transfer;
  
  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.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  import java.util.logging.Logger;
  
  import org.apache.commons.io.IOUtils;
  
  import de.smartics.exceptions.runtime.ExceptionContextManager;
  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.resource.domain.ArtifactRef;
  import de.smartics.properties.resource.domain.ClassPathEnvironment;
  import de.smartics.properties.spi.config.definition.DefinitionConfigParser;
  import de.smartics.properties.spi.config.definition.PropertiesDefinitionContext;
  import de.smartics.properties.spi.config.support.PropertiesHelper;
  import de.smartics.properties.spi.config.support.PropertiesPropertyProvider;
  import de.smartics.properties.spi.core.classpath.PropertiesFilesLoader;
  import de.smartics.util.lang.Arg;
  
  /**
   * Collects property providers to make them accessible by the transfer process
   * as a source of property definitions.
   */
  public final class PropertyProviderList implements Iterable<PropertyProvider>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Reference to the logger for this instance.
     */
    private final Logger log = Logger.getLogger(ExceptionContextManager.class
        .getName());
  
    /**
     * The list of property definitions.
     */
    private final List<PropertyProvider> propertyProviders =
        new ArrayList<PropertyProvider>(64);
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public PropertyProviderList()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Adds a property provider.
     *
     * @param provider the provider to add.
     * @throws NullPointerException if {@code provider} is <code>null</code>.
     */
   public void addPropertyProvider(final PropertyProvider provider)
     throws NullPointerException
   {
     Arg.checkNotNull("provider", provider);
     propertyProviders.add(provider);
   }
 
   /**
    * Resolves the environment to property providers and adds them.
    *
    * @param definitionConfigParser the parser to read
    *          <code>definition.xml</code> files to determine the configuration
    *          keys for properties files.
    * @param env the environment containing properties files. Each of them will
    *          be turned into a provider and added to the list.
    * @throws NullPointerException if {@code env} is <code>null</code>.
    * @throws TransferException if any of the artifacts provided in the
    *           environment {@code env} is not valid. An artifact is not valid,
    *           if the configuration key for a properties file cannot be
    *           determined. Also thrown if a properties file cannot be mapped to
    *           a configuration key.
    */
   public void addPropertyDefinitions(
       final DefinitionConfigParser<?> definitionConfigParser,
       final ClassPathEnvironment env) throws NullPointerException,
     TransferException
   {
     Arg.checkNotNull("env", env);
 
     final List<ArtifactRef> artifactRefs = env.getArtifactRefs();
     if (artifactRefs.isEmpty())
     {
       return;
     }
 
     final PropertiesFilesLoader loader = new PropertiesFilesLoader();
     for (final ArtifactRef artifactRef : artifactRefs)
     {
       final PropertiesDefinitionContext context =
           readDefinition(definitionConfigParser, artifactRef);
       if (context == null)
       {
         continue;
       }
 
       final URL rootUrl = artifactRef.getUrl();
       final Collection<URL> rootUrls = Collections.singleton(rootUrl);
       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 ConfigurationKey<?> key = getKey(context, propertiesFile);
         final PropertiesHelper helper = new PropertiesHelper(key);
         // FIXME: Instead of loading all properties into memory we should read
         // them on demand. This could be accomplished by adding a
         // PropertyProvider that reads the properties only on demand and is able
         // to remove them as soon as all are read.
         final Properties properties =
             helper.readProperties(classLoader, propertiesFile);
         final PropertyLocation sourceId = new PropertyLocation(propertiesFile);
         final PropertyProvider provider =
             new PropertiesPropertyProvider(key, sourceId, properties);
         propertyProviders.add(provider);
       }
     }
   }
 
   private ConfigurationKey<?> getKey(final PropertiesDefinitionContext context,
       final String propertiesFile) throws TransferException
   {
     final ConfigurationKey<?> key = context.getKey(propertiesFile);
     if (key == null)
     {
       throw new TransferException(
           new NoConfigurationKeyForPropertiesMessageBean(propertiesFile));
     }
     return key;
   }
 
   private PropertiesDefinitionContext readDefinition(
       final DefinitionConfigParser<?> definitionConfigParser,
       final ArtifactRef artifactRef) throws IllegalArgumentException
   {
     InputStream input = null;
     try
     {
       final URL url = calcDefinitionXmlUrl(artifactRef);
       final String systemId =
           artifactRef.getId().toString() + ':' + url.toExternalForm();
 
       input = new BufferedInputStream(url.openStream());
       final PropertiesDefinitionContext context =
           definitionConfigParser.parse(systemId, input);
       return context;
     }
     catch (final MalformedURLException e)
     {
       final TransferMessageBean message =
           DefinitionXmlMessageBean.malformedUrl(e, artifactRef);
       log.fine(message.toString());
       throw new TransferException(message);
     }
     catch (final IOException e)
     {
       final TransferMessageBean message =
           DefinitionXmlMessageBean.missingDefinition(e, artifactRef);
       log.fine(message.toString());
       throw new TransferException(message);
     }
     finally
     {
       IOUtils.closeQuietly(input);
     }
   }
 
   private static URL calcDefinitionXmlUrl(final ArtifactRef artifactRef)
     throws MalformedURLException
   {
     final URL url;
     if (artifactRef.getUrl().toExternalForm().endsWith(".jar"))
     {
       url = calcDefinitionXmlUrlFromJar(artifactRef);
     }
     else
     {
       url = calcDefinitionXmlUrlForDir(artifactRef);
     }
     return url;
   }
 
   private static URL calcDefinitionXmlUrlFromJar(final ArtifactRef artifactRef)
     throws MalformedURLException
   {
     final String jarUrl = artifactRef.getUrl().toExternalForm();
     final URL definitionXmlUrl =
         new URL("jar:" + jarUrl + "!/" + PropertiesContext.DEFINITION_FILE);
     return definitionXmlUrl;
   }
 
   private static URL calcDefinitionXmlUrlForDir(final ArtifactRef artifactRef)
     throws MalformedURLException
   {
     final String jarUrl = artifactRef.getUrl().toExternalForm();
     final URL definitionXmlUrl =
         new URL(jarUrl + PropertiesContext.DEFINITION_FILE);
     return definitionXmlUrl;
   }
 
   @Override
   public Iterator<PropertyProvider> iterator()
   {
     return propertyProviders.iterator();
   }
 
   // --- object basics --------------------------------------------------------
 
 }