/*
    * 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.impl.config.cache;
  
  import java.io.Serializable;
  import java.util.Properties;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import org.apache.commons.lang.ObjectUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.HashMultimap;
  import com.google.common.collect.Multimap;
  
  import de.smartics.properties.api.config.domain.ConfigurationProperties;
  import de.smartics.properties.api.config.domain.DescribedProperty;
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyCollection;
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.config.domain.ValidatedProperty;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  import de.smartics.properties.spi.config.cache.CacheManagerFactory;
  import de.smartics.properties.spi.config.cache.UnawareCache;
  import de.smartics.util.lang.Arg;
  
  /**
   * A cache implementation that tracks dependencies via placeholder contained in
   * property values and property default expressions. If a property is
   * invalidated, all properties that refer to this property (even transitively)
   * will also be invalidated. Invalidation implies, that the property is revoked
   * from the cache.
   */
  @ThreadSafe
  final class DependencyTrackingCache implements Serializable
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory
        .getLogger(DependencyTrackingCache.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The key to the configuration the cache is associated with.
     *
     * @serial
     */
    private final ConfigurationKey<?> configurationKey;
  
    /**
     * The synchronized cache. The property stored may be a property or a resolved
     * property.
     *
     * @serial
     */
    private final UnawareCache<String, DescribedProperty> cache;
  
    /**
     * The dependencies of key to cascade the revoking of elements from the cache.
     * The key is a property name the values depend upon. If the property with the
     * given name is revoked from the cache, all the dependent properties of its
     * list must also be revoked.
     *
     * @serial
     */
    private final Multimap<String, String> dependencies;
  
    /**
     * 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();
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    *
    * @param configurationKey the key to the configuration the cache is
    *          associated with.
    * @throws NullPointerException if {@code configurationKey} is
    *           <code>null</code>.
    */
   @SuppressWarnings("unchecked")
   public DependencyTrackingCache(final ConfigurationKey<?> configurationKey)
     throws NullPointerException
   {
     this.configurationKey =
         Arg.checkNotNull("configurationKey", configurationKey);
 
     final String cacheName = configurationKey.toString();
     this.cache =
         (UnawareCache<String, DescribedProperty>) CacheManagerFactory
             .getPropertiesCache(cacheName);
     LOG.debug("Caches: {}", CacheManagerFactory.getCacheNames());
     this.dependencies = HashMultimap.create();
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the key to the configuration the cache is associated with.
    *
    * @return the key to the configuration the cache is associated with.
    */
   public ConfigurationKey<?> getConfigurationKey()
   {
     return configurationKey;
   }
 
   // --- business -------------------------------------------------------------
 
   // CHECKSTYLE:OFF
   public ValidatedProperty getValidatedProperty(
       // CHECKSTYLE:ON
       final ConfigurationProperties propertySource,
       final PropertyDescriptor descriptor, final Object defaultValue)
     throws IllegalArgumentException, UnknownPropertyException,
     PropertyValidationException
   {
     readLock.lock();
     boolean doReadUnlock = true;
     final String key = descriptor.getKey().toString();
     try
     {
       final Property property = cache.get(key);
       if (property instanceof ValidatedProperty)
       {
         LOG.debug("Cache hit: {}", key);
         return (ValidatedProperty) property;
       }
       else
       {
         readLock.unlock();
         doReadUnlock = false;
 
         final ValidatedProperty validatedProperty =
             propertySource.getValidatedProperty(key, defaultValue);
 
         if (validatedProperty != null)
         {
           writeLock.lock();
           try
           {
             putToCache(descriptor, key, validatedProperty);
             attachDependencies(validatedProperty);
           }
           finally
           {
             writeLock.unlock();
           }
         }
 
         LOG.debug("Cache miss: {}", key);
         return validatedProperty;
       }
     }
     finally
     {
       if (doReadUnlock)
       {
         readLock.unlock();
       }
     }
   }
 
   private void putToCache(final PropertyDescriptor descriptor,
       final String key, final ValidatedProperty validatedProperty)
   {
     final long updateIntervalInMs = descriptor.getUpdateIntervalInMs();
     cache
         .put(key, validatedProperty, updateIntervalInMs, TimeUnit.MILLISECONDS);
   }
 
   private void putToCache(final PropertyDescriptor descriptor,
       final String key, final DescribedProperty property)
   {
     final long updateIntervalInMs = descriptor.getUpdateIntervalInMs();
     cache.put(key, property, updateIntervalInMs, TimeUnit.MILLISECONDS);
   }
 
   // CHECKSTYLE:OFF
   public DescribedProperty getProperty(final ConfigurationProperties propertySource,
       final PropertyDescriptor descriptor, final Object defaultValue)
   // CHECKSTYLE:ON
   {
     readLock.lock();
     boolean doReadUnlock = true;
 
     final String key = descriptor.getKey().toString();
     try
     {
       DescribedProperty property = cache.get(key);
       if (property != null)
       {
         LOG.debug("Cache hit: {}", key);
         return property;
       }
       else
       {
         readLock.unlock();
         doReadUnlock = false;
 
         property = propertySource.getProperty(key, defaultValue);
 
         if (property != null)
         {
           writeLock.lock();
           try
           {
             putToCache(descriptor, key, property);
             if (property instanceof ValidatedProperty)
             {
               attachDependencies((ValidatedProperty) property);
             }
           }
           finally
           {
             writeLock.unlock();
           }
         }
 
         LOG.debug("Cache miss: {}", key);
         return property;
       }
     }
     finally
     {
       if (doReadUnlock)
       {
         readLock.unlock();
       }
     }
   }
 
   public Property removeFromCache(final String key)
   {
     writeLock.lock();
     try
     {
       final Property oldProperty = cache.remove(key);
       removeDependencies(key);
       LOG.debug("Cache revoke: {}", key);
       return oldProperty;
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   public void removeFromCache(final Properties properties)
   {
     writeLock.lock();
     try
     {
       for (final Object key : properties.keySet())
       {
         cache.remove((String) key);
         removeDependencies(ObjectUtils.toString(key, null));
         LOG.debug("Cache revoke due to init: {}", key);
       }
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   public void removeFromCache(final PropertyCollection collection)
   {
     writeLock.lock();
     try
     {
       for (final Property property : collection)
       {
         final String key = property.getName();
         cache.remove(key);
         removeDependencies(ObjectUtils.toString(key, null));
         LOG.debug("Cache revoke due to init: {}", key);
       }
     }
     finally
     {
       collection.close();
       writeLock.unlock();
     }
   }
 
   /**
    * It is assumed that the caller already holds the write lock.
    */
   private void attachDependencies(final ValidatedProperty property)
   {
     final String key = property.getName();
 
     for (final String dependency : property.getDependencies())
     {
       dependencies.put(dependency, key);
     }
   }
 
   /**
    * It is assumed that the caller already holds the write lock.
    */
   private void removeDependencies(final String key)
   {
     for (final String dependant : dependencies.removeAll(key))
     {
       LOG.debug("Cache revoke due to dependency on {}: {}", key, dependant);
       removeFromCache(dependant);
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }