/*
    * 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.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.UUID;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  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.DuplicateConfigurationException;
  import de.smartics.properties.api.config.domain.MissingConfigurationException;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.domain.key.KeyListBuilder;
  import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;
  import de.smartics.properties.spi.config.cache.Cache;
  import de.smartics.properties.spi.config.cache.CacheManagerFactory;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Stores all configurations in memory.
   */
  @ThreadSafe
  public final class InMemoryConfigurationRepositoryManagement implements
      ConfigurationRepositoryManagement
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The unique identifier of the instance.
     *
     * @serial
     */
    private final String id = createId();
  
    /**
     * The registry to resolve property descriptors.
     *
     * @serial
     */
    private final PropertyDescriptorRegistry registry;
  
    /**
     * The factory to create instance of {@link ConfigurationPropertiesManagement}
     * on demand.
     *
     * @serial
     */
    private final ConfigurationPropertiesManagementFactory factory;
  
    /**
     * The permanent store to store configuration keys without active dynamic key
     * parts.
     */
    private final Map<ConfigurationKey<?>, ConfigurationPropertiesManagement> permanentStore =
        Collections
            .synchronizedMap(new HashMap<ConfigurationKey<?>, ConfigurationPropertiesManagement>());
  
    /**
     * The lock for synchronized access to the cache.
     *
     * @serial
     */
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  
    /**
     * The read lock for synchronized access to the cache.
     *
    * @serial
    */
   private final Lock readLock = lock.readLock();
 
   /**
    * The write lock for synchronized access to the cache.
    *
    * @serial
    */
   private final Lock writeLock = lock.writeLock();
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    *
    * @param registry the registry to resolve property descriptors.
    * @param factory the factory to create instance of
    *          {@link ConfigurationPropertiesManagement} on demand.
    */
   public InMemoryConfigurationRepositoryManagement(
       final PropertyDescriptorRegistry registry,
       final ConfigurationPropertiesManagementFactory factory)
   {
     this.registry = registry;
     this.factory = factory;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static String createId()
   {
     final UUID uuid = UUID.randomUUID();
     final String id = "Management:ConfigurationPropertiesManagement/" + uuid;
     return id;
   }
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the registry to resolve property descriptors.
    *
    * @return the registry to resolve property descriptors.
    */
   @Override
   public PropertyDescriptorRegistry getRegistry()
   {
     return registry;
   }
 
   // --- business -------------------------------------------------------------
 
   @Override
   public ConfigurationProperties getProperties(final ConfigurationKey<?> key)
     throws NullArgumentException, MissingConfigurationException
   {
     return getPropertiesManagementWithDefaults(key);
   }
 
   @Override
   public ConfigurationPropertiesManagement getPropertiesManagementWithDefaults(
       final ConfigurationKey<?> key) throws NullArgumentException,
     MissingConfigurationException
   {
     writeLock.lock();
 
     try
     {
       return constructConfigurationWithDefaults(key);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @Override
   public ConfigurationPropertiesManagement getPropertiesManagement(
       final ConfigurationKey<?> key) throws NullArgumentException,
     MissingConfigurationException
   {
     readLock.lock();
 
     try
     {
       final ConfigurationPropertiesManagement config = getCachedOrCreate(key);
       if (config == null)
       {
         throw new MissingConfigurationException(key);
       }
       return config;
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   @Override
   public boolean hasPropertiesManagement(final ConfigurationKey<?> key)
     throws NullArgumentException
   {
     readLock.lock();
     try
     {
       final ConfigurationPropertiesManagement config = getCachedOrCreate(key);
       return config != null;
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   /**
    * Expected to be called with write lock acquired.
    */
   private ConfigurationPropertiesManagement constructConfigurationWithDefaults(
       final ConfigurationKey<?> key)
   {
     final KeyListBuilder builder =
         ConfigurationKeyContextManager.INSTANCE.context().keyListBuilder();
 
     final List<ConfigurationKey<?>> keySet = builder.createKeyList(key);
     final List<ConfigurationPropertiesManagement> defaults =
         new ArrayList<ConfigurationPropertiesManagement>(keySet.size());
     for (final ConfigurationKey<?> current : keySet)
     {
       final ConfigurationPropertiesManagement config =
           getCachedOrCreate(current);
       if (config != null)
       {
         defaults.add(config);
       }
     }
 
     if (defaults.isEmpty())
     {
       return null;
     }
     if (defaults.size() == 1)
     {
       return defaults.get(0);
     }
     return new ConfigurationPropertiesManagementWithDefaults(defaults);
   }
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   private ConfigurationPropertiesManagement getCachedOrCreate(
       final ConfigurationKey<?> key)
   {
     final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache =
         (Cache) CacheManagerFactory.getConfigurationsCache(id);
     ConfigurationPropertiesManagement config = getCached(key, cache);
     if (config == null)
     {
       config = factory.create(key);
       putInCache(key, config);
     }
     return config;
   }
 
   private ConfigurationPropertiesManagement getCached(
       final ConfigurationKey<?> key,
       final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache)
   {
     ConfigurationPropertiesManagement config;
     if (!permOnly() && key.hasActiveDynamicParts())
     {
       config = cache.get(key);
     }
     else
     {
       config = permanentStore.get(key);
     }
     return config;
   }
 
   // CHECKSTYLE: OFF
   // FIXME: Use this as boot properties.
   /**
    * FIXME: Use this as boot properties.
    */
   public static final String PERM_ONLY = "store.permonly";
 
   private static boolean permOnly()
   {
     // FIXME: Use this as boot properties.
     final boolean permOnly = "true".equals(System.getProperty(PERM_ONLY));
     return permOnly;
   }
 
   // CHECKSTYLE: ON
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   private void putInCache(final ConfigurationKey<?> key,
       final ConfigurationPropertiesManagement config)
   {
     if (!permOnly() && key.hasActiveDynamicParts())
     {
       final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache =
           (Cache) CacheManagerFactory.getConfigurationsCache(id);
       cache.put(key, config);
     }
     else
     {
       permanentStore.put(key, config);
     }
   }
 
   @Override
   public void registerProperties(final ConfigurationKey<?> key,
       final ConfigurationPropertiesManagement configurationProperties)
     throws NullArgumentException, DuplicateConfigurationException
   {
     writeLock.lock();
     try
     {
       final ConfigurationPropertiesManagement current = getCachedOrCreate(key);
       if (current != null)
       {
         throw new DuplicateConfigurationException(key, current,
             configurationProperties);
       }
       putInCache(key, configurationProperties);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @SuppressWarnings("unchecked")
   @Override
   public ConfigurationPropertiesManagement deregisterProperties(
       final ConfigurationKey<?> key) throws NullArgumentException
   {
     writeLock.lock();
     try
     {
       if (!permOnly() && key.hasActiveDynamicParts())
       {
         final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache =
             (Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement>) CacheManagerFactory
                 .getConfigurationsCache(id);
         return cache.remove(key);
       }
       else
       {
         return permanentStore.remove(key);
       }
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   @Override
   public Collection<ConfigurationKey<?>> getKeys()
   {
     readLock.lock();
     try
     {
       final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache =
           (Cache) CacheManagerFactory.getConfigurationsCache(id);
       final Set<ConfigurationKey<?>> keys =
           new HashSet<ConfigurationKey<?>>(cache.keySet());
       keys.addAll(permanentStore.keySet());
       return keys;
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   @Override
   public void release()
   {
     CacheManagerFactory.discard(id);
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * 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();
   }
 
   /**
    * Returns the string representation of the object.
    *
    * @return the string representation of the object.
    */
   @SuppressWarnings({ "unchecked", "rawtypes" })
   @Override
   public String toString()
   {
     readLock.lock();
     final StringBuilder buffer = new StringBuilder();
     final Cache<ConfigurationKey<?>, ConfigurationPropertiesManagement> cache =
         (Cache) CacheManagerFactory.getConfigurationsCache(id);
     buffer.append("The cache contains ")
         .append(cache.size() + permanentStore.size()).append(" entries.");
     try
     {
       for (final ConfigurationKey<?> key : permanentStore.keySet())
       {
         buffer.append("\n  ").append(key);
       }
       for (final ConfigurationKey<?> key : cache.keySet())
       {
         buffer.append("\n  ").append(key);
       }
     }
     finally
     {
       readLock.unlock();
     }
 
     return buffer.toString();
   }
 }