/*
    * 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.Map;
  import java.util.Properties;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import org.apache.commons.collections.map.AbstractReferenceMap;
  import org.apache.commons.collections.map.ReferenceMap;
  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.Property;
  import de.smartics.properties.api.config.domain.ResolvedProperty;
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  
  /**
   * 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 synchronized cache. The property stored may be a property or a resolved
     * property.
     *
     * @serial
     */
    private final Map<String, Property> 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.
    */
   @SuppressWarnings("unchecked")
   public DependencyTrackingCache()
   {
     this.cache =
         new ReferenceMap(AbstractReferenceMap.SOFT, AbstractReferenceMap.HARD,
             true);
     this.dependencies = HashMultimap.create();
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   public int getCacheSize()
   {
     final int cacheSize;
     readLock.lock();
     try
     {
       cacheSize = cache.size();
     }
     finally
     {
       readLock.unlock();
     }
 
     return cacheSize;
   }
 
   // --- business -------------------------------------------------------------
 
   public ResolvedProperty getResolvedProperty(
       final ConfigurationProperties propertySource, final String key,
       final Object defaultValue) throws IllegalArgumentException,
     UnknownPropertyException, PropertyValidationException
   {
     readLock.lock();
 
     try
     {
       final Property property = cache.get(key);
       if (property instanceof ResolvedProperty)
       {
         LOG.debug("Cache hit: {}", key);
         return (ResolvedProperty) property;
       }
       else
       {
         readLock.unlock();
 
         final ResolvedProperty resolvedProperty =
             propertySource.getResolvedProperty(key, defaultValue);
 
         writeLock.lock();
         try
         {
           cache.put(key, resolvedProperty);
           attachDependencies(resolvedProperty);
         }
         finally
         {
           writeLock.unlock();
           readLock.lock();
         }
 
         LOG.debug("Cache miss: {}", key);
         return resolvedProperty;
       }
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   public Property getProperty(final ConfigurationProperties propertySource,
       final String key, final Object defaultValue)
   {
     readLock.lock();
 
     try
     {
       Property property = cache.get(key);
       if (property != null)
       {
         LOG.debug("Cache hit: {}", key);
         return property;
       }
       else
       {
         readLock.unlock();
 
         property = propertySource.getProperty(key, defaultValue);
 
         writeLock.lock();
         try
         {
           cache.put(key, property);
           if (property instanceof ResolvedProperty)
           {
             attachDependencies((ResolvedProperty) property);
           }
         }
         finally
         {
           writeLock.unlock();
           readLock.lock();
         }
 
         LOG.debug("Cache miss: {}", key);
         return property;
       }
     }
     finally
     {
       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(key);
         removeDependencies(ObjectUtils.toString(key, null));
         LOG.debug("Cache revoke due to init: {}", key);
       }
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   /**
    * It is assumed that the caller already holds the write lock.
    */
   private void attachDependencies(final ResolvedProperty 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 --------------------------------------------------------
 
 }