/**
    * This file Copyright (c) 2013-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.jcr.wrapper;
  
  import info.magnolia.cms.security.JCRSessionOp;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.jcr.decoration.ContentDecorator;
  import info.magnolia.jcr.decoration.ContentDecoratorPropertyWrapper;
  import info.magnolia.jcr.decoration.ContentDecoratorSessionWrapper;
  import info.magnolia.jcr.decoration.ContentDecoratorWorkspaceWrapper;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeTypes.LastModified;
  import info.magnolia.repository.RepositoryConstants;
  
  import java.io.InputStream;
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Stack;
  
  import javax.jcr.AccessDeniedException;
  import javax.jcr.Binary;
  import javax.jcr.InvalidItemStateException;
  import javax.jcr.ItemExistsException;
  import javax.jcr.NoSuchWorkspaceException;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Property;
  import javax.jcr.ReferentialIntegrityException;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Value;
  import javax.jcr.ValueFormatException;
  import javax.jcr.Workspace;
  import javax.jcr.lock.LockException;
  import javax.jcr.nodetype.ConstraintViolationException;
  import javax.jcr.nodetype.NoSuchNodeTypeException;
  import javax.jcr.version.VersionException;
  
  import org.apache.commons.lang3.ArrayUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Decorator to set appropriate Mgnl specific properties (e.g. mgnl:lastModification, mgnl:created).
   *
   * Caution: upon workspace clone the wrapper does not update the lastModification date in order to preserve contract of clone (make an identical copy).
   */
  public class MgnlPropertySettingContentDecorator extends PropertyAndChildWrappingContentDecorator implements ContentDecorator {
  
      /**
       * inner holder of node info for all nodes that need their lud modified.
       */
      // as long as this class stays bound to session in which it is created, we don't need to store workspace name
      private class DirtyOp {
  
          private String path;
          private String userName;
          private Calendar updateDate;
  
          public DirtyOp(String path, String userName, Calendar updateDate) {
              this.path = path;
              this.userName = userName;
             this.updateDate = updateDate;
         }
 
         public String getPath() {
             return path;
         }
 
         public void setPath(String path) {
             this.path = path;
         }
 
         public String getUserName() {
             return userName;
         }
 
         public Calendar getUpdateDate() {
             return updateDate;
         }
 
     }
 
     private static final Logger log = LoggerFactory.getLogger(MgnlPropertySettingContentDecorator.class);
 
     // TODO: this behavior should be injectable w/ custom rules
     /**
      * Map below contains parent node type we try to resolve for LUD updates instead of the "current" path/node.
      */
     private static Map<String, String> parentNodeMappings = (Map) ArrayUtils.toMap(new String[][]{
             {RepositoryConstants.WEBSITE, NodeTypes.Page.NAME},
             {RepositoryConstants.USERS, NodeTypes.User.NAME}});
 
     protected List<DirtyOp> dirtyOps = new LinkedList<DirtyOp>();
 
 
     /**
      * Repository operation for update of mgnl:lastUpdated property.
      */
     final class ChangeLastUpdateDateOp extends MgnlContext.RepositoryOp {
         private final String workspaceName;
         private final String userName;
         private final String destAbsPath;
         private final Calendar updateDate;
         private final boolean recursiveDown;
 
         ChangeLastUpdateDateOp(String workspaceName, String userName, String destAbsPath, Calendar updateDate, boolean recursiveDown) {
             this.workspaceName = workspaceName;
             this.userName = userName;
             this.destAbsPath = destAbsPath;
             this.updateDate = updateDate;
             this.recursiveDown = recursiveDown;
         }
 
         @Override
         public void doExec() throws RepositoryException {
             Session sysSession = MgnlContext.getJCRSession(workspaceName);
 
             // does it exist?
             if (!sysSession.itemExists(destAbsPath)) {
                 // can't do anything.
                 if (log.isDebugEnabled()) {
                     log.warn("Can't update mgnl:lastModified. Path {}:{} doesn't exist anymore.", workspaceName, destAbsPath);
                 }
                 return;
             }
             String srcAbsPath = sysSession.getNode(destAbsPath).getPath();
 
             Stack<Node> nodes = resolveNodesToModify(workspaceName, destAbsPath, sysSession);
             Node node;
             if (!nodes.isEmpty()) {
                 node = nodes.pop();
             } else {
                 // might be null also after the failed attempt to resolve parent node that need to be marked as modified
                 node = sysSession.getNode(destAbsPath);
             }
 
             if (node.isNodeType(NodeTypes.MetaData.NAME)) {
                 // no LUD on old style of metadata
                 return;
             }
 
             // skip root node
             if (node.getDepth() == 0) {
                 return;
             }
 
             // unwrap
             if (node instanceof DelegateNodeWrapper) {
                 node = ((DelegateNodeWrapper) node).deepUnwrap(MgnlPropertySettingNodeWrapper.class);
             }
 
             log.debug("LUD on {} from {}:{}", node.getPath(), node.getSession().toString(), Thread.currentThread().getName());
             if (node.isNodeType(LastModified.NAME)) {
                 String resolvedPath = node.getPath();
                 if (!destAbsPath.equals(srcAbsPath)) {
                     // yeah, apparently that's what happens after non-yet-persisted in-session move
                     if (!resolvedPath.equals(srcAbsPath) && !resolvedPath.equals(destAbsPath)) {
                         // we are in real bind here ... what should be the dirty path?
                         if (srcAbsPath.startsWith(resolvedPath)) {
                             String hunk = StringUtils.substringAfter(srcAbsPath, resolvedPath);
                             if (destAbsPath.endsWith(hunk)) {
                                 resolvedPath = StringUtils.substringBefore(destAbsPath, hunk);
                             }
                         } else {
                             resolvedPath = destAbsPath;
                         }
                     }
                 }
 
                 dirtyOps.add(new DirtyOp(resolvedPath, userName, updateDate));
             }
 
             // do update other intermediate nodes
             while (!nodes.isEmpty()) {
                 Node child = nodes.pop();
                 if (child.isNodeType(LastModified.NAME)) {
                     dirtyOps.add(new DirtyOp(child.getPath(), userName, updateDate));
                 }
             }
 
             if (recursiveDown) {
                 // trick or treat children
                 List<NodeIterator> iters = new ArrayList<NodeIterator>();
                 iters.add(node.getNodes());
                 while (!iters.isEmpty()) {
                     List<NodeIterator> tmp = updateChildren(node.getPath(), destAbsPath, iters, updateDate);
                     iters.clear();
                     iters.addAll(tmp);
                 }
             }
             // save ... sucks, but since we are in system context there's no other way
             // we are overriding save on session and call it on sys ctx as well instead of saving here
             return;
         }
 
         /**
          * Resolves all nodes for which <code>mgnl:lastModified</code> should be updated.
          * <p>
          * This traverses the node hierarchy upwards until node is of the expected node-type (according to "parentNodeMappings", e.g. <code>mgnl:page</code> for the website workspace).
          *
          * @return a stack of nodes as follows:
          * <ul>
          * <li>Top entry is the top-most parent where <code>mgnl:lastModified</code> should be updated.</li>
          * <li>Stack contains all intermediate nodes between — and including — given node (@param <code>destAbsPath</code>) and resolved top-most parent.</li>
          * <li>Stack is empty in case no parentNodeMapping exists for the given workspace (i.e. <code>mgnl:lastModified</code> will only be updated for current node).</li>
          * </ul>
          */
         private Stack<Node> resolveNodesToModify(String workspace, String destAbsPath, Session sysSession) throws RepositoryException {
             Stack<Node> nodeStack = new Stack<Node>();
 
             String parentNodeType = parentNodeMappings.get(workspaceName);
             Node node = sysSession.getNode(destAbsPath);
             if (parentNodeType == null) {
                 return nodeStack;
             }
             while (node != null && !parentNodeType.equals(node.getPrimaryNodeType().getName()) && node.getDepth() > 0) {
                 nodeStack.add(node);
                 node = node.getParent();
             }
             nodeStack.add(node);
             return nodeStack;
         }
 
         private List<NodeIterator> updateChildren(String srcAbsPath, String destAbsPath, List<NodeIterator> iters, Calendar updateDate) {
             List<NodeIterator> tmp = new ArrayList<NodeIterator>();
             for (NodeIterator iter : iters) {
                 while (iter.hasNext()) {
                     Node node = iter.nextNode();
                     try {
                         if (skipTypeInWorkspace(workspaceName, node.getPrimaryNodeType().getName())) {
                             // do not update LUD of acls
                             continue;
                         }
                         if (node.isNodeType(NodeTypes.MetaData.NAME)) {
                             // no LUD on old style of metadata
                             continue;
                         }
                         if (node.isNodeType(LastModified.NAME)) {
                             dirtyOps.add(new DirtyOp(destAbsPath + StringUtils.removeStart(node.getPath(), srcAbsPath), userName, updateDate));
                         }
                         tmp.add(node.getNodes());
                     } catch (RepositoryException e) {
                         log.error("Failed to update last modified date of {} with {}", node, e.getMessage(), e);
                     }
                 }
             }
             return tmp;
         }
 
         private boolean skipTypeInWorkspace(String workspaceName, String name) {
             if (RepositoryConstants.USER_ROLES.equals(workspaceName)) {
                 return !(NodeTypes.Role.NAME.equals(name) || NodeTypes.Folder.NAME.equals(name));
             }
             if (RepositoryConstants.WEBSITE.equals(workspaceName)) {
                 return !NodeTypes.Page.NAME.equals(name);
             }
             return false;
         }
 
     }
 
     /**
      * Updates parent page or parent content mgnl:lastUpdated property on modification.
      */
     public class LastUpdatePropertyWrapper extends ContentDecoratorPropertyWrapper<MgnlPropertySettingContentDecorator> implements Property {
 
         public LastUpdatePropertyWrapper(Property property, MgnlPropertySettingContentDecorator contentDecorator) {
             super(property, contentDecorator);
         }
 
         @Override
         public void setValue(BigDecimal value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(Binary value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(boolean value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(Calendar value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(double value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(InputStream value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(long value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(Node value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(String value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(String[] values) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(values);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(Value value) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(value);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void setValue(Value[] values) throws ValueFormatException, VersionException, LockException, ConstraintViolationException, RepositoryException {
             super.setValue(values);
             this.updateLastModifiedProperty();
         }
 
         @Override
         public void remove() throws VersionException, LockException, ConstraintViolationException, AccessDeniedException, RepositoryException {
             Node parent = this.getParent();
             String propertyName = this.getName();
             super.remove();
             if (shouldIgnoreUpdate(propertyName)) {
                 return;
             }
             updateLastModified(parent.getSession(), parent.getPath());
         }
 
         private void updateLastModifiedProperty() throws RepositoryException {
             MgnlPropertySettingContentDecorator.this.updateLastModifiedProperty(getSession().getWorkspace().getName(), this.getName(), this.getParent().getPath());
         }
     }
 
     /**
      * Wrapper keeping last update date up to date.
      *
      * @deprecated since 5.2.2 - pls use MgnlPropertySettingWorkspaceWrapper instead.
      */
     public class LastUpdateWorkspaceWrapper extends MgnlPropertySettingWorkspaceWrapper {
 
         protected LastUpdateWorkspaceWrapper(final Workspace workspace, final ContentDecorator contentDecorator) {
             super(workspace, contentDecorator);
         }
     }
 
     /**
      * Updates destination parent page or parent content mgnl:lastUpdated property on move or copy operations.
      */
     public class MgnlPropertySettingWorkspaceWrapper extends ContentDecoratorWorkspaceWrapper implements Workspace {
 
         protected MgnlPropertySettingWorkspaceWrapper(final Workspace workspace, final ContentDecorator contentDecorator) {
             super(workspace, contentDecorator);
         }
 
         @Override
         public void move(String srcAbsPath, String destAbsPath) throws ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException {
             super.move(srcAbsPath, destAbsPath);
             updateLastModified(super.getWrappedWorkspace().getSession(), destAbsPath, true);
         }
 
         @Override
         public void copy(String srcAbsPath, String destAbsPath) throws ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException {
             super.copy(srcAbsPath, destAbsPath);
             final String workspaceName = super.getWrappedWorkspace().getName();
             setCreatedDate(workspaceName, destAbsPath, true);
         }
 
         @Override
         public void copy(String srcWorkspace, String srcAbsPath, String destAbsPath) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException {
             super.copy(srcWorkspace, srcAbsPath, destAbsPath);
             final String workspaceName = super.getWrappedWorkspace().getName();
             setCreatedDate(workspaceName, destAbsPath, true);
         }
 
         @Override
         public void clone(String srcWorkspace, String srcAbsPath, String destAbsPath, boolean removeExisting) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException {
             super.clone(srcWorkspace, srcAbsPath, destAbsPath, removeExisting);
             // no update on clone. a) it doesn't work reliably (session refresh) and b) contract of clone is to make identical copy!
         }
 
     }
 
     /**
      * Wrapper keeping last update date up to date.
      *
      * @deprecated since 5.2.2 - pls use MgnlPropertySettingSessionWrapper instead.
      */
     public class LastUpdateSessionWrapper extends MgnlPropertySettingSessionWrapper {
         public LastUpdateSessionWrapper(final Session session, final MgnlPropertySettingContentDecorator contentDecorator) {
             super(session, contentDecorator);
         }
     }
 
     /**
      * Updates all specific properties upon certain actions. Right now it's just updating the destination parent page or content mgnl:lastModified property on move.
      */
     public class MgnlPropertySettingSessionWrapper extends ContentDecoratorSessionWrapper<MgnlPropertySettingContentDecorator> implements Session {
 
         public MgnlPropertySettingSessionWrapper(Session session, MgnlPropertySettingContentDecorator contentDecorator) {
             super(session, contentDecorator);
         }
 
         @Override
         public void move(final String srcAbsPath, final String destAbsPath) throws ItemExistsException, PathNotFoundException, VersionException, ConstraintViolationException, LockException, RepositoryException {
             super.move(srcAbsPath, destAbsPath);
             // due to bug in some versions of jackrabbit we might have node showing itself as still being on a source path or already on a destination path
             boolean onSourcePath = MgnlContext.doInSystemContext(new JCRSessionOp<Boolean>(super.getWrappedSession().getWorkspace().getName()) {
                 @Override
                 public Boolean exec(Session session) throws RepositoryException {
                     return session.itemExists(srcAbsPath);
                 }
             });
             String aPath = onSourcePath ? srcAbsPath : destAbsPath;
             updateLastModified(super.getWrappedSession(), aPath, true);
             if (onSourcePath) {
                 for (DirtyOp op : dirtyOps) {
                     if (op.getPath().equals(srcAbsPath) || op.getPath().startsWith(srcAbsPath + "/")) {
                         op.setPath(destAbsPath + StringUtils.substringAfter(op.getPath(), srcAbsPath));
                     }
                 }
             }
         }
 
         @Override
         public void save() throws AccessDeniedException, ItemExistsException, ReferentialIntegrityException, ConstraintViolationException, InvalidItemStateException, VersionException, LockException, NoSuchNodeTypeException, RepositoryException {
             String workspaceName = wrapped.getWorkspace().getName();
             try {
                 log.debug("saving session: {}::{}::sys:{}::{}", wrapped.toString(), workspaceName, MgnlContext.isSystemInstance(), Thread.currentThread().getName());
                 super.save();
             } catch (InvalidItemStateException e) {
                 log.error("Failed to update LUD for session: {}::{}", wrapped.toString(), workspaceName, e);
                 throw e;
             }
             if (!dirtyOps.isEmpty()) {
                 Session sysSession = MgnlContext.getSystemContext().getJCRSession(workspaceName);
                 if (sysSession instanceof DelegateSessionWrapper) {
                     sysSession = ((DelegateSessionWrapper) sysSession).deepUnwrap(MgnlPropertySettingSessionWrapper.class);
                 }
                 applyPendingChanges(sysSession);
                 sysSession.save();
             }
         }
 
         protected void applyPendingChanges(Session session) throws RepositoryException, PathNotFoundException {
             while (!dirtyOps.isEmpty()) {
                 DirtyOp dirty = dirtyOps.remove(0);
                 if (session.nodeExists(dirty.getPath())) {
                     log.debug("Updating {} with {}", dirty.getPath(), dirty.getUpdateDate());
                     LastModified.update(session.getNode(dirty.getPath()), dirty.getUserName(), dirty.getUpdateDate());
                 } else {
                     // can happen when deleting something that was modified or moved within same session
                     if (log.isDebugEnabled()) {
                         log.warn("wanted to update {}:{} modified by:{} at {} but it's gone now.", session.getWorkspace().getName(), dirty.getPath(), dirty.getUserName(), dirty.getUpdateDate());
                     }
                 }
             }
         }
 
     }
 
     @Override
     public Session wrapSession(Session session) {
         return new MgnlPropertySettingSessionWrapper(session, this);
     }
 
     @Override
     public Workspace wrapWorkspace(Workspace workspace) {
         return new MgnlPropertySettingWorkspaceWrapper(workspace, this);
     }
 
     @Override
     public Node wrapNode(Node node) {
         return new MgnlPropertySettingNodeWrapper(node, this);
     }
 
     @Override
     public Property wrapProperty(Property property) {
         return new LastUpdatePropertyWrapper(property, this);
     }
 
     void updateLastModified(final Session session, final String destAbsPath, final boolean recursiveDown) throws RepositoryException, PathNotFoundException {
         this.updateLastModified(session.getWorkspace().getName(), destAbsPath, recursiveDown);
     }
 
     void updateLastModified(final String workspaceName, final String destAbsPath, final boolean recursiveDown) throws RepositoryException, PathNotFoundException {
 
         if ("/".equals(destAbsPath) && !recursiveDown) {
             // we do not maintain lud on root node
             return;
         }
         // one date for all children
         final Calendar updateDate = Calendar.getInstance();
 
         // DO ALL IN SYSTEM CONTEXT !!! USER MIGHT NOT HAVE ENOUGH RIGHTS
         MgnlContext.doInSystemContext(new ChangeLastUpdateDateOp(workspaceName, MgnlContext.getUser().getName(), destAbsPath, updateDate, recursiveDown));
 
     }
 
     void updateLastModified(String workspaceName, String destAbsPath) throws RepositoryException, PathNotFoundException {
         updateLastModified(workspaceName, destAbsPath, false);
     }
 
     void updateLastModified(Session session, String destAbsPath) throws RepositoryException, PathNotFoundException {
         updateLastModified(session, destAbsPath, false);
     }
 
     void updateLastModifiedProperty(String workspaceName, String propertyName, String parentPath) throws RepositoryException {
         if (shouldIgnoreUpdate(propertyName)) {
             return;
         }
         updateLastModified(workspaceName, parentPath);
     }
 
     void setCreatedDate(final String workspaceName, final String absPath) throws RepositoryException {
         setCreatedDate(workspaceName, absPath, false);
     }
 
     void setCreatedDate(final String workspaceName, final String absPath, final boolean recursiveDown) throws RepositoryException {
         final Session session = MgnlContext.getJCRSession(workspaceName);
 
         // does it exist?
         if (!session.itemExists(absPath)) {
             // can't do anything.
             if (log.isDebugEnabled()) {
                 log.warn("Can't update {}. Path {}:{} does not exist.", NodeTypes.Created.NAME, workspaceName, absPath);
             }
             return;
         }
         Node node = session.getNode(absPath);
 
         // don't do anything on null nodes
         if (node == null) {
             return;
         }
 
         // skip root
         if (node.getDepth() == 0) {
             return;
         }
 
         // unwrap if required
         if (node instanceof DelegateNodeWrapper) {
             node = ((DelegateNodeWrapper) node).deepUnwrap(MgnlPropertySettingNodeWrapper.class);
         }
 
         final String user = MgnlContext.getUser().getName();
 
         // one date for all
         final Calendar now = Calendar.getInstance();
 
         if (node.isNodeType(NodeTypes.Created.NAME)) {
             log.debug("Setting {} on {} from {}:{}", NodeTypes.Created.NAME, node.getPath(), node.getSession().toString(), Thread.currentThread().getName());
             NodeTypes.Created.set(node, user, now);
         }
 
         if (recursiveDown) {
             // trick or treat children
             List<NodeIterator> iters = new ArrayList<NodeIterator>();
             iters.add(node.getNodes());
             while (!iters.isEmpty()) {
                 List<NodeIterator> tmp = updateChildren(iters, user, now);
                 iters.clear();
                 iters.addAll(tmp);
             }
         }
     }
 
     private List<NodeIterator> updateChildren(final List<NodeIterator> iters, final String user, final Calendar updateDate) {
         List<NodeIterator> tmp = new ArrayList<NodeIterator>();
         for (NodeIterator iterator : iters) {
             while (iterator.hasNext()) {
                 Node node = iterator.nextNode();
                 try {
                     if (node.isNodeType(NodeTypes.Created.NAME)) {
                         NodeTypes.Created.set(node, user, updateDate);
                     }
                     tmp.add(node.getNodes());
                 } catch (RepositoryException e) {
                     log.error("Failed to set created date of {} with {}", node, e.getMessage(), e);
                 }
             }
         }
         return tmp;
     }
 
     /**
      * @return whether a modification to the property with the provided name should trigger an update of the last modification or not.
      */
     protected boolean shouldIgnoreUpdate(final String propertyName) {
         // our update doesn't count as update (activation, versioning, last update, etc) - except for changing the template
         return propertyName.startsWith(NodeTypes.JCR_PREFIX) || (propertyName.startsWith(NodeTypes.MGNL_PREFIX) && !NodeTypes.Renderable.TEMPLATE.equals(propertyName));
     }
 }