/**
    * This file Copyright (c) 2015-2018 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.maputil;
  
  import static org.apache.commons.lang3.StringUtils.*;
  
  import java.util.AbstractMap;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import com.google.common.collect.Lists;
  import com.google.common.collect.Sets;
  
  /**
   * Overlays a map-represented configuration data (map of maps) with another similarly-structured map at a certain path.
   */
  public class ConfigurationMapOverlay {
  
      private Map<String, Object> source;
      private Map<String, Object> decorator;
      private String overlayPath;
  
      public static ConfigurationMapOverlay of(Map<String, Object> source) {
          ConfigurationMapOverlay configMapMerger = new ConfigurationMapOverlay();
          configMapMerger.source = source;
          return configMapMerger;
      }
  
      public ConfigurationMapOverlay by(Map<String, Object> decorator) {
          this.decorator = decorator;
          return this;
      }
  
      public ConfigurationMapOverlay at(String path) {
          this.overlayPath = path;
          return this;
      }
  
      public Map<String, Object> overlay() {
          return doOverlay(source, "/");
      }
  
      /**
       * Recursively goes over the {@code source} map and tracks the current traversed path. If the
       * current traversed path matches the {@link #overlayPath overlay path} - the {@link #decorator overlay map}
       * is merged directly into the current source sub-map (or sub-collection).
       *
       * @param source map structure being overlayed
       * @param currentTraversedPath currently processed part of the {@code source}
       */
      private <K> Map<K, Object> doOverlay(Map<K, Object> source, String currentTraversedPath) {
          Map<K, Object> result = new LinkedHashMap<>();
          for (K key : source.keySet()) {
              Object value = source.get(key);
              // If not a map or collection - nothing to do, simply put the value into resulting map
              if (!(value instanceof Collection) && !(value instanceof Map)) {
                  result.put(key, value);
              } else {
                  // If value is a map or collection - try to recursively overlay it
                  Map<Object, Object> map = ToMap.toMap(value);
                  result.put(key, doOverlay(map, String.format("%s/%s", stripEnd(currentTraversedPath, "/"), key)));
              }
          }
 
         if (overlayPath.equals(currentTraversedPath)) {
             // cannot overcome the lousy cast below, this is because decorator data may occur at a point where we no longer guarantee keys to be strings
             result = mergeMaps((Map) result, decorator);
         } else {
             // Now check if maybe we need to simply add the decorator data under the remaining path which is completely missing from the parent
 
             // Make sure that so far we were going the right direction
             if (overlayPath.startsWith("/".equals(currentTraversedPath) ? "/" : currentTraversedPath + "/")) {
 
                 // Resolve the part we did not cover yet
                 String notCoveredOverlayPath = removeStart(overlayPath, currentTraversedPath);
 
                 // strip the leading slash if any
                 notCoveredOverlayPath = stripStart(notCoveredOverlayPath, "/");
 
                 // extract the next possible hop
                 final String nextNotCoveredLocation = notCoveredOverlayPath.contains("/") ? substringBefore(notCoveredOverlayPath, "/") : notCoveredOverlayPath;
 
                 // If the next hop is missing from the source - create the config path and
                 if (!source.containsKey(nextNotCoveredLocation)) {
                     addWithoutMerging(result, decorator, notCoveredOverlayPath);
                 }
             }
         }
 
         return result;
     }
 
     private void addWithoutMerging(Map source, Map decorator, String pathToAdd) {
         // First - create the layered maps for the missing path
         Map<String, Object> configMap;
         if (pathToAdd.contains("/")) {
             configMap = new LinkedHashMap<>();
             // Figure out all the missing path fragments and create the map layers in a reversed order:
             // e.g. we want to put the decorator data under path /foo/bar/baz which does not exist. For that
             // we create an empty map and put the decorator data in it with the key 'baz'. Then we create another map
             // and put the first map in it under key 'bar' and so on. The result is the layered configuration map
             // corresponding to the path that was initially missing from the source (/foo/bar/baz in our case).
             final List<String> fragmentsToCreate = Lists.reverse(Arrays.asList(substringAfter(pathToAdd, "/").split("/")));
             for (final String pathFragment : fragmentsToCreate) {
                 if (configMap.isEmpty()) {
                     configMap.put(pathFragment, decorator);
                 } else {
                     Map<String, Object> wrappingMap = new LinkedHashMap<>();
                     wrappingMap.put(pathFragment, configMap);
                     configMap = wrappingMap;
                 }
             }
         } else {
             configMap = decorator;
         }
 
         final String key = substringBefore(pathToAdd, "/");
         //noinspection unchecked
         source.put(key, configMap);
     }
 
     private <K> Map<K, Object> mergeMaps(Map<K, Object> original, Map<K, Object> decorator) {
         final Map<K, Object> result = new LinkedHashMap<>();
 
         final Set<K> resultingKeys;
         final Set<K> originalKeys = original.keySet();
         final Set<K> decoratingKeys = decorator.keySet();
 
         if (decorator instanceof OverridingMap) {
             // if the map contains the override instruction - use only the decorator keys
             resultingKeys = new LinkedHashSet<>(decoratingKeys);
         } else {
             // otherwise - combine the decorator keys with the original keys
             resultingKeys = Sets.union(originalKeys, decorator.keySet());
         }
 
         resultingKeys.forEach(key -> result.put(key, mergeValues(original.get(key), decorator.get(key))));
 
         return result;
     }
 
     private Object mergeValues(Object source, Object decoration) {
         if (source == null) {
             return decoration;
         }
 
         if (decoration == null) {
             return source;
         }
 
         if (!(source instanceof Collection) && !(source instanceof Map)) {
             // 'Simple value' case - decoration wins
             return decoration;
         } else {
             // Map/collection have to be overlayed
             final Map<Object, Object> sourceValueMap = ToMap.toMap(source);
             final Map<Object, Object> decorationMap = ToMap.toMap(decoration);
             return mergeMaps(sourceValueMap, decorationMap);
         }
     }
 
     /**
      * Map structure wrapper which merely indicates to the {@link ConfigurationMapOverlay}
      * that whenever the overlaying map is instance of this class, it should completely overwrite the
      * data coming from the source map.
      *
      * @param <K> key type
      * @param <V> value type
      */
     public final static class OverridingMap<K, V> extends AbstractMap<K, V> {
 
         private final Map<K, V> wrappedMap;
 
         public OverridingMap(Map<K, V> wrappedMap) {
             this.wrappedMap = wrappedMap;
         }
 
         @Override
         public Set<Entry<K, V>> entrySet() {
             return this.wrappedMap.entrySet();
         }
     }
 
 }