/*
    * 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.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  import java.util.LinkedHashMap;
  import java.util.Map;
  import java.util.UUID;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.annotation.CheckForNull;
  import javax.annotation.concurrent.ThreadSafe;
  
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyCollection;
  import de.smartics.properties.api.config.domain.PropertyLocation;
  import de.smartics.properties.api.config.domain.PropertyManager;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.util.lang.Arg;
  
  /**
   * Helper implementation to deal with property management. This is a pure
   * {@link String} key and value implementation of a properties map.
   */
  @ThreadSafe
  public final class InMemoryPropertiesManager implements PropertyManager
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    // --- members --------------------------------------------------------------
  
    /**
     * The key of the configuration whose properties are managed.
     *
     * @serial
     */
    private final ConfigurationKey<?> configurationKey;
  
    /**
     * The unique identifier of the property source.
     *
     * @serial
     */
    private final PropertyLocation sourceId;
  
    /**
     * The map of properties key strings to their property instance.
     *
     * @serial
     */
    private final Map<String, Property> propertiesKeyToValueMap =
        new LinkedHashMap<String, Property>();
  
    /**
     * Helper to handle property change listeners.
     *
     * @serial
     */
    private final PropertyChangeSupport support;
  
    /**
     * The lock for synchronized access to property values.
     *
     * @serial
     */
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  
    /**
     * The read lock for synchronized access to property values.
     *
     * @serial
     */
    private final Lock readLock = lock.readLock();
  
    /**
     * The write lock for synchronized access to property values.
     *
    * @serial
    */
   private final Lock writeLock = lock.writeLock();
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    *
    * @param configurationKey the key of the configuration whose properties are
    *          managed.
    * @param sourceId the unique identifier of the property source.
    * @throws NullPointerException if {@code configurationKey} or
    *           {@code sourceId} is <code>null</code>.
    */
   public InMemoryPropertiesManager(final ConfigurationKey<?> configurationKey,
       final PropertyLocation sourceId) throws NullPointerException
   {
     Arg.checkNotNull("configurationKey", configurationKey);
     Arg.checkNotNull("sourceId", sourceId);
 
     this.configurationKey = configurationKey;
     this.sourceId = sourceId;
     support = new PropertyChangeSupport(this);
   }
 
   /**
    * Convenience constructor creating a UUID as source.
    * <p>
    * Usually the
    * {@link #InMemoryPropertiesManager(ConfigurationKey, PropertyLocation)
    * default constructor} should be used, since it provides proper information
    * on the physical resource of the properties that is of invaluable help if
    * someone tries to track down a configuration problem with a property.
    * </p>
    *
    * @param configurationKey the key of the configuration whose properties are
    *          managed.
    * @throws NullPointerException if {@code configurationKey} is
    *           <code>null</code>.
    */
   public InMemoryPropertiesManager(final ConfigurationKey<?> configurationKey)
     throws NullPointerException
   {
     this(configurationKey, new PropertyLocation("inmemory:"
                                                 + UUID.randomUUID().toString()));
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the key of the configuration whose properties are managed.
    *
    * @return the key of the configuration whose properties are managed.
    */
   @Override
   public ConfigurationKey<?> getConfigurationKey()
   {
     return configurationKey;
   }
 
   @Override
   public PropertyLocation getSourceId()
   {
     return sourceId;
   }
 
   @Override
   public boolean isLazy()
   {
     return false;
   }
 
   // --- business -------------------------------------------------------------
 
   @Override
   @CheckForNull
   public Property setProperty(final Property property)
     throws NullPointerException
   {
     Arg.checkNotNull("property", property); // NOPMD
 
     final String name = property.getName();
     final Property oldValue;
     writeLock.lock();
     try
     {
       oldValue = propertiesKeyToValueMap.put(name, property);
     }
     finally
     {
       writeLock.unlock();
     }
 
     support.firePropertyChange(name, oldValue, property);
 
     return oldValue;
   }
 
   @Override
   @CheckForNull
   public Property getProperty(final String name) throws NullPointerException,
     IllegalArgumentException
   {
     Arg.checkNotNull("name", name); // NOPMD
 
     final Property property;
     readLock.lock();
     try
     {
       property = propertiesKeyToValueMap.get(name);
       if (property == null && !propertiesKeyToValueMap.containsKey(name))
       {
         throw new IllegalArgumentException("Unknown property '" + name + "'.");
       }
     }
     finally
     {
       readLock.unlock();
     }
 
     return property;
   }
 
   @Override
   public boolean containsKey(final String name) throws NullPointerException
   {
     Arg.checkNotNull("name", name);
 
     readLock.lock();
     try
     {
       return propertiesKeyToValueMap.containsKey(name);
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   @Override
   @CheckForNull
   public Property removeProperty(final String name) throws NullPointerException
   {
     Arg.checkNotNull("name", name);
 
     final Property property;
     writeLock.lock();
     try
     {
       property = propertiesKeyToValueMap.remove(name);
     }
     finally
     {
       writeLock.unlock();
     }
 
     support.firePropertyChange(name, property, null);
 
     return property;
   }
 
   @Override
   public PropertyCollection getProperties()
   {
     readLock.lock();
 
     try
     {
       final PropertyCollection collection =
           new NativePropertyCollection(propertiesKeyToValueMap);
       return collection;
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   @Override
   public void addPropertyChangeListener(final String name,
       final PropertyChangeListener listener) throws NullPointerException
   {
     Arg.checkNotNull("name", name);
     Arg.checkNotNull("listener", listener); // NOPMD
 
     support.addPropertyChangeListener(name, listener);
   }
 
   @Override
   public void removePropertyChangeListener(final String name,
       final PropertyChangeListener listener) throws NullPointerException
   {
     Arg.checkNotNull("name", name);
     Arg.checkNotNull("listener", listener);
 
     support.removePropertyChangeListener(name, listener);
   }
 
   @Override
   public void addPropertyChangeListener(final PropertyChangeListener listener)
     throws NullPointerException
   {
     Arg.checkNotNull("listener", listener);
 
     support.addPropertyChangeListener(listener);
   }
 
   @Override
   public void removePropertyChangeListener(final PropertyChangeListener listener)
     throws NullPointerException
   {
     Arg.checkNotNull("listener", listener);
 
     support.removePropertyChangeListener(listener);
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Returns the string representation of the object.
    *
    * @return the string representation of the object.
    */
   @Override
   public String toString()
   {
     final StringBuilder buffer = new StringBuilder();
 
     for (final Property property : propertiesKeyToValueMap.values())
     {
       buffer.append(property).append('\n');
     }
 
     return buffer.toString();
   }
 
 }