/**
    * This file Copyright (c) 2003-2017 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.cms.core.version;
  
  import info.magnolia.cms.core.Path;
  import info.magnolia.context.SystemContext;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.VersionUtil;
  import info.magnolia.repository.RepositoryConstants;
  import info.magnolia.repository.RepositoryManager;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.inject.Inject;
  import javax.inject.Singleton;
  import javax.jcr.ImportUUIDBehavior;
  import javax.jcr.ItemNotFoundException;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.PropertyType;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Workspace;
  import javax.jcr.nodetype.ConstraintViolationException;
  import javax.jcr.nodetype.NodeType;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.RandomStringUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.JcrConstants;
  import org.apache.jackrabbit.commons.iterator.FilteringNodeIterator;
  import org.apache.jackrabbit.commons.predicate.Predicate;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * <p>Util to copy nodes and hierarchies between workspaces. A {@link Node, Predicate} defines what such a copy process includes.
   * This is used to copy pages to the version workspace. While the paragraph nodes have to be copied the sub-pages should not.</p>
   * <p>Storage structure is generated from node's uuid, level 1 node - first two letters from the first part, level 2 node - two letters from the second part and level 3 node - two letters from third part.</p>
   * <p>Example: for uuid<pre>93b0b5d8-8a10-11e6-ae22-56b6b6499611</pre> is generated following structure: <pre>/93/8a/11/[nodeName]</pre></p>.
   */
  @Singleton
  public final class CopyUtil {
  
      private static Logger log = LoggerFactory.getLogger(CopyUtil.class);
  
      private final SystemContext systemContext;
      private final RepositoryManager repositoryManager;
  
      @Inject
      public CopyUtil(SystemContext systemContext, RepositoryManager repositoryManager) {
          this.systemContext = systemContext;
          this.repositoryManager = repositoryManager;
      }
  
      /**
       * @deprecated since 5.3.1 - use {CopyUtil#copyToVersion} instead.
       */
      void copyToversion(Node source, Predicate filter) throws RepositoryException {
         copyToVersion(source, filter);
     }
 
     /**
      * Copy given node to the version store using specified filter.
      */
     void copyToVersion(Node source, Predicate filter) throws RepositoryException {
         // first check if the node already exist
         Node root;
         try {
             root = getVersionSessionFor(source).getNodeByIdentifier(source.getUUID());
             if (root.getParent().getName().equalsIgnoreCase(VersionManager.TMP_REFERENCED_NODES)) {
                 root.getSession().move(root.getPath(), "/" + root.getName());
             } else if (root.getDepth() > 3) {
                 this.removeProperties(root);
                 // copy root properties
                 this.updateProperties(source, root);
 
                 this.updateNodeTypes(source, root);
                 root.getSession().save();
             } else {
                 root = doImport(source);
             }
         } catch (ItemNotFoundException e) {
             // create root for this versionable node
             root = doImport(source);
         }
         // copy all child nodes
         NodeIterator children = new FilteringNodeIterator(source.getNodes(), filter);
         while (children.hasNext()) {
             Node child = children.nextNode();
             this.clone(child, root, filter, true);
         }
         this.removeNonExistingChildNodes(source, root, filter);
     }
 
     private Node doImport(Node source) throws RepositoryException {
         try {
             this.importNode(getVersionSessionFor(source).getRootNode(), source);
         } catch (IOException ioe) {
             throw new RepositoryException("Failed to import node in magnolia version store : " + ioe.getMessage(), ioe);
         }
         Node root = getVersionSessionFor(source).getNodeByIdentifier(source.getIdentifier());
         // save parent node since this node is newly created
         getVersionSessionFor(source).save();
         return root;
     }
 
     private void updateNodeTypes(Node source, Node root) throws RepositoryException {
         String sourcePrimaryNodeType = source.getPrimaryNodeType().getName();
         if (!root.getPrimaryNodeType().getName().equals(sourcePrimaryNodeType)) {
             root.setPrimaryType(sourcePrimaryNodeType);
         }
 
         List<String> targetNodeTypes = new ArrayList<String>();
         for (NodeType t : root.getMixinNodeTypes()) {
             targetNodeTypes.add(t.getName());
         }
         NodeType[] nodeTypes = source.getMixinNodeTypes();
         for (NodeType type : nodeTypes) {
             root.addMixin(type.getName());
             targetNodeTypes.remove(type.getName());
         }
         // remove all mixins not found in the original except MIX_VERSIONABLE
         for (String nodeType : targetNodeTypes) {
             if (JcrConstants.MIX_VERSIONABLE.equals(nodeType)) {
                 continue;
             }
             root.removeMixin(nodeType);
         }
     }
 
     /**
      * Copy source to destination using the provided filter.
      *
      * @param source node in version store
      * @param destination which needs to be restored
      * @param filter this must be the same filter as used while creating this version
      */
     void copyFromVersion(Node source, Node destination, Predicate filter) throws RepositoryException {
         // copy all nodes from version store
         this.copyAllChildNodes(source, destination, filter);
         // remove all non existing nodes
         this.removeNonExistingChildNodes(source, destination, filter);
 
         // merge top node properties
         this.removeProperties(destination);
         this.updateProperties(source, destination);
 
         this.removeNonExistingMixins(source, destination);
     }
 
     private void removeNonExistingMixins(Node source, Node destination) throws RepositoryException {
         List<String> destNodeTypes = new ArrayList<String>();
         // has to match mixin names as mixin instances to not equal()
         for (NodeType nt : destination.getMixinNodeTypes()) {
             destNodeTypes.add(nt.getName());
         }
         // remove all that still exist in source
         for (NodeType nt : source.getMixinNodeTypes()) {
             destNodeTypes.remove(nt.getName());
         }
         // un-mix the rest
         for (String type : destNodeTypes) {
             destination.removeMixin(type);
         }
     }
 
     /**
      * Recursively removes all child nodes from node using specified filter.
      */
     private void removeNonExistingChildNodes(Node source, Node destination, Predicate filter)
             throws RepositoryException {
         // collect all uuids from the source node hierarchy using the given filter
         NodeIterator children = new FilteringNodeIterator(destination.getNodes(), filter);
         while (children.hasNext()) {
             Node child = children.nextNode();
             // check if this child exist in source, if not remove it
             if (child.getDefinition().isAutoCreated()) {
                 continue;
             }
             try {
                 source.getSession().getNodeByIdentifier(child.getIdentifier());
                 // if exist its ok, recursively remove all sub nodes
                 this.removeNonExistingChildNodes(source, child, filter);
             } catch (ItemNotFoundException e) {
                 PropertyIterator referencedProperties = child.getReferences();
                 if (referencedProperties.getSize() > 0) {
                     // remove all referenced properties, its safe since source workspace cannot have these
                     // properties if node with this UUID does not exist
                     while (referencedProperties.hasNext()) {
                         referencedProperties.nextProperty().remove();
                     }
                 }
                 child.remove();
             }
         }
     }
 
     /**
      * Copy all child nodes from node1 to node2.
      */
     private void copyAllChildNodes(Node node1, Node node2, Predicate filter)
             throws RepositoryException {
         NodeIterator children = new FilteringNodeIterator(node1.getNodes(), filter);
         while (children.hasNext()) {
             Node child = children.nextNode();
             this.clone(child, node2, filter, true);
         }
     }
 
     public void clone(Node node, Node parent, Predicate filter, boolean removeExisting)
             throws RepositoryException {
         try {
             // it seems to be a bug in jackrabbit - cloning does not work if the node with the same uuid
             // exist, "removeExisting" has no effect
             // if node exist with the same UUID, simply update non propected properties
             String workspaceName = parent.getSession().getWorkspace().getName();
             Session session = getSession(workspaceName);
             Node existingNode = session.getNodeByIdentifier(node.getIdentifier());
             if (removeExisting) {
                 existingNode.remove();
                 session.save();
                 this.clone(node, parent);
                 return;
             }
             this.removeProperties(existingNode);
             this.updateProperties(node, existingNode);
             NodeIterator children = new FilteringNodeIterator(node.getNodes(), filter);
             while (children.hasNext()) {
                 this.clone(children.nextNode(), existingNode, filter, removeExisting);
             }
         } catch (ItemNotFoundException e) {
             // it's safe to clone if UUID does not exist in this workspace but we might have to remove same name sibling (different uuid) to avoid conflicts
             if (parent.hasNode(node.getName())) {
                 parent.getNode(node.getName()).remove();
                 parent.getSession().save();
             }
             this.clone(node, parent);
         }
     }
 
     private void clone(Node node, Node parent) throws RepositoryException {
         if (node.getDefinition().isAutoCreated()) {
             Node destination = parent.getNode(node.getName());
             this.removeProperties(destination);
             this.updateProperties(node, destination);
         } else {
             final String parentPath = parent.getPath();
             final String srcWorkspaceLogicalName = node.getSession().getWorkspace().getName();
             final String srcWorkspacePhysicalName = repositoryManager.getWorkspaceMapping(srcWorkspaceLogicalName).getPhysicalWorkspaceName();
             final Workspace targetWorkspace = parent.getSession().getWorkspace();
             final String srcPath = node.getPath();
             final String targetPath = parentPath + (parentPath != null && parentPath.endsWith("/") ? "" : "/") + node.getName();
             log.debug("workspace level clone from {}:{} to {}:{}", srcWorkspaceLogicalName, srcPath, targetWorkspace.getName(), parentPath);
             targetWorkspace.clone(srcWorkspacePhysicalName, srcPath, targetPath, true);
         }
     }
 
     /**
      * Remove all properties under the given node.
      */
     private void removeProperties(Node node) throws RepositoryException {
         PropertyIterator properties = node.getProperties();
         while (properties.hasNext()) {
             Property property = properties.nextProperty();
             if (property.getDefinition().isProtected() || property.getDefinition().isMandatory()) {
                 continue;
             }
             try {
                 property.remove();
             } catch (ConstraintViolationException e) {
                 log.debug("Property {} is a reserved property", property.getName());
             }
         }
     }
 
     /**
      * Import while preserving UUID, parameters supplied must be from separate workspaces.
      *
      * @param parent under which the specified node will be imported
      * @throws IOException if failed to import or export
      */
     private void importNode(Node parent, Node node) throws RepositoryException, IOException {
         File file = File.createTempFile("mgnl", null, Path.getTempDirectory());
         FileOutputStream outStream = new FileOutputStream(file);
         try {
             node.getSession().getWorkspace().getSession().exportSystemView(node.getPath(), outStream, false, true);
             outStream.flush();
         } finally {
             IOUtils.closeQuietly(outStream);
         }
         FileInputStream inStream = new FileInputStream(file);
         String tempPath = null;
         Node maybeVersionNode;
         try {
             // check if uuid exists and if it's versioned node node or not ... if it's some of the structure nodes, we need to:
             // - move children (versioned nodes) to some temporary location
             // - copy node from source workspace
             // - move back nodes from temporary location
             maybeVersionNode = getVersionSessionFor(node).getNodeByIdentifier(node.getIdentifier());
 
             // rather check depth than folder node type - folders can be versioned too ...
             if (maybeVersionNode.getDepth() < 4) {
                 // we found structure node, lets move it's subnodes under temp node
                 Iterable<Node> children = NodeUtil.getNodes(maybeVersionNode);
                 tempPath = RandomStringUtils.randomAlphabetic(16);
                 Node tempNode = parent.addNode(tempPath);
                 for (Node child : children) {
                     NodeUtil.createPath(parent, StringUtils.substringAfter(tempNode.getPath() + child.getParent().getPath(), "/"), NodeTypes.Folder.NAME);
                     NodeUtil.copyInSession(child, tempNode.getPath() + child.getPath());
                 }
             }
         } catch (ItemNotFoundException e) {
             // this is fine, node is not versioned yet
         }
         // this will remove structure node if it has same uuid as the new versioned node
         try {
             parent.getSession().getWorkspace().getSession().importXML(
                     NodeUtil.createPath(parent, getSavePath(node), NodeTypes.Folder.NAME, true).getPath(),
                     inStream,
                     ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING);
         } finally {
             IOUtils.closeQuietly(inStream);
         }
         // we need to check whether tempPath is not null and if not, move all nodes back where they should be
         if (StringUtils.isNotBlank(tempPath)) {
             moveChildren(parent, parent.getNode(tempPath), tempPath);
             // finally remove temp node
             parent.getNode(tempPath).remove();
             parent.getSession().save();
         }
         file.delete();
     }
 
     private void moveChildren(Node parent, Node node, String temPath) throws RepositoryException {
         for (Node child : NodeUtil.getNodes(node)) {
             if (parent.hasNode(StringUtils.substringAfter(child.getPath(), "/" + temPath + "/"))) {
                 moveChildren(parent.getNode(StringUtils.substringAfter(child.getPath(), "/" + temPath + "/")), child, temPath);
             } else {
                 NodeUtil.moveNode(child, parent);
             }
         }
     }
 
     /**
      * Merge all non reserved properties.
      */
     private void updateProperties(Node source, Node destination) throws RepositoryException {
         PropertyIterator properties = source.getProperties();
         while (properties.hasNext()) {
             Property property = properties.nextProperty();
             // exclude system property Rule and Version specific properties which were created on version
             String propertyName = property.getName();
             if (propertyName.equalsIgnoreCase(VersionManager.PROPERTY_RULE)) {
                 continue;
             }
             try {
                 if (property.getDefinition().isProtected()) {
                     continue;
                 }
                 if ("jcr:isCheckedOut".equals(propertyName)) {
                     // do not attempt to restore isCheckedOut property as it makes no sense to restore versioned node with
                     // checkedOut status and value for this property might not be set even though the property itself is set.
                     // Since JCR-1272 attempt to restore the property with no value will end up with RepositoryException instead
                     // of ConstraintViolationException and hence will not be caught by the catch{} block below.
                     continue;
                 }
                 if (property.getType() == PropertyType.REFERENCE) {
                     // first check for the referenced node existence
                     String destWorkspaceName = destination.getSession().getWorkspace().getName();
                     try {
                         getSession(destWorkspaceName).getNodeByIdentifier(property.getString());
                     } catch (ItemNotFoundException e) {
                         String repositoryId = repositoryManager.getRepositoryNameForWorkspace(destWorkspaceName);
                         if (!StringUtils.equalsIgnoreCase(destWorkspaceName, repositoryId + "-" + RepositoryConstants.VERSION_STORE)) {
                             throw e;
                         }
                         // get referenced node under temporary store
                         // use jcr import, there is no other way to get a node without sub hierarchy
                         String srcWorkspaceName = source.getSession().getWorkspace().getName();
                         Node referencedNode = getSession(srcWorkspaceName).getNodeByIdentifier(property.getString());
                         try {
                             this.importNode(getTemporaryPath(source), referencedNode);
                             this.removeProperties(getVersionSessionFor(source).getNodeByIdentifier(property.getString()));
                             getTemporaryPath(source).save();
                         } catch (IOException ioe) {
                             log.error("Failed to import referenced node", ioe);
                         }
                     }
                 }
                 if (property.getDefinition().isMultiple()) {
                     destination.setProperty(propertyName, property.getValues());
                 } else {
                     destination.setProperty(propertyName, property.getValue());
                 }
             } catch (ConstraintViolationException e) {
                 log.debug("Property {} is a reserved property", propertyName);
             }
         }
     }
 
     /**
      * Get session of the specified workspace. Always uses the System Context.
      */
     private Session getSession(String workspaceId) throws RepositoryException {
         return systemContext.getJCRSession(workspaceId);
     }
 
     private Session getVersionSessionFor(Node source) throws RepositoryException {
         final String versionWorkspace = VersionUtil.getVersionWorkspaceForNode(repositoryManager, source);
         return systemContext.getJCRSession(versionWorkspace);
     }
 
     /**
      * Get temporary node.
      */
     private Node getTemporaryPath(Node node) throws RepositoryException {
         return getVersionSessionFor(node).getNode("/" + VersionManager.TMP_REFERENCED_NODES);
     }
 
     static String getSavePath(Node node) throws RepositoryException {
         String uuid = node.getIdentifier();
         return String.format("%s/%s/%s", StringUtils.substring(uuid, 0, 2), StringUtils.substring(uuid, 9, 11), StringUtils.substring(uuid, 14, 16));
     }
 }