/*
    * 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.IOException;
  import java.io.ObjectInputStream;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import de.smartics.properties.api.config.app.FactoryConfiguration;
  import de.smartics.properties.api.config.domain.CompoundConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationCode;
  import de.smartics.properties.api.config.domain.ConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationProperties;
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.ConfigurationRepositoryManagement;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;
  import de.smartics.properties.resource.domain.ArtifactId;
  import de.smartics.properties.resource.domain.ArtifactRef;
  import de.smartics.properties.resource.domain.ClassPathEnvironment;
  import de.smartics.properties.resource.repository.RepositoryException;
  import de.smartics.properties.resource.repository.ResourceRepository;
  import de.smartics.properties.resource.repository.ResourceRepositoryFactory;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
  import de.smartics.properties.spi.core.registry.InMemoryPropertyDescriptorRegistry;
  import de.smartics.util.lang.Arg;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Base implementation of the {@link ConfigurationPropertiesManagementFactory}.
   *
   * @param <T> the concrete type of the returned configuration properties.
   */
  @ThreadSafe
  public abstract class AbstractConfigurationPropertiesFactory<T extends ConfigurationPropertiesManagement>
      implements ConfigurationPropertiesManagementFactory
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    // --- members --------------------------------------------------------------
  
    /**
     * The locations to search for property descriptors and definitions.
     *
     * @serial
     */
    private final List<URL> rootLocations = new ArrayList<URL>();
  
    /**
     * The properties provided by other means than being found on the class path.
     * <p>
     * While
     * {@link AbstractConfigurationPropertiesFactory#addRootLocations(Collection)}
     * and {@link AbstractConfigurationPropertiesFactory#addRootLocations(URL...)}
     * allows to declare class path roots to search for properties files
     * automatically, the root property provider allow access to properties that
     * are stored in arbitrary locations and formats. These properties may be
     * stored in databases or any other technology, as long as they provide the
     * concept of key and value.
     * </p>
     *
     * @serial
     */
    private final List<PropertyProvider> rootPropertyProviders =
        new ArrayList<PropertyProvider>();
  
    /**
     * The factory configuration.
    *
    * @serial
    */
   private final FactoryConfiguration factoryConfiguration =
       new FactoryConfiguration();
 
   /**
    * The list of artifact that reference all resources to access to read
    * property declarations and definitions.
    *
    * @serial
    */
   private final Map<ArtifactId, ClassPathEnvironment> artifactIds =
       new LinkedHashMap<ArtifactId, ClassPathEnvironment>();
 
   /**
    * The cache of currently loaded configurations.
    *
    * @impl the implementation of the cache is required to be thread-safe.
    */
   private transient ConfigurationRepositoryManagement cache;
 
   /**
    * The registry of declarations used by all created configurations.
    *
    * @serial
    */
   private final PropertyDescriptorRegistry registry =
       new InMemoryPropertyDescriptorRegistry();
 
   /**
    * The lock for synchronized access.
    *
    * @serial
    */
   private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
   /**
    * The read lock for synchronized access.
    *
    * @serial
    */
   private final Lock readLock = lock.readLock();
 
   /**
    * The write lock for synchronized access.
    *
    * @serial
    */
   private final Lock writeLock = lock.writeLock();
 
   /**
    * Flag to check if initialization has already taken place.
    *
    * @serial
    */
   private volatile boolean initialized;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    */
   protected AbstractConfigurationPropertiesFactory()
   {
     this.cache =
         new InMemoryConfigurationRepositoryManagement(registry, createFactory()); // NOPMD
   }
 
   // CHECKSTYLE:OFF
   private ConfigurationPropertiesManagementFactory createFactory()
   {
     return new ConfigurationPropertiesManagementFactory()
     {
       private static final long serialVersionUID = 1L;
 
       @Override
       public final ConfigurationPropertiesManagement create(
           final ConfigurationKey<?> key)
       {
         return AbstractConfigurationPropertiesFactory.this
             .createNewConfiguration(key);
       }
 
       @Override
       public ConfigurationPropertiesManagement remove(
           final ConfigurationKey<?> key) throws NullPointerException
       {
         return AbstractConfigurationPropertiesFactory.this.remove(key);
       }
 
       @Override
       public FactoryConfiguration getFactoryConfiguration()
       {
         return AbstractConfigurationPropertiesFactory.this
             .getFactoryConfiguration();
       }
 
       @Override
       public void addRootLocations(final Collection<URL> urls)
       {
         AbstractConfigurationPropertiesFactory.this.addRootLocations(urls);
       }
 
       @Override
       public void addRootLocations(final URL... urls)
       {
         AbstractConfigurationPropertiesFactory.this.addRootLocations(urls);
       }
 
       @Override
       public void addPropertyProviders(
           final Collection<PropertyProvider> providers)
       {
         AbstractConfigurationPropertiesFactory.this
             .addPropertyProviders(providers);
       }
 
       @Override
       public void addPropertyProviders(final PropertyProvider... providers)
       {
         AbstractConfigurationPropertiesFactory.this
             .addPropertyProviders(providers);
       }
 
       @Override
       public ConfigurationPropertiesManagement createManagement(
           final ConfigurationKey<?> key) throws NullPointerException,
         ConfigurationException
       {
         return AbstractConfigurationPropertiesFactory.this
             .createManagement(key);
       }
 
       @Override
       public ConfigurationProperties createDefault()
         throws ConfigurationException
       {
         return AbstractConfigurationPropertiesFactory.this.createDefault();
       }
 
       @Override
       public ConfigurationPropertiesManagement createDefaultManagement()
         throws ConfigurationException
       {
         return AbstractConfigurationPropertiesFactory.this
             .createDefaultManagement();
       }
 
       @Override
       public Collection<ConfigurationKey<?>> getRegisteredConfigurationKeys()
       {
         return AbstractConfigurationPropertiesFactory.this
             .getRegisteredConfigurationKeys();
       }
 
       @Override
       public PropertyDescriptorRegistry getRegistry()
       {
         return AbstractConfigurationPropertiesFactory.this.getRegistry();
       }
 
       @Override
       public Collection<ConfigurationKey<?>> materialize()
       {
         return AbstractConfigurationPropertiesFactory.this.materialize();
       }
 
       @Override
       public void release()
       {
         AbstractConfigurationPropertiesFactory.this.release();
       }
 
       @Override
       public String addRootUrls(final ArtifactId artifactId)
         throws NullArgumentException, RepositoryException,
         CompoundConfigurationException
       {
         return AbstractConfigurationPropertiesFactory.this
             .addRootUrls(artifactId);
       }
 
       @Override
       public ArtifactRef getArtifactRef(final String artifactId)
         throws NullPointerException
       {
         return AbstractConfigurationPropertiesFactory.this
             .getArtifactRef(artifactId);
       }
     };
   }
 
   // CHECKSTYLE:ON
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   @Override
   public final PropertyDescriptorRegistry getRegistry()
   {
     return registry;
   }
 
   @Override
   public final FactoryConfiguration getFactoryConfiguration()
   {
     return factoryConfiguration;
   }
 
   @Override
   public final void addRootLocations(final Collection<URL> urls)
   {
     if (urls != null && !urls.isEmpty())
     {
       writeLock.lock();
       try
       {
         rootLocations.addAll(urls);
       }
       finally
       {
         writeLock.unlock();
       }
     }
   }
 
   @Override
   public final void addRootLocations(final URL... urls)
   {
     if (urls != null && urls.length != 0)
     {
       writeLock.lock();
       try
       {
         rootLocations.addAll(Arrays.asList(urls));
       }
       finally
       {
         writeLock.unlock();
       }
     }
   }
 
   @Override
   public final void addPropertyProviders(
       final Collection<PropertyProvider> providers)
   {
     if (providers != null && !providers.isEmpty())
     {
       writeLock.lock();
       try
       {
         rootPropertyProviders.addAll(providers);
       }
       finally
       {
         writeLock.unlock();
       }
     }
   }
 
   @Override
   public final void addPropertyProviders(final PropertyProvider... providers)
   {
     if (providers != null && providers.length != 0)
     {
       writeLock.lock();
       try
       {
         rootPropertyProviders.addAll(Arrays.asList(providers));
       }
       finally
       {
         writeLock.unlock();
       }
     }
   }
 
   // --- business -------------------------------------------------------------
 
   @Override
   public final String addRootUrls(final ArtifactId artifactId)
     throws NullArgumentException, RepositoryException,
     CompoundConfigurationException
   {
     Arg.checkNotNull("artifactId", artifactId);
 
     final ResourceRepositoryFactory factory = new ResourceRepositoryFactory();
     final ResourceRepository repository = factory.create();
     final ClassPathEnvironment resources = repository.resolve(artifactId);
 
     synchronized (artifactIds)
     {
       artifactIds.put(artifactId, resources);
     }
 
     final List<URL> urls = resources.getUrls();
     addRootLocations(urls);
 
     return repository.getRemoteRepositoryUrl();
   }
 
   @Override
   public final ArtifactRef getArtifactRef(final String artifactId)
     throws NullPointerException
   {
     Arg.checkNotNull("artifactId", artifactId);
 
     for (final ClassPathEnvironment env : artifactIds.values())
     {
       final ArtifactRef ref = env.getArtifactRef(artifactId);
       if (ref != null)
       {
         return ref;
       }
     }
 
     return null;
   }
 
   @Override
   public final Collection<ConfigurationKey<?>> getRegisteredConfigurationKeys()
   {
     return cache.getKeys();
   }
 
   @Override
   public final T create(final ConfigurationKey<?> key)
     throws NullPointerException, ConfigurationException
   {
     return createManagement(key);
   }
 
   @Override
   public final T createDefault()
   {
     final ConfigurationKey<?> key =
         ConfigurationKeyContextManager.INSTANCE.context()
             .configurationKeyFactory().createDefaultKey();
     return create(key);
   }
 
   @Override
   public final ConfigurationPropertiesManagement createDefaultManagement()
   {
     final ConfigurationKey<?> key =
         ConfigurationKeyContextManager.INSTANCE.context()
             .configurationKeyFactory().createDefaultKey();
     return createManagement(key);
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public final T createManagement(final ConfigurationKey<?> key)
     throws NullPointerException, ConfigurationException
   {
     writeLock.lock();
     try
     {
       // FIXME: If our cache contains different implementations, this cast won't
       // work.
       return (T) getCachedOrCreate(key);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   private ConfigurationPropertiesManagement getCachedOrCreate(
       final ConfigurationKey<?> key)
   {
     ConfigurationPropertiesManagement configuration = null;
 
     if (!cache.hasPropertiesManagement(key))
     {
       configuration = createNewConfiguration(key);
     }
 
     initializeConfiguration();
 
     final ConfigurationPropertiesManagement withDefaults =
         cache.getPropertiesManagementWithDefaults(key);
 
     if (withDefaults != null)
     {
       configuration = withDefaults;
     }
     else if (configuration != null)
     {
       // Getting ...WithDefaults may return null in case no configuration
       // properties have been found. So we return an empty configuration instead
       // of 'null'.
       cache.registerProperties(key, configuration);
     }
     else
     {
       throw new ConfigurationException(
           ConfigurationCode.CONFIGURATION_ACCESS_FAILED, key);
     }
 
     return configuration;
   }
 
   private void initializeConfiguration()
   {
     if (!initialized)
     {
       final FactoryCache<T> factoryCache = new FactoryCache<T>(cache, this);
 
       final ClassPathLoader<T> loader =
           new ClassPathLoader<T>(factoryCache, false,
               factoryConfiguration.isSkipClassPathPropertyLoading(),
               factoryConfiguration.getDecrypter());
 
       readLock.lock();
       try
       {
         loader.addRootUrls(rootLocations);
         loader.addRootProperties(rootPropertyProviders);
       }
       finally
       {
         readLock.unlock();
       }
 
       if (factoryConfiguration.isAddDefaultRootLocations())
       {
         loader.addDefaultRootUrls();
       }
       loader.load();
 
       initialized = true;
     }
   }
 
   @Override
   public Collection<ConfigurationKey<?>> materialize()
   {
     writeLock.lock();
     try
     {
       initializeConfiguration();
     }
     finally
     {
       writeLock.unlock();
     }
 
     final Collection<ConfigurationKey<?>> keys =
         getRegisteredConfigurationKeys();
     return keys;
   }
 
   /**
    * Creates an empty instance of the configuration properties instance. Where
    * the public create methods may consult a cache, this method is required to
    * create a new instance.
    *
    * @param key the key to the instance.
    * @return the instance. Never <code>null</code>.
    * @throws NullPointerException if {@code key} is <code>null</code>.
    * @throws ConfigurationException if the configuration cannot be created.
    */
   protected abstract T createNewConfiguration(ConfigurationKey<?> key)
     throws NullPointerException, ConfigurationException;
 
   // --- object basics --------------------------------------------------------
 
   @Override
   public void release()
   {
     cache.release();
   }
 
   @Override
   public final ConfigurationPropertiesManagement remove(
       final ConfigurationKey<?> key) throws NullPointerException
   {
     return cache.deregisterProperties(key);
   }
 
   /**
    * Reads the object from the given stream.
    *
    * @param in the stream to read from.
    * @throws IOException on read problems.
    * @throws ClassNotFoundException if a class cannot be found.
    */
   private void readObject(final ObjectInputStream in) throws IOException,
     ClassNotFoundException
   {
     in.defaultReadObject();
 
     cache =
         new InMemoryConfigurationRepositoryManagement(registry, createFactory());
   }
 
   @Override
   public String toString()
   {
     final StringBuilder buffer = new StringBuilder(8192);
     final Collection<ConfigurationKey<?>> keys = cache.getKeys();
     buffer.append("The factory caches access to the following " + keys.size()
                   + " configurations:");
     for (final ConfigurationKey<?> key : keys)
     {
       buffer.append("\n  ").append(key);
     }
     buffer.append("\nDetails:");
     for (final ConfigurationKey<?> key : keys)
     {
       final ConfigurationProperties config = cache.getProperties(key);
       buffer.append("\n--> ").append(config);
     }
 
     synchronized (artifactIds)
     {
       for (final ArtifactId artifactId : artifactIds.keySet())
       {
         buffer.append(artifactId).append(' ');
       }
     }
 
     return buffer.toString();
   }
 }