/**
    * This file Copyright (c) 2012-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.dam.app.setup.migration;
  
  import info.magnolia.dam.api.ItemKey;
  import info.magnolia.dam.jcr.DamConstants;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.NodeVisitor;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  import javax.jcr.ItemNotFoundException;
  import javax.jcr.Node;
  import javax.jcr.Property;
  import javax.jcr.PropertyIterator;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.jackrabbit.core.id.NodeId;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This task is responsible for cleaning the content repository.<br>
   * Iterate the list of contentPathsList, get the related Node, and apply the
   * visitor to the Node tree.<br>
   * It use the {@link NodeVisitor} pattern. In order to define your own
   * NodeVisior, extend this migration task and override the addCustomVisitors()
   * protected method.<br>
   * 
   * <pre>
   * Implemented visitor:
   *   <B>CleanUpNodeVisitor</B>
   * Condition:
   *   Node must be of type mgnl:content or mgnl:page
   *    and
   *   must have one of the following property : image , video , flash , logoImg, printLogoImg --> index.
   * Action
   *  If the value of the property is an Identifier
   *  and Identifier is not linked to a DAM node
   *  remove it.
   *    <B>HandleDamLinkNodeVisitor</B>
   * Condition:
   *   Node must be of type mgnl:content or mgnl:page
   *    and
   *   must have the following property : link --> index.
   * Action
   *  If the value of the property is an Identifier
   *  and Identifier is linked to a DAM node
   *  Create a composite key.
   * </pre>
   **/
  public class CleanContentForDamMigrationTask extends AbstractCleanContentForDamMigrationTask {
  
      private static final Logger log = LoggerFactory.getLogger(CleanContentForDamMigrationTask.class);
  
      /**
       * Default constructor.
       */
      public CleanContentForDamMigrationTask(String taskName, String taskDescription, String contentRepository, List<String> contentPathsList) {
          super(taskName, taskDescription, contentRepository, contentPathsList);
      }
  
      /**
       * Override in order to add your custom visitors.
      */
     @Override
     protected List<NodeVisitor> addCustomVisitors() {
         List<NodeVisitor> visitorList = new ArrayList<NodeVisitor>();
         visitorList.add(createCleanUpNodeVisitor());
         visitorList.add(createHandleDamLinkNodeVisitor());
         return visitorList;
     }
 
     /**
      * Create the node property prefix used in the Clean Up Node visitor.
      * Used to filter Node properties and return only the properties part of the prefix list.
      * Current prefix defined:
      * image , video , flash , logoImg, printLogoImg, teaserImg.
      */
     protected String[] createCleanUpVisitorPrefixTable() {
         return new String[] { "image", "video", "flash", "logoImg", "printLogoImg", "teaserImg", "image_*", "video_*", "flash_*", "logoImg_*", "printLogoImg_*", "teaserImg_*" };
     }
 
     /**
      * prefix list : image , video , flash , logoImg, printLogoImg, teaserImg.
      * Condition:
      * node type = mgnl:component or mgnl:page
      * Action:
      * remove properties part of the prefix list found in the Node
      * if this property is an identifier and not linked to an DAM existing Node.
      */
     private NodeVisitor createCleanUpNodeVisitor() {
         NodeVisitor cleanUpVisitor = new NodeVisitor() {
             private String[] prefix = createCleanUpVisitorPrefixTable();
 
             @Override
             public void visit(Node node) throws RepositoryException {
                 if (NodeUtil.isNodeType(node, NodeTypes.Page.NAME) || NodeUtil.isNodeType(node, NodeTypes.Component.NAME)) {
                     PropertyIterator propertyIterator = node.getProperties(prefix);
                     while (propertyIterator.hasNext()) {
                         Property property = propertyIterator.nextProperty();
                         if (!StringUtils.contains(property.getName(), "_") || DamMigrationUtil.isPropertyNameI18nBased(property.getName())) {
                             // Take Action
                             cleanUpVisitorTakeAction(node, property);
                         }
                     }
                 }
             }
         };
         return cleanUpVisitor;
     }
 
     /**
      * Take action of the node property:
      * Check if the property value is a valid Identifier.
      * If it's an Identifier and not related to DAM, remove the property
      */
     private void cleanUpVisitorTakeAction(Node node, Property property) throws RepositoryException {
 
         try {
             // In case of it is not an Identifier, this will throw a IllegalArgumentException
             NodeId.valueOf(ItemKey.from(property.getString()).getAssetId());
             if (!damNodeExist(ItemKey.from(property.getString()).getAssetId())) {
                 log.warn("The property {} located under {} with value {} seems not to be related to an Identifier. This property will be removed.'",
                         Arrays.asList(property.getName(), property.getPath(), property.getString()));
                 property.remove();
             }
         } catch (IllegalArgumentException ie) {
             log.info("The property {} located under {} with value {} seems not to be related to an Identifier. This property will be keeped.'",
                     Arrays.asList(property.getName(), property.getPath(), property.getString()));
         }
     }
 
     /**
      * Condition:<br>
      * node type = mgnl:component or mgnl:page and has a property named link <br>
      * Action:<br>
      * create a composite id if this property is an identifier and linked to an
      * DAM existing Node.
      */
     private NodeVisitor createHandleDamLinkNodeVisitor() {
         NodeVisitor cleanUpVisitor = new NodeVisitor() {
             private String[] prefix = new String[] { "link", "link_*" };
 
             @Override
             public void visit(Node node) throws RepositoryException {
                 if (NodeUtil.isNodeType(node, NodeTypes.Page.NAME) || NodeUtil.isNodeType(node, NodeTypes.Component.NAME)) {
                     PropertyIterator propertyIterator = node.getProperties(prefix);
                     while (propertyIterator.hasNext()) {
                         Property property = propertyIterator.nextProperty();
                         if (!StringUtils.contains(property.getName(), "_") || DamMigrationUtil.isPropertyNameI18nBased(property.getName())) {
                             // Take Action
                             handleDamLinkVisitorTakeAction(node, property);
                         }
                     }
                 }
             }
         };
         return cleanUpVisitor;
     }
 
     /**
      * Take action of the node property:<br>
      * Check if the property value is a valid Identifier.<br>
      * If it's an Identifier and related to DAM, create a composite Id <br>
      */
     private void handleDamLinkVisitorTakeAction(Node node, Property property) throws RepositoryException {
 
         try {
             String damIdentifier = property.getString();
             // In case of it is not an Identifier, this will throw a
             // IllegalArgumentException
             NodeId.valueOf(damIdentifier);
             if (damNodeExist(damIdentifier)) {
                 log.info("The property {} located under {} with value {} is related to an DAM Identifier. This property will be Changed to a Composite ID.'",
                         Arrays.asList(property.getName(), property.getPath(), damIdentifier));
                 property.setValue(new ItemKey(DamConstants.DEFAULT_JCR_PROVIDER_ID, damIdentifier).asString());
             }
         } catch (IllegalArgumentException ie) {
             log.debug("The property {} located under {} with value {} seems not to be related to an Identifier. This property will be keeped.'",
                     Arrays.asList(property.getName(), property.getPath(), property.getString()));
         }
     }
 
     /**
      * Utility method.
      * Check if the identifier exist in the DAM repository.
      */
     private boolean damNodeExist(String identifier) {
         try {
             damSession.getNodeByIdentifier(identifier);
             return true;
         } catch (ItemNotFoundException infe) {
             log.debug("Following identifier not found in the DAM workspace " + identifier);
             return false;
         } catch (RepositoryException re) {
             log.warn("DamSession.getNodeByIdentifier({}) generated a RepositoryException.", identifier, re);
             return false;
         }
     }
 }