/**
    * 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.commands.impl;
  
  import info.magnolia.cms.core.version.VersionManager;
  import info.magnolia.cms.util.Rule;
  import info.magnolia.context.Context;
  import info.magnolia.jcr.predicate.NodeTypePredicate;
  import info.magnolia.jcr.predicate.RuleBasedNodePredicate;
  import info.magnolia.jcr.util.NodeUtil;
  
  import javax.inject.Inject;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  import javax.jcr.version.Version;
  import javax.jcr.version.VersionIterator;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Command to restore a node and all its descendants to their previous version.
   */
  public class RestorePreviousVersionCommand extends RuleBasedCommand {
      private static final Logger log = LoggerFactory.getLogger(RestorePreviousVersionCommand.class);
  
      private VersionManager versionManager;
  
      private boolean parentNodeTypeOnly = false;
  
      @Inject
      public RestorePreviousVersionCommand(VersionManager versionManager) {
          this.versionManager = versionManager;
      }
  
      @Override
      public boolean execute(Context context) throws Exception {
  
          final Node node = getJCRNode(context);
  
          parentNodeTypeOnly = (Boolean) (context.containsKey("parentNodeTypeOnly") ? context.get("parentNodeTypeOnly") : false);
  
          restore(node);
  
          return true;
      }
  
      @Override
      protected Rule getDefaultRule() {
          // disable default rule, we use a different strategy here, see #restoreAllChildren
          return null;
      }
  
      private void restore(Node node) throws RepositoryException {
          String nodeType = node.getPrimaryNodeType().getName();
  
          log.debug("Restoring previous version of node at {} of type {}", node.getPath(), nodeType);
  
          // Get last version of parent or single node.
          Version version = getPreviousVersion(node);
          // Check the version.
          if (version == null) {
              throw new RepositoryException("No previous version found for node at " + node.getPath());
          }
  
          // Restore parent previous version
          versionManager.restore(node, version, true);
  
         restoreAllChildren(node, nodeType);
     }
 
     /**
      * Restores all descendant nodes according to the following strategy:
      * <ul>
      * <li>Restore descendants of the same type as the parent, if {@link #isParentNodeTypeOnly()} is set to <code>true</code>
      * <li>Restore descendants according to the configured {@link Rule} for allowed node-types
      * <li>Restore descendants whose type is in the <code>mgnl:</code> namespace (fallback behavior).
      * </ul>
      *
      * @see #isParentNodeTypeOnly()
      * @see #getRule()
      */
     protected void restoreAllChildren(Node node, String parentNodeType) throws RepositoryException {
 
         Iterable<Node> children;
 
         if (isParentNodeTypeOnly()) {
             children = NodeUtil.collectAllChildren(node, new NodeTypePredicate(parentNodeType));
         } else if (this.getRule() != null) {
             children = NodeUtil.collectAllChildren(node, new RuleBasedNodePredicate(this.getRule()));
         } else {
             children = NodeUtil.collectAllChildren(node);
         }
 
         for (Node child : children) {
             Version childVersion = getPreviousVersion(child);
             if (childVersion == null) {
                 log.debug("No previous version found for subnode {}. Skipping restore...", child.getPath());
                 continue;
             }
             versionManager.restore(child, childVersion, true);
         }
     }
 
     /**
      * @return previous version or null if not found.
      */
     private Version getPreviousVersion(Node node) throws RepositoryException {
         Version previousVersion = null;
         VersionIterator versionIterator = versionManager.getAllVersions(node);
 
         while (versionIterator.hasNext()) {
             previousVersion = versionIterator.nextVersion();
         }
 
         return previousVersion;
     }
 
     /**
      * @return true if the command context contains an <code>parentNodeTypeOnly</code> parameter whose value is true, false (default setting) otherwise.
      */
     public boolean isParentNodeTypeOnly() {
         return parentNodeTypeOnly;
     }
 
 }