/*
    * 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.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import javax.annotation.CheckForNull;
  import javax.annotation.concurrent.ThreadSafe;
  
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.ConfigurationRepositoryManagement;
  import de.smartics.properties.api.config.domain.MissingConfigurationException;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.ConfigException;
  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.util.lang.Arg;
  
  /**
   * Creates and caches configurations.
   * <p>
   * Required by the {@link ClassPathLoader} to store all encountered
   * configuration properties.
   * </p>
   *
   * @param <T> the type of {@link ConfigurationPropertiesManagement} created and
   *          stored by this factory cache.
   */
  @ThreadSafe
  public final class FactoryCache<T extends ConfigurationPropertiesManagement>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The cache of currently loaded configurations.
     *
     * @impl the implementation of the cache is required to be thread-safe.
     */
    private final ConfigurationRepositoryManagement cache;
  
    /**
     * The factory to create instances of
     * {@link ConfigurationPropertiesManagement}.
     */
    private final AbstractConfigurationPropertiesFactory<?> factory;
  
    /**
     * The shared registry of property descriptors.
     */
    private final PropertyDescriptorRegistry registry;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param cache the cache of currently loaded configurations.
     * @param factory the factory to create instances of
     *          {@link ConfigurationPropertiesManagement}.
     */
    public FactoryCache(final ConfigurationRepositoryManagement cache,
        final AbstractConfigurationPropertiesFactory<?> factory)
    {
      this.cache = cache;
      this.factory = factory;
      this.registry = factory.getRegistry();
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    /**
    * Returns the cache of currently loaded configurations.
    *
    * @return the cache of currently loaded configurations.
    */
   public ConfigurationRepositoryManagement getCache()
   {
     return cache;
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * Returns the context for the given type.
    *
    * @param declaringType the type of a property descriptor.
    * @return the context for the declared properties. May return
    *         <code>null</code> if the {@code declaringType} is unknown.
    * @throws ConfigException if the context for the descriptor cannot be found.
    * @throws NullPointerException if {@code declaringType} is <code>null</code>.
    */
   @CheckForNull
   public PropertiesContext getContext(final Class<?> declaringType)
     throws NullPointerException, ConfigException
   {
     return registry.getContext(declaringType);
   }
 
   /**
    * Registers the list of descriptors to the given declaring types.
    *
    * @param descriptorMap a map of declaring types to their associated
    *          descriptors.
    * @throws NullPointerException if {@code descriptorMap} or if any key of
    *           value of that map is <code>null</code>.
    */
   public void registerDescriptors(
       final Map<Class<?>, List<PropertyDescriptor>> descriptorMap)
     throws NullPointerException
   {
     Arg.checkNotNull("descriptorMap", descriptorMap);
 
     for (final Entry<Class<?>, List<PropertyDescriptor>> entry : descriptorMap
         .entrySet())
     {
       final Class<?> declaringType = entry.getKey();
       final List<PropertyDescriptor> descriptors = entry.getValue();
       registry.addDescriptors(declaringType, descriptors);
     }
   }
 
   /**
    * Creates an instance of {@link ConfigurationPropertiesManagement}.
    *
    * @param key the key to the configuration to be created.
    * @return the created configuration.
    */
   public ConfigurationPropertiesManagement ensureManagement(
       final ConfigurationKey<?> key)
   {
     try
     {
       return cache.getPropertiesManagement(key);
     }
     catch (final MissingConfigurationException e)
     {
       return createPropertiesManagement(key);
     }
   }
 
   /**
    * Creates an instance of {@link ConfigurationPropertiesManagement}.
    *
    * @param key the key to the configuration to be created.
    * @return the created configuration.
    */
   public ConfigurationPropertiesManagement createPropertiesManagement(
       final ConfigurationKey<?> key)
   {
     final ConfigurationPropertiesManagement configuration =
         factory.createNewConfiguration(key);
     cache.registerProperties(key, configuration);
     return configuration;
   }
 
   // --- 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();
 
     buffer.append("== Descriptor Registry:\n").append(registry);
     buffer.append("\n== Configuration Cache:\n").append(cache);
     buffer.append("\n== Factory Type       : ").append(
         factory.getClass().getName());
 
     return buffer.toString();
   }
 }