/*
    * 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.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.UUID;
  
  import javax.annotation.CheckForNull;
  import javax.annotation.concurrent.NotThreadSafe;
  
  import de.smartics.properties.api.config.domain.ConfigurationException;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.spi.config.cache.Cache;
  import de.smartics.properties.spi.config.cache.CacheManagerFactory;
  import de.smartics.properties.spi.config.definition.DefinitionConfigParser;
  import de.smartics.properties.spi.config.definition.DefinitionKeyHelper;
  import de.smartics.properties.spi.config.definition.PropertiesDefinitionContext;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
  import de.smartics.util.lang.classpath.ClassPathContext;
  
  /**
   * Helper to provide multiple sources for any configurations found.
   */
  @NotThreadSafe
  public final class MultiSourcePropertiesManager
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The additional properties added by other means than loading them from the
     * class path.
     */
    private final Collection<PropertyProvider> rootPropertyProviders;
  
    /**
     * The flag indicates that configuration problems are not signaled by
     * exceptions.
     */
    private final boolean lenient;
  
    /**
     * The unique identifier of the definition cache.
     */
    private final String definitionCacheId = createId("DefinitionCache");
  
    /**
     * The unique identifier of the dictionary cache.
     */
    private final String dictionaryCacheId = createId("Dictionary");
  
    /**
     * The dictionary cache to map a configuration key to a properties collection.
     */
    @SuppressWarnings("unchecked")
    private final Cache<ConfigurationKey<?>, MultiSourceProperties> dictionaryCache =
        (Cache<ConfigurationKey<?>, MultiSourceProperties>) CacheManagerFactory
            .getConfigurationsCache(dictionaryCacheId);
  
    /**
     * The cache for property definition information loaded from
     * {@value de.smartics.properties.api.core.domain.PropertiesContext#DEFINITION_FILE}
     * or the default (which may be <code>null</code> if
     * {@value de.smartics.properties.api.core.domain.PropertiesContext#META_INF_HOME}
     * is absent).
     * <p>
     * The key is the path to the root folder that contains the
     * <code>META-INF</code> folder for a given resource in form of a
     * {@link ClassPathContext} instance.
     * </p>
     */
    @SuppressWarnings("unchecked")
    private final Cache<ClassPathContext, DefinitionKeyHelper> definitionCache =
        (Cache<ClassPathContext, DefinitionKeyHelper>) CacheManagerFactory
            .getConfigurationsCache(definitionCacheId);
  
    // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   MultiSourcePropertiesManager(final boolean lenient,
       final Collection<PropertyProvider> rootPropertyProviders)
   {
     this.lenient = lenient;
     this.rootPropertyProviders = rootPropertyProviders;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static String createId(final String discriminator)
   {
     final UUID uuid = UUID.randomUUID();
     final String id =
         "Management:DefinitionKeyHelper:" + discriminator + "/" + uuid;
     return id;
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   MultiSourceProperties create(final ConfigurationKey<?> key)
   {
     MultiSourceProperties allProperties = dictionaryCache.get(key);
     if (allProperties == null)
     {
       allProperties =
           new MultiSourceProperties(key, lenient ? null
               : new ArrayList<ConfigurationException>());
       allProperties.addProviders(rootPropertyProviders);
       dictionaryCache.put(key, allProperties);
     }
 
     return allProperties;
   }
 
   void create()
   {
     for (final PropertyProvider provider : rootPropertyProviders)
     {
       final ConfigurationKey<?> key = provider.getConfigurationKey();
       MultiSourceProperties allProperties = dictionaryCache.get(key);
       if (allProperties == null)
       {
         allProperties =
             new MultiSourceProperties(key, lenient ? null
                 : new ArrayList<ConfigurationException>());
         allProperties.addProvider(provider);
         dictionaryCache.put(key, allProperties);
       }
     }
   }
 
   void release()
   {
     CacheManagerFactory.discard(dictionaryCacheId);
     CacheManagerFactory.discard(definitionCacheId);
   }
 
   /**
    * Returns the definition information for the given class loader.
    *
    * @param context the class loader and the root folder to read the
    *          <code>{@value de.smartics.properties.api.core.domain.PropertiesContext#DEFINITION_FILE_NAME}</code>
    *          .
    * @return the definition helper if there is a
    *         <code>{@value de.smartics.properties.api.core.domain.PropertiesContext#DEFINITION_FILE_NAME}</code>
    *         or at least
    *         {@value de.smartics.properties.api.core.domain.PropertiesContext#META_INF_HOME}
    *         , <code>null</code> otherwise.
    */
   @CheckForNull
   DefinitionKeyHelper getDefinition(final ClassPathContext context)
   {
     DefinitionKeyHelper definition = definitionCache.get(context);
     if (definition == null)
     {
       final DefinitionConfigParser<?> parser =
           ConfigurationKeyContextManager.INSTANCE.context()
               .definitionConfigParser();
 
       final PropertiesDefinitionContext definitionContext =
           parser.parse(context);
       definition =
           ConfigurationKeyContextManager.INSTANCE.context()
               .definitionKeyHelper(definitionContext);
 
       definitionCache.put(context, definition);
     }
 
     return definition;
   }
 
   Collection<MultiSourceProperties> getProperties()
   {
     final List<MultiSourceProperties> propertiesCollection =
         new LinkedList<MultiSourceProperties>();
     for (final Iterator<ConfigurationKey<?>> iterator =
         dictionaryCache.keySet().iterator(); iterator.hasNext();)
     {
       final ConfigurationKey<?> configKey = iterator.next();
       final MultiSourceProperties properties = dictionaryCache.get(configKey);
       propertiesCollection.add(properties);
     }
     return Collections.unmodifiableCollection(propertiesCollection);
   }
 
   // --- object basics --------------------------------------------------------
 
 }