/**
    * This file Copyright (c) 2003-2016 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.Content;
  import info.magnolia.cms.core.Path;
  import info.magnolia.cms.security.JCRSessionOp;
  import info.magnolia.cms.security.PermissionUtil;
  import info.magnolia.cms.util.Rule;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.context.SystemContext;
  import info.magnolia.jcr.predicate.RuleBasedNodePredicate;
  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 info.magnolia.repository.definition.RepositoryDefinition;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InvalidClassException;
  import java.io.ObjectInput;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutput;
  import java.io.ObjectOutputStream;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.inject.Inject;
  import javax.jcr.ItemNotFoundException;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.UnsupportedRepositoryOperationException;
  import javax.jcr.Value;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.version.Version;
  import javax.jcr.version.VersionHistory;
  import javax.jcr.version.VersionIterator;
  import javax.jcr.version.VersionManager;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.commons.io.IOUtils;
  import org.apache.jackrabbit.JcrConstants;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This version manager uses an extra workspace to manage the versions. The
   * workspace maintains a flat hierarchy. The content is then finally versioned
   * using JCR versioning which also copies the sub-nodes.
   *
   * The mix:versionable is only added on the top level nodes.
   */
  public abstract class BaseVersionManager {
  
      private static final Logger log = LoggerFactory.getLogger(BaseVersionManager.class);
  
      /**
       * Name of the workspace.
       */
      public static final String VERSION_WORKSPACE = "mgnlVersion";
 
     /**
      * Node which contains stubs for referenced nodes. We have to copy them to the workspace as well.
      */
     public static final String TMP_REFERENCED_NODES = "mgnl:tmpReferencedNodes";
 
     /**
      * Sub-node containing the data used for the version/restore process.
      */
     public static final String SYSTEM_NODE = "mgnl:versionMetaData";
 
     /**
      * Property name for collection rule. The rule defines which sub-nodes belong to a node: page and paragraphs.
      */
     public static final String PROPERTY_RULE = "Rule";
 
     /**
      * JCR version store root.
      */
     protected static final String ROOT_VERSION = "jcr:rootVersion";
 
     /**
      * Workspace of the source node.
      */
     public static final String SOURCE_WORKSPACE = "sourceWorkspace";
 
     private Collection<String> versionWorkspaces = new ArrayList<>();
 
     private final SystemContext systemContext;
     private final RepositoryManager repositoryManager;
     private final CopyUtil copyUtil;
 
     @Inject
     public BaseVersionManager(SystemContext systemContext, RepositoryManager repositoryManager, CopyUtil copyUtil) {
         this.systemContext = systemContext;
         this.repositoryManager = repositoryManager;
         this.copyUtil = copyUtil;
         for (RepositoryDefinition repositoryDefinition : repositoryManager.getRepositoryDefinitions()) {
             String repositoryId = repositoryDefinition.getName();
             String workspaceName = repositoryId + "-" + RepositoryConstants.VERSION_STORE;
             if (repositoryManager.getWorkspaceMapping(workspaceName) != null) {
                 versionWorkspaces.add(workspaceName);
             } else {
                 throw new RuntimeException(String.format("Something went wrong, version workspace for repository %s does not exist.", repositoryId));
             }
         }
     }
 
     /**
      * Create structure needed for version store workspace.
      *
      * @throws RepositoryException if unable to create magnolia system structure
      */
     protected void createInitialStructure() throws RepositoryException {
         for (String workspaceName : versionWorkspaces) {
             Session session = systemContext.getJCRSession(workspaceName);
             try {
                 Node tmp = session.getNode("/" + TMP_REFERENCED_NODES);
                 // remove nodes if they are no longer referenced within this workspace
                 NodeIterator children = tmp.getNodes();
                 while (children.hasNext()) {
                     Node child = children.nextNode();
                     if (child.getReferences().getSize() < 1) {
                         child.remove();
                     }
                 }
             } catch (PathNotFoundException e) {
                 session.getRootNode().addNode(TMP_REFERENCED_NODES, NodeTypes.System.NAME);
             }
             session.save();
         }
     }
 
     /**
      * Add version of the specified node and all child nodes while ignoring the same node type.
      */
     public synchronized Version addVersion(Node node) throws RepositoryException {
         Rule rule = new Rule(VersionUtil.getNodeTypeName(node) + "," + NodeTypes.System.NAME, ",");
         rule.reverse();
         return this.addVersion(node, rule);
     }
 
     /**
      * Add version of the specified node and all child nodes based on the given <code>Rule</code>. Reads the <code>userName</code>
      * from the current context.
      */
     public synchronized Version addVersion(final Node node, final Rule rule) throws RepositoryException {
         final String userName = getSafelyUserNameFromMgnlContext();
         return addVersion(node, rule, userName);
     }
 
     /**
      * Add version of the specified node and all child nodes based on the given <code>Rule</code> and <code>userName</code>.
      */
     public synchronized Version addVersion(final Node node, final Rule rule, final String userName) throws RepositoryException {
         final String workspaceName = node.getSession().getWorkspace().getName();
         Version version = MgnlContext.doInSystemContext(new JCRSessionOp<Version>(workspaceName) {
 
             @Override
             public Version exec(Session session) throws RepositoryException {
                 try {
                     return createVersion(session.getNodeByIdentifier(node.getIdentifier()), rule, userName);
                 } catch (RepositoryException re) {
                     // since add version is synchronized on a singleton object, its safe to revert all changes made in
                     // the session attached to workspace - mgnlVersion
                     log.error("failed to copy versionable node to version store, reverting all changes made in this session", re);
                     String versionWorkspaceName = VersionUtil.getVersionWorkspaceForNode(repositoryManager, node);
                     // We're in SystemContext
                     MgnlContext.getJCRSession(versionWorkspaceName).refresh(false);
                     throw re;
                 }
 
             }
         });
         return version;
     }
 
     private String getSafelyUserNameFromMgnlContext() {
         String userName = "";
         if (MgnlContext.getUser() != null) {
             userName = MgnlContext.getUser().getName();
         }
         return userName;
     }
 
     /**
      * Create version of the specified node and all child nodes based on the given <code>Rule</code>.
      * This will return null if can't create new version in case when max version index is lower then one
      * or when content is marked for deletion.
      *
      * @param node to be versioned
      * @return newly created version node
      * @throws UnsupportedOperationException if repository implementation does not support Versions API
      * @throws javax.jcr.RepositoryException if any repository error occurs
      */
     protected Version createVersion(Node node, Rule rule, String userName) throws RepositoryException {
         if (isInvalidMaxVersions()) {
             log.debug("Ignore create version, MaxVersionIndex < 1");
             return null;
         }
         if (node.isNodeType(NodeTypes.Deleted.NAME)) {
             log.debug("Don't create version for content marked as deleted");
             return null;
         }
 
         copyUtil.copyToVersion(node, new RuleBasedNodePredicate(rule));
         Node versionedNode = this.getVersionedNode(node);
 
         checkAndAddMixin(versionedNode);
         Node systemInfo = this.getSystemNode(versionedNode);
         // add serialized rule which was used to create this version
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         try {
             ObjectOutput objectOut = new ObjectOutputStream(out);
             objectOut.writeObject(rule);
             objectOut.flush();
             objectOut.close();
             // PROPERTY_RULE is not a part of MetaData to allow versioning of node types which does NOT support MetaData
             systemInfo.setProperty(PROPERTY_RULE, new String(Base64.encodeBase64(out.toByteArray())));
         } catch (IOException e) {
             throw new RepositoryException("Unable to add serialized Rule to the versioned content");
         }
         // add all system properties for this version
         systemInfo.setProperty(ContentVersion.VERSION_USER, userName);
         systemInfo.setProperty(ContentVersion.NAME, node.getName());
         systemInfo.setProperty(SOURCE_WORKSPACE, node.getSession().getWorkspace().getName());
 
         versionedNode.save();
 
         // add version
         VersionManager versionManager = versionedNode.getSession().getWorkspace().getVersionManager();
         Version newVersion = versionManager.checkin(versionedNode.getPath());
         versionManager.checkout(versionedNode.getPath());
 
         node.addMixin(NodeTypes.HasVersion.NAME);
         node.getSession().save();
 
         try {
             this.setMaxVersionHistory(versionedNode);
         } catch (RepositoryException re) {
             log.error("Failed to limit version history to the maximum configured", re);
             log.error("New version has already been created");
         }
 
 
         return newVersion;
     }
 
     /**
      * Check if max version index is lower then one.
      */
     public abstract boolean isInvalidMaxVersions();
 
     /**
      * Get node from version store.
      */
     public synchronized Node getVersionedNode(Node node) throws RepositoryException {
         try {
             final String versionWorkspace = VersionUtil.getVersionWorkspaceForNode(repositoryManager, node);
             final Session versionSession = new MgnlVersionSessionDecorator(node.getSession().getWorkspace().getName()).wrapSession(systemContext.getJCRSession(versionWorkspace));
             return versionSession.getNodeByIdentifier(node.getIdentifier());
         } catch (ItemNotFoundException e) {
             // node is not versioned yet
             return null;
         }
     }
 
     /**
      * Get node from version store.
      */
     protected Node getVersionedNode(Session session, String uuid) throws RepositoryException {
         try {
             return session.getNodeByIdentifier(uuid);
         } catch (ItemNotFoundException e) {
             // node is not versioned yet
             return null;
         }
     }
 
     /**
      * Set version history to max version possible.
      *
      * @throws RepositoryException if failed to get VersionHistory or fail to remove
      */
     public abstract void setMaxVersionHistory(Node node) throws RepositoryException;
 
     /**
      * Get history of this node as recorded in the version store.
      *
      * @return version history of the given node
      * @throws UnsupportedOperationException if repository implementation does not support Versions API
      * @throws javax.jcr.RepositoryException if any repository error occurs
      */
     public synchronized VersionHistory getVersionHistory(Node node) throws RepositoryException {
         try {
             Node versionedNode = this.getVersionedNode(node);
             if (versionedNode == null) {
                 // node does not exist in version store so no version history
                 log.debug("No VersionHistory found for {} node.", node);
                 return null;
             }
             VersionHistory versionHistory = versionedNode.getVersionHistory();
             VersionIterator versionIterator = versionHistory.getAllVersions();
             long filteredSize = versionIterator.getSize();
             long unfilteredSize = ((MgnlVersionSessionDecorator.MgnlVersionSessionVersionIteratorWrapper) versionIterator).getUnfilteredSize();
             // we have just root version for the passed node, but there are other versions from one or more workspaces
             // so to preserve expected behavior, return null
             if (filteredSize == 1 && unfilteredSize > filteredSize) {
                 return null;
             }
             return versionHistory;
         } catch (UnsupportedRepositoryOperationException e) {
             log.debug("Node {} is not versionable.", node);
             // node is not versionable or underlying repo doesn't support versioning.
             return null;
         }
     }
 
     /**
      * Get named version.
      *
      * @throws UnsupportedOperationException if repository implementation does not support Versions API
      * @throws javax.jcr.RepositoryException if any repository error occurs
      */
     public synchronized Version getVersion(Node node, String name) throws RepositoryException {
         VersionHistory history = this.getVersionHistory(node);
         if (history != null) {
             return new VersionedNode(history.getVersion(name), node);
         }
         log.error("Node {} was never versioned", node.getPath());
         return null;
     }
 
     /**
      * Returns the current base version of given node.
      */
     public Version getBaseVersion(Node node) throws UnsupportedOperationException, RepositoryException {
         VersionIterator versionIterator = getAllVersions(node);
         Version baseVersion = null;
         if (versionIterator != null) {
             while (versionIterator.hasNext()) {
                 Version version = versionIterator.nextVersion();
                 if (baseVersion == null) {
                     baseVersion = version;
                 } else if (baseVersion.getCreated().compareTo(version.getCreated()) < 0) {
                     baseVersion = version;
                 }
             }
         }
         if (baseVersion == null) {
             throw new RepositoryException("Node " + node.getPath() + " was never versioned");
         }
         return baseVersion;
     }
 
     /**
      * Get all versions.
      *
      * @return Version iterator retrieved from version history
      * @throws UnsupportedOperationException if repository implementation does not support Versions API
      * @throws javax.jcr.RepositoryException if any repository error occurs
      */
     public synchronized VersionIterator getAllVersions(Node node) throws RepositoryException {
         Node versionedNode = this.getVersionedNode(node);
         if (versionedNode == null) {
             // node does not exist in version store so no versions
             return null;
         }
         VersionHistory versionHistory = getVersionHistory(node);
         if (versionHistory == null) {
             // does not have any versions in version store
             return null;
         }
         return versionHistory.getAllVersions();
     }
 
     /**
      * Restore specified version.
      *
      * @param node to be restored
      * @param version to be used
      * @throws javax.jcr.version.VersionException if the specified <code>versionName</code> does not exist in this
      * node's version history
      * @throws javax.jcr.RepositoryException if an error occurs
      * @deprecated since 4.5 use {@link #restore(Node, Version, boolean)} instead
      */
     @Deprecated
     public synchronized void restore(Content node, Version version, boolean removeExisting) throws RepositoryException {
         restore(node.getJCRNode(), version, removeExisting);
     }
 
     /**
      * Restore specified version.
      *
      * @param node to be restored
      * @param version to be used
      * @throws javax.jcr.version.VersionException if the specified <code>versionName</code> does not exist in this
      * node's version history
      * @throws javax.jcr.RepositoryException if an error occurs
      */
     public synchronized void restore(final Node node, Version version, boolean removeExisting) throws RepositoryException {
         // FYI: restore is done in SC!!! Check permissions manually
         PermissionUtil.verifyIsGrantedOrThrowException(node.getSession(), node.getPath(), Session.ACTION_SET_PROPERTY + "," + Session.ACTION_REMOVE + "," + Session.ACTION_ADD_NODE);
 
         // get the cloned node from version store
         final Node versionedNode = this.getVersionedNode(node);
 
         final Version unwrappedVersion;
         if (version instanceof VersionedNode) {
             unwrappedVersion = VersionUtil.unwrap(((VersionedNode) version).unwrap());
         } else {
             unwrappedVersion = VersionUtil.unwrap(version);
         }
 
         VersionManager versionManager = versionedNode.getSession().getWorkspace().getVersionManager();
         versionManager.restore(unwrappedVersion, removeExisting);
         versionManager.checkout(versionedNode.getPath());
         MgnlContext.doInSystemContext(new JCRSessionOp<Void>(versionedNode.getSession().getWorkspace().getName()) {
 
             @Override
             public Void exec(Session session) throws RepositoryException {
                 //mixins are NOT restored automatically
                 List<String> mixins = new ArrayList<>();
                 for (Value v : unwrappedVersion.getNode(JcrConstants.JCR_FROZENNODE).getProperty("jcr:frozenMixinTypes").getValues()) {
                     mixins.add(v.getString());
                 }
 
                 final Node systemVersionedNode = session.getNodeByIdentifier(versionedNode.getUUID());
                 for (NodeType nt : versionedNode.getMixinNodeTypes()) {
                     if (!mixins.remove(nt.getName())) {
                         systemVersionedNode.removeMixin(nt.getName());
                     }
                 }
                 for (String mix : mixins) {
                     systemVersionedNode.addMixin(mix);
                 }
                 systemVersionedNode.save();
 
                 try {
                     // using system context here is forced by the fact that JR will use same context to also check source (mgnlVersion) repo READ permission and ordinary user has no rights in this workspace
                     Session sysDestinationSession = MgnlContext.getJCRSession(node.getSession().getWorkspace().getName());
                     log.debug("restoring info:{}:{}", sysDestinationSession.getWorkspace().getName(), node.getPath());
                     Node destinationNode = sysDestinationSession.getNode(node.getPath());
                     // if restored, update original node with the restored node and its subtree
                     Rule rule = getUsedFilter(versionedNode);
                     try {
                         copyUtil.copyFromVersion(versionedNode, destinationNode, new RuleBasedNodePredicate(rule));
                         if (NodeUtil.hasMixin(destinationNode, NodeTypes.Deleted.NAME)) {
                             destinationNode.removeMixin(NodeTypes.Deleted.NAME);
                         }
                         // next line is required because restore is done via clone op that preserves last modification date otherwise.
                         NodeTypes.LastModified.update(destinationNode);
                         destinationNode.save();
                         // node was updated in system context and we should make sure it is notified of the changes
                         node.refresh(false);
                     } catch (RepositoryException re) {
                         log.debug("error during restore: {}", re.getMessage(), re);
                         log.error("failed to restore versioned node, reverting all changes make to this node");
                         destinationNode.refresh(false);
                         throw re;
                     }
                 } catch (IOException e) {
                     throw new RepositoryException(e);
                 } catch (ClassNotFoundException e) {
                     throw new RepositoryException(e);
                 }
                 return null;
             }
         });
     }
 
     /**
      * Removes all versions of the node associated with given UUID.
      *
      * @throws RepositoryException if fails to remove versioned node from the version store
      */
     public synchronized void removeVersionHistory(final Node node) throws RepositoryException {
         final String nodePath = Path.getAbsolutePath(node.getPath());
         final Session session = node.getSession();
         final String workspaceName = session.getWorkspace().getName();
         log.debug("removing {} from {}", nodePath, workspaceName);
         PermissionUtil.verifyIsGrantedOrThrowException(session, nodePath, Session.ACTION_REMOVE);
 
         if (!(workspaceName.endsWith("-" + RepositoryConstants.VERSION_STORE) || workspaceName.endsWith("-" + RepositoryConstants.SYSTEM))) {
             VersionHistory versionHistory = getVersionHistory(node);
             if (versionHistory != null) {
                 VersionIterator versionIterator = versionHistory.getAllVersions();
                 long filteredSize = versionIterator.getSize();
                 long unfilteredSize = ((MgnlVersionSessionDecorator.MgnlVersionSessionVersionIteratorWrapper) versionIterator).getUnfilteredSize();
                 if (filteredSize == unfilteredSize) {
                     Node versioned = getVersionedNode(node);
                     versioned.remove();
                     versioned.getSession().save();
                 } else {
                     Iterator<Version> iterator = ((MgnlVersionSessionDecorator.MgnlVersionSessionVersionIteratorWrapper) versionIterator).getAllVersionsUnfiltered();
                     while (iterator.hasNext()) {
                         Version version = iterator.next();
                         if (version.getFrozenNode().hasNode(SYSTEM_NODE) && version.getFrozenNode().getNode(SYSTEM_NODE).hasProperty(SOURCE_WORKSPACE)) {
                             String sourceWorkspace = version.getFrozenNode().getNode(SYSTEM_NODE).getProperty(SOURCE_WORKSPACE).getString();
                             if (!sourceWorkspace.equals(node.getSession().getWorkspace().getName())) {
                                 Node nodeToRestore = systemContext.getJCRSession(sourceWorkspace).getNodeByIdentifier(node.getIdentifier());
                                 Version base = getBaseVersion(nodeToRestore);
                                 try {
                                     nodeToRestore.setProperty(NodeTypes.Versionable.COMMENT, "Created by system in order to release base version.");
                                     nodeToRestore.getSession().save();
                                     addVersion(nodeToRestore, getUsedFilter(getVersionedNode(base.getFrozenNode())));
                                 } catch (IOException | ClassNotFoundException e) {
                                     throw new RepositoryException(e);
                                 }
                                 break;
                             }
                         }
                     }
                 }
                 versionIterator.nextVersion(); // skip root version
                 while (versionIterator.hasNext()) {
                     Version version = versionIterator.nextVersion();
                     if (version.getName().equals(JcrConstants.JCR_ROOTVERSION)) {
                         continue;
                     }
                     versionHistory.removeVersion(version.getName());
                 }
             }
             session.save();
         }
     }
 
     public boolean hasVersion(Node node) throws RepositoryException {
         return NodeUtil.hasMixin(node, NodeTypes.HasVersion.NAME);
     }
 
     /**
      * Verifies the existence of the mix:versionable and adds it if not.
      */
     protected void checkAndAddMixin(Node node) throws RepositoryException {
         if (!node.isNodeType("mix:versionable")) {
             log.debug("Add mix:versionable");
             node.addMixin("mix:versionable");
         }
     }
 
     /**
      * Get Rule used for this version.
      */
     protected Rule getUsedFilter(Node versionedNode) throws IOException, ClassNotFoundException, RepositoryException {
         // if restored, update original node with the restored node and its subtree
         ByteArrayInputStream inStream = null;
         try {
             String ruleString = this.getSystemNode(versionedNode).getProperty(PROPERTY_RULE).getString();
             inStream = new ByteArrayInputStream(Base64.decodeBase64(ruleString.getBytes()));
             ObjectInput objectInput = new ObjectInputStream(inStream);
             return (Rule) objectInput.readObject();
         } catch (InvalidClassException e) {
             log.debug(e.getMessage());
             log.debug("Will return default rule -> all child nodes while ignoring versionedNode nodeType.");
             Rule rule = new Rule(VersionUtil.getNodeTypeName(versionedNode) + "," + NodeTypes.System.NAME, ",");
             rule.reverse();
             return rule;
         } catch (IOException e) {
             throw e;
         } catch (ClassNotFoundException e) {
             throw e;
         } finally {
             IOUtils.closeQuietly(inStream);
         }
     }
 
     /**
      * Get the Magnolia system node created under the given node.
      *
      * @throws RepositoryException if failed to create system node
      */
     protected synchronized Node getSystemNode(Node node) throws RepositoryException {
         if (node.hasNode(SYSTEM_NODE)) {
             return node.getNode(SYSTEM_NODE);
         }
         return node.addNode(SYSTEM_NODE, NodeTypes.System.NAME);
     }
 }