/**
    * 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.setup.for5_0;
  
  import info.magnolia.module.InstallContext;
  import info.magnolia.module.delta.AbstractRepositoryTask;
  import info.magnolia.module.delta.TaskExecutionException;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Set;
  
  import javax.jcr.NamespaceException;
  import javax.jcr.RepositoryException;
  import javax.jcr.nodetype.NodeTypeDefinition;
  import javax.jcr.nodetype.NodeTypeManager;
  import javax.jcr.nodetype.NodeTypeTemplate;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.core.nodetype.NodeTypeManagerImpl;
  import org.apache.jackrabbit.core.nodetype.NodeTypeRegistry;
  import org.apache.jackrabbit.spi.Name;
  import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Task allowing to register or un-register nodeTypes.
   * <br>
   * <br>
   * <b>For Registration</b>
   * <ul>
   *     <li>override {@link #getNodeTypesToRegister(NodeTypeManager)}.</li>
   *     <li>Every {@link NodeTypeDefinition} in the list will either be created if not present yet, otherwise the existing one will be updated.</li>
   * </ul>
   * <b>Warning:</b> Be careful with the order of the list of {@link NodeTypeDefinition}:<br>
   * Always put the parent NodeType or newly referenced NodeTypes first. For example, you may want to create a new NodeType A
   * that is referenced as super by an updated NodeType B, the list should be [A,B] so A is created before B. Otherwise,
   * A will not be updated. In this case, the NodeType A will not be registered and a warn log is displayed.
   * <br>
   * <br>
   * <b>For Un-registration</b>
   * <ul>
   *     <li>override {@link #getNodeTypesToUnregister(NodeTypeManager)}.</li>
   * </ul>
   * <b>Warning:</b> A NodeType will be unregistered only if no dependency issue is found<br>
   * Potential dependency issues:<br>
   * <ul>
   *     <li>NodeType is referenced as child node by one ore more other NodeType definitions</li>
   *     <li>NodeType is defined as super of one ore more other NodeType definitions</li>
   * </ul>
   * In this case, the NodeType will not be unregistered and a warn log is displayed.
   * <br>
   * <br>
   * <b>Note:</b>  Most of the custom implementation used in this task is due to jackrabbit not being able to update
   * NodeTypeDefinitions with non-trivial changes. Originally the intention was to keep it independent from jackrabbits API
   * as well, but in reality we are already heavily dependant on jackrabbit API.
   *
   */
  public abstract class AbstractNodeTypeRegistrationTask extends AbstractRepositoryTask {
  
      private final Logger log = LoggerFactory.getLogger(AbstractNodeTypeRegistrationTask.class);
  
      private String workspaceName;
  
     public AbstractNodeTypeRegistrationTask(String name, String description, String workspaceName) {
         super(name, description);
         this.workspaceName = workspaceName;
     }
 
     @Override
     protected void doExecute(InstallContext installContext) throws RepositoryException, TaskExecutionException {
         if (StringUtils.isBlank(workspaceName)) {
             log.warn("No workspace defined. This task will resume");
             return;
         }
 
         NodeTypeManager nodeTypeManager = installContext.getJCRSession(workspaceName).getWorkspace().getNodeTypeManager();
 
         // Register nodeTypes
         List<NodeTypeDefinition> nodeTypeToRegister = getNodeTypesToRegister(nodeTypeManager);
         if (nodeTypeToRegister == null || nodeTypeToRegister.isEmpty()) {
             log.info("No NodeType defined to register for the following workspace '{}'", workspaceName);
         } else {
             // exception not caught, installation will bail
             registerNodeTypes(nodeTypeManager, nodeTypeToRegister, installContext);
         }
         // Un-register nodeTypes
         List<String> nodeTypeToUnregister = getNodeTypesToUnregister(nodeTypeManager);
         if (nodeTypeToUnregister == null || nodeTypeToUnregister.isEmpty()) {
             log.info("No NodeType defined to unregister for the following workspace '{}'", workspaceName);
         } else {
             try {
                 unregisterNodeTypes(nodeTypeManager, nodeTypeToUnregister);
             } catch (RepositoryException e) {
                 installContext.warn("Un-registration of NodeTypes generated exceptions. NodeType will not be Unregistered. Please check the NodeType dependency.");
                 log.warn("Not able to un-register the following node type {}. The original definition is kept.", nodeTypeToUnregister, e);
             }
         }
 
     }
 
     /**
      * Get a List of {@link NodeTypeDefinition} to register or update (in case they are already created).
      */
     public abstract List<NodeTypeDefinition> getNodeTypesToRegister(NodeTypeManager nodeTypeManager) throws RepositoryException;
 
     /**
      * Get a List of {@link NodeTypeDefinition#getName()} to un-register.
      */
     public abstract List<String> getNodeTypesToUnregister(NodeTypeManager nodeTypeManager) throws RepositoryException;
 
     /**
      * Register a list of NodeTypes.
      *   <ul>
      *     <li>In case of new NodeType definition, simply register it.</li>
      *     <li>In case the NodeType definition already exist:
      *       <ul>
      *         <li>Get all NodeType definitions that have a dependency to the current definition.</li>
      *         <li>Un-register the complete list of dependent NodeTypes (including the current one).</li>
      *         <li>Re-Register the complete list of dependent NodeTypes, including the new NodeType definition.</li>
      *         <li>In case of exception, re register the original NodeType definition and including the dependencies  andlog the exception.</li>
      *       </ul>
      *     </li>
      *   </ul>
      */
     private void registerNodeTypes(NodeTypeManager nodeTypeManager, List<NodeTypeDefinition> nodeTypesToRegister, InstallContext installContext) throws RepositoryException {
         NodeTypeRegistry registry = ((NodeTypeManagerImpl) nodeTypeManager).getNodeTypeRegistry();
         NamePathResolver namePathResolver = ((NodeTypeManagerImpl) nodeTypeManager).getNamePathResolver();
         // Iterate the nodeTypeToRegister List
         for (NodeTypeDefinition nodeType : nodeTypesToRegister) {
             // NodeType already registered, Update (unregister, register)
             String nodeTypeName = nodeType.getName();
 
             if (nodeTypeManager.hasNodeType(nodeTypeName)) {
 
                 // Get the original NodeType definition. Useful in case of dependency issue (the original NodeType is re-registered in case of exception).
                 NodeTypeDefinition originalNodeType = nodeTypeManager.getNodeType(nodeTypeName);
 
                 // Get the list of NodeType that reference the current nodeType
                 Set<Name> dependentNodeTypeQNames = registry.getDependentNodeTypes(namePathResolver.getQName(nodeTypeName));
 
                 // we need the names
                 List<String> dependentNodeTypeNames = getNodeTypeNames(namePathResolver, dependentNodeTypeQNames);
 
                 // get definitions before we un-register them, to re-register them afterwards
                 List<NodeTypeDefinition> dependentNodeTypeDefinitions = getNodeTypeDefinitions(nodeTypeManager, dependentNodeTypeNames);
 
                 // UN-REGISTRATION
                 log.info("In order to register '{}', the following depending node types have to be unregistered first: {}.", nodeTypeName, dependentNodeTypeNames);
                 // the order does not matter
                 dependentNodeTypeNames.add(nodeTypeName);
                 unregisterNodeTypes(nodeTypeManager, dependentNodeTypeNames);
 
 
                 // RE-REGISTRATION
                 log.info("Registering {} and the following depending nodeTypes: {}", nodeTypeName, dependentNodeTypeQNames);
                 try {
                     registerNodeType(nodeTypeManager, nodeType);
                 } catch (RepositoryException e) {
                     // Register the previous version of the NodeType, if this fails the task will bail
                     registerNodeType(nodeTypeManager, originalNodeType);
                     String error = String.format("Registration (update of an existing NodeType) of the following NodeType generated exceptions '%s'. " +
                             "The original version of the definition is kept. Please check the NodeType dependency and the input list order.", nodeTypeName);
                     installContext.warn(error);
                     log.warn("Not able to register the following node type {}. The original definition is kept.", nodeTypeName, e);
                 }
 
                 for (NodeTypeDefinition nodeTypeDefinition : dependentNodeTypeDefinitions) {
                     try {
                         registerNodeType(nodeTypeManager, nodeTypeDefinition);
                     } catch (RepositoryException e) {
                         String error = String.format("Re-registration of the NodeType '%s' as a dependent nodeType of '%s' failed.", nodeTypeDefinition.getName(), nodeTypeName);
                         installContext.warn(error);
                         log.error(error, e);
                     }
                 }
 
             } else {
                 // NodeType is new, Create (register)
                 nodeTypeManager.registerNodeType(nodeType, false);
                 log.info("Registering new '{}' node type.", nodeTypeName);
             }
         }
     }
 
     /**
      * Register the {@link NodeTypeDefinition}.
      */
     private void registerNodeType(NodeTypeManager nodeTypeManager, NodeTypeDefinition nodeTypeDefinition) throws RepositoryException {
         // "transforming" each definition into a template, so that nodeTypeManager.registerNodeType doesn't barf unnecessary exceptions.
         final NodeTypeTemplate nodeTypeTemplate = nodeTypeManager.createNodeTypeTemplate(nodeTypeDefinition);
         log.debug("Registering the following '{}' node type.", nodeTypeTemplate.getName());
         nodeTypeManager.registerNodeType(nodeTypeTemplate, true);
     }
 
     /**
      * Un-register all nodeTypes passed as {@code nodeTypeNames}. Filter the list as the {@link NodeTypeManager#unregisterNodeTypes(String[])}
      * throws Exception if the nodeType is not registered.
      */
     private void unregisterNodeTypes(final NodeTypeManager nodeTypeManager, List<String> nodeTypeNames) throws RepositoryException {
         Iterator<String> it = nodeTypeNames.iterator();
         while(it.hasNext()) {
             String nodeTypeName = it.next();
             if (!nodeTypeManager.hasNodeType(nodeTypeName)) {
                 log.warn("Node type '{}' is not registered . No un-registration will be performed for this nodeType.", nodeTypeName);
                 it.remove();
             }
         }
 
         NodeTypeRegistry.disableCheckForReferencesInContentException = true;
         nodeTypeManager.unregisterNodeTypes(nodeTypeNames.toArray(new String[nodeTypeNames.size()]));
         log.info("Unregistered the following NodeTypes '{}'.", nodeTypeNames);
         NodeTypeRegistry.disableCheckForReferencesInContentException = false;
     }
 
     private List<NodeTypeDefinition> getNodeTypeDefinitions(NodeTypeManager nodeTypeManager, List<String> nodeTypeNames) throws RepositoryException {
         List<NodeTypeDefinition> nodeTypeDefinitions = new ArrayList<>();
         for (String ntn : nodeTypeNames) {
             nodeTypeDefinitions.add(nodeTypeManager.getNodeType(ntn));
         }
         return nodeTypeDefinitions;
     }
 
     /**
      * Transform a list of {@link NodeTypeDefinition}s to an array-list of their names.
      */
     private List<String> getNodeTypeNames(NamePathResolver namePathResolver, Set<Name> nodeTypeQNames) throws NamespaceException {
         List<String> names = new ArrayList<>();
 
         for (Name qName : nodeTypeQNames) {
             names.add(namePathResolver.getJCRName(qName));
         }
         return names;
     }
 
     /**
      * Create a Map containing all child NodeType of.<br>
      * - key = NodeType name.<br>
      * - value = {@link NodeTypeDefinition}.
      *
      * @deprecated since 5.4.3, use {@link NodeTypeRegistry#getDependentNodeTypes(Name)}. This function was added to keep
      * the implementation jackrabbit-API agnostic. But we already have jackrabbit dependencies in the passed params, so
      * it essentially is useless. Apart from that it was causing the migration to fail, as the returned Map did not retain
      * the order of the nodeTypes.
      */
     @Deprecated
     protected HashMap<String, NodeTypeDefinition> getDependentNodeTypes(NodeTypeDefinition nodeType, NodeTypeRegistry registry, NamePathResolver namePathResolver, NodeTypeManager nodeTypeManager) throws RepositoryException {
 
         HashMap<String, NodeTypeDefinition> dependentNodeType = new LinkedHashMap<String, NodeTypeDefinition>();
         // Get the Name in order to get the Dependent Node type
         Name qName = namePathResolver.getQName(nodeType.getName());
         Set<Name> dependentNodesName = registry.getDependentNodeTypes(qName);
         // for every dependent node type, call recursively in order to get all the dependency tree.
         if (dependentNodesName != null && !dependentNodesName.isEmpty()) {
             for (Name name : dependentNodesName) {
                 dependentNodeType.putAll(getDependentNodeTypes(nodeTypeManager.getNodeType(namePathResolver.getJCRName(name)), registry, namePathResolver, nodeTypeManager));
             }
         }
 
         dependentNodeType.put(nodeType.getName(), nodeType);
         return dependentNodeType;
 
     }
 }