/**
    * This file Copyright (c) 2016-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.map2bean;
  
  import static java.util.stream.Collectors.toList;
  
  import info.magnolia.jcr.node2bean.PropertyTypeDescriptor;
  import info.magnolia.jcr.node2bean.TypeDescriptor;
  import info.magnolia.transformer.TransformationProblem;
  
  import java.util.ArrayDeque;
  import java.util.ArrayList;
  import java.util.Deque;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.StringJoiner;
  import java.util.function.Function;
  
  import org.apache.commons.lang3.StringUtils;
  
  /**
   * Carries contextual information about the state of map-to-bean transformation run. Used by {@link Map2BeanTransformer}.
   * Aggregates the following info:
   * <ul>
   * <li>names of the map nodes currently stacked for transformation and {@link #currentPath()} method which allows to present these keys in a form of the path</li>
   * <li>stack of corresponding un-transformed values</li>
   * <li>stack of corresponding target type descriptors (and optionally their generic parameters)</li>
   * <li>a list of problems which occurred during transformation, accessible via {@link #getProblems()}</li>
   * </ul>
   */
  public class TransformationState {
  
      /**
       * A tuple containing information required for transformation of a single value.
       */
      class Entry {
          String name;
          Object value;
          TypeDescriptor typeDescriptor;
          TypeDescriptor genericTypeDescriptor;
  
          Entry(String name, Object value, TypeDescriptor typeDescriptor, TypeDescriptor genericType) {
              this.name = name;
              this.value = value;
              this.typeDescriptor = typeDescriptor;
              this.genericTypeDescriptor = genericType;
          }
      }
  
      private final List<TransformationProblem> problems = new ArrayList<>();
      private final Deque<Entry> entries = new ArrayDeque<>();
  
      void pushEntry(String name, Object value, TypeDescriptor typeDescriptor) {
          this.pushEntry(name, value, typeDescriptor, null);
      }
  
      public void pushEntry(String name, Object value, PropertyTypeDescriptor typeDescriptor) {
          this.pushEntry(name, value, typeDescriptor.getType(), typeDescriptor.getCollectionEntryType());
      }
  
      void pushEntry(String name, Object value, TypeDescriptor typeDescriptor, TypeDescriptor genericTypeDescriptor) {
          entries.push(new Entry(name, value, typeDescriptor, genericTypeDescriptor));
      }
  
      public void popCurrentEntry() {
          entries.pop();
     }
 
     Entry peek() {
         return entries.peek();
     }
 
     String peekName() {
         return entries.peek().name;
     }
 
     TypeDescriptor peekTypeDescriptor() {
         return entries.peek().typeDescriptor;
     }
 
     Object peekValue() {
         return entries.peek().value;
     }
 
     List<?> peekList() {
         return getListValue(entries.peek().value);
     }
 
     Map<String, Object> peekMap() {
         if (entries.peek().value instanceof Map) {
             return (Map<String, Object>) entries.peek().value;
         }
         return null;
     }
 
     List<TransformationProblem> getProblems() {
         return problems;
     }
 
     String currentPath() {
         final StringJoiner joiner = new StringJoiner("/");
         for (final Iterator<Entry> entryIterator = entries.descendingIterator(); entryIterator.hasNext(); ) {
             Entry next = entryIterator.next();
             joiner.add(Optional.ofNullable(next.value)
                     .filter(Map.class::isInstance)
                     .map(Map.class::cast)
                     .map(map -> map.get("name"))
                     .map(Object::toString)
                     .orElse(next.name)
             );
         }
         return StringUtils.defaultIfBlank(String.join("/", joiner.toString()), "/");
     }
 
     public void trackProblem(TransformationProblem.Builder problemBuilder) {
         problems.add(problemBuilder.withLocation(currentPath()).build());
     }
 
     private static List<Object> getListValue(Object value) {
         if (value instanceof List) {
             return (List<Object>) value;
         }
 
         if (value instanceof Map) {
             final Map<String, Object> map = (Map) value;
             final Function<Map.Entry<String, Object>, Object> entry2Value = new Function<Map.Entry<String, Object>, Object>() {
                 @Override
                 public Object apply(Map.Entry<String, Object> input) {
                     final Object returnValue = input.getValue();
                     if (returnValue instanceof Map) {
                         final Map mapValue = (Map) returnValue;
                         if (!mapValue.containsKey("name")) {
                             mapValue.put("name", input.getKey());
                         }
                     }
                     return returnValue;
                 }
             };
             return map.entrySet().stream().map(entry2Value).collect(toList());
         }
 
         return null;
     }
 }