/**
    * This file Copyright (c) 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.module.resources.setup;
  
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.module.InstallContext;
  import info.magnolia.module.delta.AbstractRepositoryTask;
  import info.magnolia.module.delta.Task;
  import info.magnolia.module.delta.TaskExecutionException;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.repository.RepositoryManager;
  import info.magnolia.resourceloader.Resource;
  import info.magnolia.resourceloader.ResourceOrigin;
  import info.magnolia.resourceloader.jcr.JcrResourceOrigin;
  import info.magnolia.resourceloader.layered.LayeredResource;
  import info.magnolia.resourceloader.layered.LayeredResourceOrigin;
  
  import java.io.IOException;
  import java.io.Reader;
  import java.util.Iterator;
  
  import javax.inject.Provider;
  import javax.jcr.Node;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.ObjectUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.commons.predicate.NodeTypePredicate;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Migrates all templates from <code>{@value #TEMPLATES_WORKSPACE}</code> to the
   * <code>{@value JcrResourceOrigin#RESOURCES_WORKSPACE}</code> workspace.
   *
   * <p>Templates will only be processed when they have the <code>{@value #PROPERTY_ENABLED}</code> property.</p>
   *
   * <p>When a template has <code>{@value #PROPERTY_AUTO_IMPORT}</code> set to <code>true</code> we check if there is an
   * existing resource in the {@link ResourceOrigin} and migrate the template if there is none. Otherwise no action is
   * taken.</p>
   *
   * <p>When a template has <code>{@value #PROPERTY_AUTO_IMPORT}</code> set to <code>false</code> we check whether there
   * is a hot-fixed version of that template in {@link JcrResourceOrigin#RESOURCES_WORKSPACE}. If there is, contents
   * are compared and when equal, no action is taken, otherwise this task will fail! If there is no hot-fix or no
   * resource what so ever, the template will be migrated.</p>
   */
  public class TemplateMigrationTask extends AbstractRepositoryTask {
  
      private static final Logger log = LoggerFactory.getLogger(TemplateMigrationTask.class);
  
      protected static final String TEMPLATES_WORKSPACE = "templates";
  
      protected static final String PROPERTY_AUTO_IMPORT = "autoImport";
      protected static final String PROPERTY_TEXT = "text";
      protected static final String PROPERTY_ENABLED = "enabled";
  
      private final Provider<ResourceOrigin> resourceOriginProvider;
  
      private Session templatesSession = null;
      private Session resourcesSession = null;
  
      private final Task onSuccess;
 
     public TemplateMigrationTask(Task onSuccess) {
         super("Migrates templates from 'templates' workspace", "Migrates templates from 'templates' workspace to 'resources' workspace");
 
         this.resourceOriginProvider = new Provider<ResourceOrigin>() {
             @Override
             public ResourceOrigin get() {
                 return Components.getComponent(ResourceOrigin.class);
             }
         };
 
         this.onSuccess = onSuccess;
     }
 
     public TemplateMigrationTask() {
         this(null);
     }
 
     @Override
     protected void doExecute(InstallContext installContext) throws RepositoryException, TaskExecutionException {
         final RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class);
         String infoMessage = null;
         if (repositoryManager.hasWorkspace(TEMPLATES_WORKSPACE)) {
             try {
                 templatesSession = installContext.getJCRSession(TEMPLATES_WORKSPACE);
             } catch (RepositoryException e) {
                 infoMessage = String.format("Could not get session for workspace '%s'. " +
                         "Not running template migration task.", TEMPLATES_WORKSPACE);
             }
         } else {
             infoMessage = String.format("Inplace-templating might not be installed. Not running template migration task.");
         }
 
         if (infoMessage != null) {
             installContext.info(infoMessage);
             log.info(infoMessage);
 
             // We won't exit here as there might be an onSuccessTask to be executed below. Not having to do anything
             // with the templates workspace doesn't mean we are done yet.
         }
 
         if (templatesSession != null) {
             resourcesSession = installContext.getJCRSession(JcrResourceOrigin.RESOURCES_WORKSPACE);
 
             final LayeredResourceOrigin resourceOrigin = (LayeredResourceOrigin) resourceOriginProvider.get();
 
             final Iterator<Node> nodeIterator = NodeUtil.collectAllChildren(templatesSession.getRootNode(),
                     new NodeTypePredicate(NodeTypes.Content.NAME, false)).iterator();
 
             while (nodeIterator.hasNext()) {
                 final Node templateNode = nodeIterator.next();
 
                 // We consider no enabled property to be equal to enabled=false
                 // All templates used to be considered as disabled, also see deprecated
                 // info.magnolia.module.inplacetemplating.JcrRepoTemplateLoader
                 final boolean enabled = templateNode.hasProperty(PROPERTY_ENABLED) && templateNode.getProperty(PROPERTY_ENABLED).getBoolean();
                 if (!enabled) {
                     continue;
                 }
 
                 // We consider no autoImport property to be equal to autoImport=false
                 final boolean autoImport = templateNode.hasProperty(PROPERTY_AUTO_IMPORT) && templateNode.getProperty(PROPERTY_AUTO_IMPORT).getBoolean();
 
                 try {
 
                     final String resourceTemplatePath = templateNode.getPath() + ".ftl";
 
                     // autoImport=true means we can safely override edited resources
                     // autoImport=false means we cannot
                     if (autoImport) {
                         if (!resourceOrigin.hasPath(resourceTemplatePath)) {
                             // Template doesn't exists in resource origin so we can migrate it
                             migrateTemplate(templateNode, resourceTemplatePath);
                         }
                     } else {
                         // When template exists in resource origin check whether it was 'hot-fixed' or not
                         if (resourceOrigin.hasPath(resourceTemplatePath)) {
                             final LayeredResource resource = resourceOrigin.getByPath(resourceTemplatePath);
 
                             // When there is a hot-fixed resource
                             if (resource.getFirst().getOrigin() instanceof JcrResourceOrigin) {
                                 // Compare contents
                                 if (!templateEqualsResource(templateNode, resource)) {
                                     // There is no way we can handle this scenario:
                                     // autoImport=false (i.e. do not override) but the very same template exists in jcr
                                     // resource origin with different content!
                                     throw new TaskExecutionException(String.format("Contents of '%s:%s' and resource '%s:%s' were not equal but autoImport was set to 'false'. " +
                                                     "Cannot proceed with template migration.", TEMPLATES_WORKSPACE, resourceTemplatePath,
                                             JcrResourceOrigin.RESOURCES_WORKSPACE, resource.getPath()));
                                 }
                                 // Otherwise do nothing with template; it's already in jcr with the same content
                                 // why bother migrating it...!?
                             } else {
                                 // No jcr hotfix available means we can safely migrate
                                 migrateTemplate(templateNode, resourceTemplatePath);
                             }
                         } else {
                             // No resource available at all also means we can safely migrate the template to jcr
                             migrateTemplate(templateNode, resourceTemplatePath);
                         }
                     }
 
                 } catch (RepositoryException e) {
                     log.info("An error occurred when handling template '{}:{}'. Will not migrate this template.",
                             TEMPLATES_WORKSPACE, NodeUtil.getPathIfPossible(templateNode), e);
                 }
             }
 
         }
 
         // If we reach this point, no errors have happened!
         // Any additional task given, will now be executed...
         if (onSuccess != null) {
             onSuccess.execute(installContext);
         }
     }
 
     /**
      * Compares the template contents of a {@link Node} from <code>{@value #TEMPLATES_WORKSPACE}</code> workspace and a
      * {@link Resource} from {@link ResourceOrigin}. Both contents being {@code null} are considered equal.
      */
     private boolean templateEqualsResource(final Node templateNode, final Resource resource) {
         try (final Reader reader = resource.openReader()) {
             final String contentResource = IOUtils.toString(reader);
             final String contentTemplate = PropertyUtil.getString(templateNode, PROPERTY_TEXT, null);
 
             return ObjectUtils.equals(contentResource, contentTemplate);
         } catch (IOException e) {
             log.error("Cannot read contents of '{}:{}'.", resource.getOrigin().getName(), resource.getName(), e);
         }
 
         return false;
     }
 
     /**
      * Copies the template {@link Node} to the {@value JcrResourceOrigin#RESOURCES_WORKSPACE} workspace. Also creates
      * parent folders if necessary.
      */
     private void migrateTemplate(final Node templateNode, final String newTemplatePath) throws RepositoryException {
         final String parentPath = StringUtils.substringBeforeLast(newTemplatePath, "/");
         if (StringUtils.isNotBlank(parentPath) && !resourcesSession.nodeExists(parentPath)) {
             NodeUtil.createPath(resourcesSession.getRootNode(), parentPath, NodeTypes.Folder.NAME);
 
             log.info("Created path '{}:{}'.", JcrResourceOrigin.RESOURCES_WORKSPACE, parentPath);
         }
 
         copyTemplateNode(templateNode, newTemplatePath);
 
         log.info("Migrated template '{}:{}' to '{}:{}'.", TEMPLATES_WORKSPACE, NodeUtil.getPathIfPossible(templateNode),
                 JcrResourceOrigin.RESOURCES_WORKSPACE, newTemplatePath);
     }
 
     /**
      * Copies {@link Node} to destination <code>newTemplatePath</code> and also copies all properties (except
      * properties suffixed with <code>{@value NodeTypes#REP_PREFIX}</code> or
      * <code>{@value NodeTypes#JCR_PREFIX}</code>) without saving the session.
      *
      * <p>Note: {@link javax.jcr.Workspace#clone(String, String, String, boolean)} or
      * {@link javax.jcr.Workspace#copy(String, String, String)} would have needed the parent folders to be persisted
      * ({@link Session#save()}) which is not desired in {@link info.magnolia.module.delta.Task}s!</p>
      */
     private void copyTemplateNode(final Node templateNode, final String newTemplatePath) throws RepositoryException {
         final Node newTemplateNode = NodeUtil.createPath(resourcesSession.getRootNode(), newTemplatePath, NodeTypes.Content.NAME);
         final PropertyIterator propertyIterator = templateNode.getProperties();
 
         while (propertyIterator.hasNext()) {
             final Property property = propertyIterator.nextProperty();
             final String propertyName = property.getName();
 
             // We do not migrate property enabled
             if (PROPERTY_ENABLED.equals(propertyName)) {
                 continue;
             }
 
             // Properties prefixed with jcr:/rep: should not be migrated
             if (propertyName.startsWith(NodeTypes.REP_PREFIX) || propertyName.startsWith(NodeTypes.JCR_PREFIX)) {
                 continue;
             }
 
             // We want to maintain the last modified date/actor of above, new node
             // Creation date/actor will be migrated
             if (NodeTypes.LastModified.LAST_MODIFIED.equals(propertyName) || NodeTypes.LastModified.LAST_MODIFIED_BY.equals(propertyName)) {
                 continue;
             }
 
             // We also do not want to copy properties related to activation. This makes sure the new nodes do not have
             // the activation status + information until they are indeed properly activated.
             // This is also "in-sync" with potentially created parent folders that have the not-activated status.
             if (NodeTypes.Activatable.LAST_ACTIVATED.equals(propertyName) || NodeTypes.Activatable.LAST_ACTIVATED_BY.equals(propertyName) ||
                     NodeTypes.Activatable.ACTIVATION_STATUS.equals(propertyName)) {
                 continue;
             }
 
             newTemplateNode.setProperty(propertyName, property.getValue());
         }
     }
 
 }