/**
    * This file Copyright (c) 2014-2015 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.config.registry;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.lang3.StringUtils;
  
  /**
   * Thread safe map intended to be used for registries. Provides an atomic operation <code>removeAndPutAll</code> that is
   * used to remove a set of previously added values before adding a collection of new ones. Read operations are blocked
   * until it completes guaranteeing proper visibility.
   * <p/>
   * It is common for entities in registries to also hold their identifier. The method <code>keyFormValue</code> can be
   * overridden to get the identifier from the value. This removes the need to package a set of entities that should be
   * added in a Map before calling {@link #removeAndPutAll(java.util.Collection, java.util.Collection)}.
   *
   * This is a port and simplified version of {@link info.magnolia.registry.RegistryMap}, which was written prior to the
   * introduction of the {@link Registry} interface. It should not be used directly.
   *
   * @param <T> the type of the contained objects
   */
  public class RegistryMap<T> {
  
      private final Map<DefinitionMetadata, DefinitionProvider<T>> map = new HashMap<>();
  
      private final Map<String, DefinitionMetadata> stringKeysMap = new HashMap<>();
  
      public synchronized DefinitionProvider<T> get(DefinitionMetadata key) {
          return map.get(key);
      }
  
      public synchronized DefinitionProvider<T> getByStringKey(String stringKey) {
          final DefinitionMetadata k = stringKeysMap.get(stringKey);
          return get(k);
      }
  
      public synchronized DefinitionProvider<T> getRequired(DefinitionMetadata key) throws RegistrationException {
          DefinitionProvider<T> value = map.get(key);
          if (value == null) {
              throw new RegistrationException("Entry for [" + key + "] not found in registry, available entries are: " +
                      (map.isEmpty() ? "<none>" : StringUtils.join(map.keySet(), ", ")));
          }
          return value;
      }
  
      public synchronized DefinitionProvider<T> getRequiredByStringKey(String stringKey) throws RegistrationException {
          final DefinitionMetadata k = stringKeysMap.get(stringKey);
          return getRequired(k);
      }
  
  
      public synchronized DefinitionMetadata put(DefinitionProvider<T> value) {
          final DefinitionMetadata key = keyFromValue(value);
          map.put(key, value);
          stringKeysMap.put(asStringKey(value), key);
          return key;
      }
  
      public synchronized void remove(DefinitionMetadata key) {
          final DefinitionProvider<T> provider = map.remove(key);
          stringKeysMap.remove(asStringKey(provider));
      }
 
     public synchronized Set<DefinitionMetadata> removeAndPutAll(Collection<DefinitionMetadata> toRemove, Collection<DefinitionProvider<T>> toPut) {
         // Fail early (and don't remove existing defs) if keyFromValue can't work for any of toPut items
         if (!toPut.isEmpty()) {
             keyFromValue(toPut.iterator().next());
         }
         for (DefinitionMetadata key : toRemove) {
             if (!map.containsKey(key)) {
                 throw new IllegalArgumentException(String.format("%s can't be removed from map, it is not an existing key", key));
             }
 
             final DefinitionProvider<T> provider = map.remove(key);
             stringKeysMap.remove(asStringKey(provider));
         }
         final Set<DefinitionMetadata> keys = new HashSet<>();
         for (DefinitionProvider<T> value : toPut) {
             final DefinitionMetadata key = put(value);
             keys.add(key);
         }
         return keys;
     }
 
     public synchronized Collection<DefinitionMetadata> keySet() {
         return new ArrayList<>(map.keySet());
     }
 
     public synchronized Collection<DefinitionProvider<T>> values() {
         return new ArrayList<>(map.values());
     }
 
     protected DefinitionMetadata keyFromValue(DefinitionProvider<T> provider) {
         return provider.getMetadata();
     }
 
     protected String asStringKey(DefinitionProvider<T> provider) {
         return provider.getMetadata().getReferenceId();
     }
 }