/*

  * 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

             .getInstance().createManager().getPropertiesCache(cacheName);

     LOG.debug("Caches: {}", CacheManagerFactory.getInstance().createManager()

         .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 --------------------------------------------------------

 }