/**
    * This file Copyright (c) 2012-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.jcr.node2bean.impl;
  
  import static info.magnolia.transformer.TransformationProblem.error;
  
  import info.magnolia.cms.util.ContentUtil;
  import info.magnolia.cms.util.SystemContentWrapper;
  import info.magnolia.jcr.iterator.FilteringNodeIterator;
  import info.magnolia.jcr.iterator.FilteringPropertyIterator;
  import info.magnolia.jcr.node2bean.Node2BeanException;
  import info.magnolia.jcr.node2bean.Node2BeanTransformer;
  import info.magnolia.jcr.node2bean.PropertyTypeDescriptor;
  import info.magnolia.jcr.node2bean.TransformationState;
  import info.magnolia.jcr.node2bean.TypeDescriptor;
  import info.magnolia.jcr.node2bean.TypeMapping;
  import info.magnolia.jcr.predicate.AbstractPredicate;
  import info.magnolia.jcr.predicate.JCRMgnlPropertyHidingPredicate;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.objectfactory.Classes;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.transformer.BeanTypeResolver;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Queue;
  import java.util.Set;
  import java.util.stream.Collectors;
  
  import javax.inject.Inject;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.beanutils.BeanUtilsBean;
  import org.apache.commons.beanutils.Converter;
  import org.apache.commons.beanutils.MethodUtils;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.lang3.LocaleUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.Iterables;
  import com.google.common.collect.Maps;
  
  /**
   * Concrete implementation using reflection, generics and setter methods.
   */
  public class Node2BeanTransformerImpl implements Node2BeanTransformer {
  
      private static final Logger log = LoggerFactory.getLogger(Node2BeanTransformerImpl.class);
 
     private final BeanUtilsBean beanUtilsBean;
 
     private final Class<?> defaultListImpl;
 
     private final Class<?> defaultSetImpl;
 
     private final Class<?> defaultQueueImpl;
 
     private final BeanTypeResolver beanTypeResolver;
 
     @Inject
     public Node2BeanTransformerImpl(PreConfiguredBeanUtils beanUtilsBean, BeanTypeResolver beanTypeResolver) {
         this(beanUtilsBean, LinkedList.class, HashSet.class, LinkedList.class, beanTypeResolver);
     }
 
     /**
      * @deprecated since 5.4 - use IoC, don't instantiate directly. You should not have to instantiate this if you
      * use magnolia-configuration mechanisms introduced in 5.4.
      */
     @Deprecated
     public Node2BeanTransformerImpl() {
         this(Components.getComponent(PreConfiguredBeanUtils.class), new BeanTypeResolver());
     }
 
     /**
      * @deprecated since 5.5.1 - use {@link #Node2BeanTransformerImpl(PreConfiguredBeanUtils, BeanTypeResolver)} instead.
      */
     @Deprecated
     public Node2BeanTransformerImpl(PreConfiguredBeanUtils beanUtilsBean) {
         this(beanUtilsBean, LinkedList.class, HashSet.class, LinkedList.class, new BeanTypeResolver());
     }
 
     /**
      * @deprecated since 5.4 - use IoC, don't instantiate directly. You should not have to instantiate this if you
      * use magnolia-configuration mechanisms introduced in 5.4.
      */
     @Deprecated
     public Node2BeanTransformerImpl(Class<?> defaultListImpl, Class<?> defaultSetImpl, Class<?> defaultQueueImpl) {
         this(Components.getComponent(PreConfiguredBeanUtils.class), defaultListImpl, defaultSetImpl, defaultQueueImpl, Components.getComponent(BeanTypeResolver.class));
     }
 
     protected Node2BeanTransformerImpl(PreConfiguredBeanUtils beanUtilsBean, Class<?> defaultListImpl, Class<?> defaultSetImpl, Class<?> defaultQueueImpl, BeanTypeResolver beanTypeResolver) {
         this.beanUtilsBean = beanUtilsBean;
         this.defaultListImpl = defaultListImpl;
         this.defaultSetImpl = defaultSetImpl;
         this.defaultQueueImpl = defaultQueueImpl;
         this.beanTypeResolver = beanTypeResolver;
 
         beanUtilsBean.getConvertUtils().deregister(Class.class);
     }
 
     @Override
     public TransformationState newState() {
         return new TransformationStateImpl();
     }
 
     @Override
     public TypeDescriptor resolveType(TypeMapping typeMapping, TransformationState state, ComponentProvider componentProvider) throws ClassNotFoundException, RepositoryException {
         Node node = state.getCurrentNode();
 
         Map<String, Object> properties = convertPropertiesToMap(node.getProperties());
 
         TypeDescriptor typeDscr = null;
         if (state.getLevel() > 1) {
             TypeDescriptor parentTypeDscr = state.getCurrentType();
             PropertyTypeDescriptor propDscr;
 
             if (parentTypeDscr.isMap() || parentTypeDscr.isCollection()) {
                 if (state.getLevel() > 2) {
                     // this is not necessarily the parent node of the current
                     String mapProperyName = state.peekNode(1).getName();
                     propDscr = state.peekType(1).getPropertyTypeDescriptor(mapProperyName, typeMapping);
                     if (propDscr != null) {
                         typeDscr = propDscr.getCollectionEntryType();
                     }
                 }
             } else {
                 propDscr = state.getCurrentType().getPropertyTypeDescriptor(node.getName(), typeMapping);
                 if (propDscr != null) {
                     typeDscr = propDscr.getType();
                 }
             }
         }
 
         typeDscr = beanTypeResolver.resolve(typeDscr, properties).map(typeMapping::getTypeDescriptor).orElse(typeDscr);
         typeDscr = onResolveType(typeMapping, state, typeDscr, componentProvider);
 
         if (typeDscr != null) {
             // might be that the factory util defines a default implementation for interfaces
             final Class<?> type = typeDscr.getType();
             typeDscr = typeMapping.getTypeDescriptor(componentProvider.getImplementation(type));
 
             // now that we know the property type we should delegate to the custom transformer if any defined
             Node2BeanTransformer customTransformer = typeDscr.getTransformer();
             if (customTransformer != null && customTransformer != this) {
                 TypeDescriptor typeFoundByCustomTransformer = customTransformer.resolveType(typeMapping, state, componentProvider);
                 // if no specific type has been provided by the
                 // TODO - TypeDescriptor - equals and hashCode impl and use
                 // not equals instead of !=
                 if (typeFoundByCustomTransformer != TypeMapping.MAP_TYPE) {
                     // might be that the factory util defines a default implementation for interfaces
                     Class<?> implementation = componentProvider.getImplementation(typeFoundByCustomTransformer.getType());
                     typeDscr = typeMapping.getTypeDescriptor(implementation);
                 }
             }
         }
 
         if (typeDscr == null || typeDscr.needsDefaultMapping()) {
             if (typeDscr == null) {
                 log.debug("Was not able to resolve type for node [{}] will use a map", node);
             }
             typeDscr = TypeMapping.MAP_TYPE;
         }
         log.debug("Resolved type [{}] for node [{}]", typeDscr.getType(), node.getPath());
 
         return typeDscr;
     }
 
     private Map<String, Object> convertPropertiesToMap(PropertyIterator iterator) throws RepositoryException {
         Map<String, Object> propertyMap = Maps.newHashMap();
         while (iterator.hasNext()) {
             Property property = iterator.nextProperty();
             final Object propertyValue;
             if (property.isMultiple()) {
                propertyValue = Arrays.stream(property.getValues()).map(PropertyUtil::getValueObject).collect(Collectors.toList());
             } else {
                propertyValue = PropertyUtil.getValueObject(property.getValue());
             }
             propertyMap.put(property.getName(), propertyValue);
         }
         return propertyMap;
     }
 
     @Override
     public NodeIterator getChildren(Node node) throws RepositoryException {
         // TODO create predicate into separate class, <? extends Item> ItemHidingPredicate (regexp)
         return new FilteringNodeIterator(node.getNodes(), new AbstractPredicate<Node>() {
             @Override
             public boolean evaluateTyped(Node t) {
                 try {
                     return !(t.getName().startsWith(NodeTypes.JCR_PREFIX) || t.isNodeType(NodeTypes.MetaData.NAME));
                 } catch (RepositoryException e) {
                     return false;
                 }
             }
         });
     }
 
     @Override
     public PropertyIterator getProperties(Node node) throws RepositoryException {
         return new FilteringPropertyIterator(node.getProperties(), new JCRMgnlPropertyHidingPredicate());
     }
 
     @Override
     public Object newBeanInstance(TransformationState state, Map<String, Object> values, ComponentProvider componentProvider) throws Node2BeanException {
         // we try first to use conversion (Map --> primitive type)
         // this is the case when we flattening the hierarchy?
         final Object bean = convertPropertyValue(state.getCurrentType().getType(), values);
         // were the properties transformed?
         if (bean == values) {
             try {
                 // is this property remove necessary?
                 values.remove("class");
                 final Class<?> type = state.getCurrentType().getType();
                 if (LinkedHashMap.class.equals(type)) {
                     // TODO - as far as I can tell, "bean" and "properties" are already the same instance of a
                     // LinkedHashMap, so what are we doing in here ?
                     return new LinkedHashMap();
                 } else if (Map.class.isAssignableFrom(type)) {
                     // TODO ?
                     log.warn("someone wants another type of map ? {}", type);
                 } else if (Collection.class.isAssignableFrom(type)) {
                     // someone wants specific collection
                     return type.newInstance();
                 }
                 return componentProvider.newInstance(type);
             } catch (Exception e) {
                 // This error is not tracked here because by current design the N2B conversion is supossed to blow up.
                 // The N2B exception will bubble upwards to the N2BProcessor where we either handle it (the new API will catch the exception and record the error)
                 // or, in case of the old API - we don't care about error tracking that much and will just let exception fly.
                 throw new Node2BeanException(
                         String.format("Failed to instantiate a bean of type [%s] due to: [%s]", state.getCurrentType().getType().getName(), e.getMessage()), e);
             }
         }
         return bean;
     }
 
     @Override
     public void initBean(TransformationState state, Map values) throws Node2BeanException {
         Object bean = state.getCurrentBean();
 
         Method init;
         try {
             init = bean.getClass().getMethod("init");
             try {
                 init.invoke(bean); // no parameters
             } catch (Exception e) {
                 throw new Node2BeanException("can't call init method", e);
             }
         } catch (SecurityException | NoSuchMethodException e) {
             return;
         }
         log.debug("{} is initialized", bean);
 
     }
 
     @Override
     public Object convertPropertyValue(Class<?> propertyType, Object value) throws Node2BeanException {
         if (Class.class.equals(propertyType)) {
             try {
                 return Classes.getClassFactory().forName(value.toString());
             } catch (ClassNotFoundException e) {
                 // we let this error to be tracked by handleSetPropertyException, which is a common funnel for property-related failures
                 throw new Node2BeanException(String.format("Can't convert property. Class for type [%s] not found.", propertyType), e);
             }
         }
 
         if (Locale.class.equals(propertyType)) {
             if (value instanceof String) {
                 String localeStr = (String) value;
                 if (StringUtils.isNotEmpty(localeStr)) {
                     return LocaleUtils.toLocale(localeStr);
                 }
             }
         }
 
         if (Collection.class.equals(propertyType) && value instanceof Map) {
             // TODO never used ?
             return ((Map) value).values();
         }
 
         // this is mainly the case when we are flattening node hierarchies
         if (String.class.equals(propertyType) && value instanceof Map && ((Map) value).size() == 1) {
             return ((Map) value).values().iterator().next();
         }
 
         return value;
     }
 
     /**
      * Called once the type should have been resolved. The resolvedType might be
      * null if no type has been resolved. Every subclass should override this method.
      */
     protected TypeDescriptor onResolveType(TypeMapping typeMapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
         return resolvedType;
     }
 
     @Override
     public void setProperty(TypeMapping mapping, TransformationState state, PropertyTypeDescriptor descriptor, Map<String, Object> values) throws RepositoryException {
         String propertyName = descriptor.getName();
         if (propertyName.equals("class")) {
             return;
         }
         Object value = values.get(propertyName);
         Object bean = state.getCurrentBean();
 
         if (propertyName.equals("content") && value == null) {
             PropertyTypeDescriptor dscr = mapping.getPropertyTypeDescriptor(bean.getClass(), propertyName);
             // For backwards compatibility with before this type check was present we support all the base classes of
             // SystemContentWrapper and all the interfaces it implements
             if (dscr.getType().getType().isAssignableFrom(SystemContentWrapper.class)) {
                 value = new SystemContentWrapper(ContentUtil.asContent(state.getCurrentNode()));
             } else  if (dscr.getType().getType().isAssignableFrom(Node.class)) {
                 value = state.getCurrentNode();
             }
 
         } else if (propertyName.equals("name") && value == null) {
             value = state.getCurrentNode().getName();
         } else if (propertyName.equals("className") && value == null) {
             value = values.get("class");
         }
 
         // do no try to set a bean-property that has no corresponding node-property
         if (value == null) {
             return;
         }
 
         log.debug("try to set {}.{} with value {}", bean, propertyName, value);
         // if the parent bean is a map, we can't guess the types.
         if (!(bean instanceof Map)) {
             try {
                 PropertyTypeDescriptor dscr = mapping.getPropertyTypeDescriptor(bean.getClass(), propertyName);
                 if (dscr.getType() != null) {
                     // try to use a setter method for a Collection property of
                     // the bean
                     if (dscr.isCollection() || dscr.isMap() || dscr.isArray()) {
                         log.debug("{} is of type collection, map or array", propertyName);
                         if (dscr.getWriteMethod() != null) {
                             Method method = dscr.getWriteMethod();
                             clearCollection(bean, propertyName);
                             filterOrConvertCollectionsAndMaps(dscr, value);
                             if (dscr.isMap()) {
                                 method.invoke(bean, value);
                             } else if (dscr.isArray()) {
                                 Class<?> entryClass = dscr.getCollectionEntryType().getType();
                                 Collection<Object> list = new LinkedList<>(((Map<Object, Object>) value).values());
 
                                 Object[] arr = (Object[]) Array.newInstance(entryClass, list.size());
                                 for (int i = 0; i < arr.length; i++) {
                                     arr[i] = Iterables.get(list, i);
                                 }
                                 method.invoke(bean, new Object[]{arr});
                             } else if (dscr.isCollection()) {
                                 if (value instanceof Map) {
                                     value = createCollectionFromMap((Map<Object, Object>) value, dscr.getType().getType());
                                 }
                                 method.invoke(bean, value);
                             }
                             return;
                         } else if (dscr.getAddMethod() != null) {
                             Method method = dscr.getAddMethod();
                             clearCollection(bean, propertyName);
                             Class<?> entryClass = dscr.getCollectionEntryType().getType();
 
                             log.warn("Will use deprecated add method [{}] to populate [{}] in bean class [{}].", method.getName(), propertyName, bean.getClass().getName());
                             for (Object key : ((Map<Object, Object>) value).keySet()) {
                                 Object entryValue = ((Map<Object, Object>) value).get(key);
                                 entryValue = convertPropertyValue(entryClass, entryValue);
                                 if (entryClass.isAssignableFrom(entryValue.getClass())) {
                                     if (dscr.isCollection() || dscr.isArray()) {
                                         log.debug("will add value {}", entryValue);
                                         method.invoke(bean, entryValue);
                                     }
                                     // is a map
                                     else {
                                         log.debug("will add key {} with value {}", key, entryValue);
                                         method.invoke(bean, key, entryValue);
                                     }
                                 }
                             }
                             return;
                         }
                         if (dscr.isCollection()) {
                             log.debug("transform the values to a collection", propertyName);
                             value = ((Map<Object, Object>) value).values();
                         }
                     } else {
                         value = convertPropertyValue(dscr.getType().getType(), value);
                     }
                 }
             } catch (Exception e) {
                 handleSetPropertyException(state, propertyName, value, bean, e);
                 return;
             }
         }
 
         try {
             // This uses the converters registered in beanUtilsBean.convertUtilsBean (see constructor of this class)
             // If a converter is registered, beanutils will determineBestMatch value.toString(), not the value object as-is.
             // If no converter is registered, then the value Object is set as-is.
             // If convertPropertyValue() already converted this value, you'll probably want to unregister the beanutils
             // converter.
             // some conversions like string to class. Performance of PropertyUtils.setProperty() would be better
             beanUtilsBean.setProperty(bean, propertyName, value);
         } catch (Exception e) {
             handleSetPropertyException(state, propertyName, value, bean, e);
         }
     }
 
     @Override
     public boolean canHandleValue(TypeMapping typeMapping, TransformationState state, PropertyTypeDescriptor descriptor, Entry<String, Object> value) {
         return descriptor.getName().equals(value.getKey())
                 || isCollectionOfStrings(typeMapping, state, value);
     }
 
     private boolean isCollectionOfStrings(TypeMapping typeMapping, TransformationState state, Entry<String, Object> value) {
         if (state.getCurrentBean() instanceof String && state.getLevel() > 2) {
             try {
                 PropertyTypeDescriptor propertyTypeDescriptor = state.peekType(2).getPropertyTypeDescriptor(state.peekNode(1).getName(), typeMapping);
                 if (propertyTypeDescriptor != null) {
                     TypeDescriptor entryType = propertyTypeDescriptor.getCollectionEntryType();
                     if (entryType != null) {
                         return entryType.getType().isAssignableFrom(value.getValue().getClass());
                     }
                 }
             } catch (RepositoryException e) {
                 log.error("Could not resolve property type for node [{}]", state.getCurrentNode(), e);
             }
         }
         return false;
     }
 
     @Override
     public boolean supportsValueClaims() {
         // sub-classes should opt-in explicitly
         return getClass().equals(Node2BeanTransformerImpl.class);
     }
 
     protected boolean isBeanEnabled(Object bean) {
         Method method;
         Object isEnabled;
         try {
             method = bean.getClass().getMethod("isEnabled");
             // Check if return type is *not primitive* Boolean and if so return always true
             // See ConfiguredAreaDefinition
             if (method.getReturnType().equals(Boolean.class)) {
                 return true;
             }
             isEnabled = method.invoke(bean);
         } catch (NoSuchMethodException e) {
             // this is ok, enabled property is optional
             return true;
         } catch (IllegalArgumentException e) {
             // this should never happen
             return true;
         } catch (IllegalAccessException e) {
             log.warn("Can't access method [{}#isEnabled]. Maybe it's private/protected?", bean.getClass());
             return true;
         } catch (InvocationTargetException e) {
             log.error("An exception was thrown by [{}]#isEnabled method.", bean.getClass(), e);
             return true;
         }
         return (Boolean) isEnabled;
     }
 
     /**
      * Filters out not matching values and converts values if required.
      *
      * @param dscr descriptor keeping information about the properties
      * @param value object from which some element might be filtered or converted
      */
     private void filterOrConvertCollectionsAndMaps(final PropertyTypeDescriptor dscr, final Object value) {
         if (dscr.getCollectionEntryType() != null) {
             Class<?> entryClass = dscr.getCollectionEntryType().getType();
             if (dscr.getType().isCollection() && value instanceof Collection) {
                 final Collection<?> collection = ((Collection) value);
                 final Collection convertedCollection = filterOrConvert(collection, entryClass);
                 collection.clear();
                 collection.addAll(convertedCollection);
             } else if (value instanceof Map) {
                 final Map map = (Map) value;
                 final Map convertedMap = filterOrConvert(map, entryClass);
                 map.clear();
                 map.putAll(convertedMap);
             }
         }
     }
 
     private Collection filterOrConvert(final Collection collection, final Class entryClass) {
         final Collection converted = new ArrayList();
         for (Object obj : collection) {
             if (isBeanEnabled(obj)) {
                 if (!entryClass.isAssignableFrom(obj.getClass())) {
                     final Converter converter = beanUtilsBean.getConvertUtils().lookup(entryClass);
                     if (converter != null) {
                         converted.add(converter.convert(entryClass, obj));
                     }
                 } else {
                     converted.add(obj);
                 }
             }
         }
         return converted;
     }
 
     private Map filterOrConvert(final Map map, final Class entryClass) {
         final Map converted = new LinkedHashMap();
         for (Object key : map.keySet()) {
             Object obj = map.get(key);
             if (isBeanEnabled(obj)) {
                 if (!entryClass.isAssignableFrom(obj.getClass())) {
                     final Converter converter = beanUtilsBean.getConvertUtils().lookup(entryClass);
                     if (converter != null) {
                         converted.put(key, converter.convert(entryClass, obj));
                     }
                 } else {
                     converted.put(key, obj);
                 }
             }
         }
         return converted;
     }
 
     private void clearCollection(Object bean, String propertyName) {
         log.debug("clearing the current content of the collection/map");
         try {
             Object col = PropertyUtils.getProperty(bean, propertyName);
             if (col != null) {
                 MethodUtils.invokeExactMethod(col, "clear", new Object[]{});
             }
         } catch (Exception e) {
             log.debug("no clear method found on collection {}", propertyName);
         }
     }
 
     /**
      * Creates collection from map. Collection type depends on passed class parameter. If passed class parameter is
      * interface, then default implementation will be used for creating collection.<br/>
      * By default
      * <ul>
      * <li>{@link LinkedList} is used for creating List and Queue collections.</li>
      * <li>{@link HashSet} is used for creating Set collection.</li>
      * </ul>
      * If passed class parameter is an implementation of any collection type, then this method will create
      * this implementation and returns it.
      *
      * @param map a map which values will be converted to a collection
      * @param clazz collection type
      * @return Collection of elements or null.
      */
     protected Collection<?> createCollectionFromMap(Map<?, ?> map, Class<?> clazz) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
         Collection<?> collection = null;
         Constructor<?> constructor = null;
         if (clazz.isInterface()) {
             // class is an interface, we need to decide which implementation of interface we will use
             if (List.class.isAssignableFrom(clazz)) {
                 constructor = defaultListImpl.getConstructor(Collection.class);
             } else if (clazz.isAssignableFrom(Queue.class)) {
                 constructor = defaultQueueImpl.getConstructor(Collection.class);
             } else if (Set.class.isAssignableFrom(clazz)) {
                 constructor = defaultSetImpl.getConstructor(Collection.class);
             }
         } else {
             if (Collection.class.isAssignableFrom(clazz)) {
                 constructor = clazz.getConstructor(Collection.class);
             }
         }
         if (constructor != null) {
             collection = (Collection<?>) constructor.newInstance(map.values());
         }
         return collection;
     }
 
     private void handleSetPropertyException(TransformationState state, String propertyName, Object value, Object bean, Exception e) throws RepositoryException /* See MAGNOLIA-5890, Node2BeanException */ {
         if (e instanceof InvocationTargetException) {
             e = (Exception) e.getCause();
         }
         final String errorMessage = String.format("Can't set property [%s] to value [%s] in bean [%s] for node [%s] due to: [%s]", propertyName, value, bean.getClass().getName(), state.getCurrentNode().getPath(), e.toString());
 
         state.trackProblem(error(errorMessage).withException(e));
     }
 
 }