/**
    * This file Copyright (c) 2011-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.rendering.template.configured;
  
  import info.magnolia.jcr.RuntimeRepositoryException;
  import info.magnolia.jcr.predicate.AbstractPredicate;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.rendering.template.InheritanceConfiguration;
  
  import java.util.Comparator;
  
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  
  /**
   * Defines behavior for inheritance. Allows for enabling
   */
  public class ConfiguredInheritance implements InheritanceConfiguration {
  
      public static final String COMPONENTS_ALL = "all";
      public static final String COMPONENTS_NONE = "none";
      public static final String COMPONENTS_FILTERED = "filtered";
  
      public static final String PROPERTIES_ALL = "all";
      public static final String PROPERTIES_NONE = "none";
  
      private Boolean enabled = false;
      private String components = COMPONENTS_FILTERED;
      private String properties = PROPERTIES_ALL;
      private Class<? extends AbstractPredicate<Node>> predicateClass;
      private Class<? extends Comparator<Node>> nodeComparatorClass;
  
      @Override
      public Boolean isEnabled() {
          return enabled;
      }
  
      public void setEnabled(Boolean enabled) {
          this.enabled = enabled;
      }
  
      public void setComponents(String components) {
          this.components = components;
      }
  
      public void setProperties(String properties) {
          this.properties = properties;
      }
  
      @Override
      public Boolean isInheritsProperties() {
          return isEnabled() != null && isEnabled() && StringUtils.equalsIgnoreCase(StringUtils.trim(properties), PROPERTIES_ALL);
      }
  
      @Override
      public Boolean isInheritsComponents() {
          return isEnabled() != null && isEnabled() && (StringUtils.equalsIgnoreCase(StringUtils.trim(components), COMPONENTS_ALL) || StringUtils.equalsIgnoreCase(StringUtils.trim(components), COMPONENTS_FILTERED));
      }
  
      @Override
      public AbstractPredicate<Node> getComponentPredicate() {
          if (isEnabled() == null || !isEnabled()) {
              return new InheritNothingInheritancePredicate();
         }
         if (predicateClass != null) {
             return Components.newInstance(predicateClass);
         }
         if (StringUtils.equalsIgnoreCase(StringUtils.trim(components), COMPONENTS_ALL)) {
             return new AllComponentsAndResourcesInheritancePredicate();
         }
         if (StringUtils.equalsIgnoreCase(StringUtils.trim(components), COMPONENTS_FILTERED)) {
             return new FilteredComponentInheritancePredicate();
         }
         return new InheritNothingInheritancePredicate();
     }
 
     public void setPredicateClass(Class<? extends AbstractPredicate<Node>> predicateClass) {
         this.predicateClass = predicateClass;
     }
 
     @Override
     public Comparator<Node> getComponentComparator() {
         if (nodeComparatorClass != null) {
             return Components.newInstance(nodeComparatorClass);
         }
         return new NodeDepthComparator();
     }
 
     public void setNodeComparatorClass(Class<? extends Comparator<Node>> nodeComparatorClass) {
         this.nodeComparatorClass = nodeComparatorClass;
     }
 
     /**
      * Predicate for component inheritance that includes only nodes with a a property named 'inheritable' that needs to
      * be present and set to 'true'.
      */
     public static class FilteredComponentInheritancePredicate extends AbstractPredicate<Node> {
 
         public static final String INHERITED_PROPERTY_NAME = "inheritable";
 
         @Override
         public boolean evaluateTyped(Node node) {
             try {
                 return NodeUtil.isNodeType(node, NodeTypes.Component.NAME) && (node.hasProperty(INHERITED_PROPERTY_NAME) && Boolean.parseBoolean(node.getProperty(INHERITED_PROPERTY_NAME).getString()));
             } catch (RepositoryException e) {
                 throw new RuntimeRepositoryException(e);
             }
         }
     }
 
     /**
      * Predicate for component inheritance that includes all components.
      */
     public static class AllComponentsAndResourcesInheritancePredicate extends AbstractPredicate<Node> {
 
         @Override
         public boolean evaluateTyped(Node node) {
             try {
                 return NodeUtil.isNodeType(node, NodeTypes.Component.NAME) || NodeUtil.isNodeType(node, NodeTypes.Resource.NAME);
             } catch (RepositoryException e) {
                 throw new RuntimeRepositoryException(e);
             }
         }
     }
 
     /**
      * Predicate for component inheritance that includes no components.
      */
     public static class InheritNothingInheritancePredicate extends AbstractPredicate<Node> {
 
         @Override
         public boolean evaluateTyped(Node node) {
             return false;
         }
     }
 
     /**
      * Comparator for ordering nodes by depth placing nodes deeper in the hierarchy after those further up and ordering
      * nodes on the same level by the order they appear as siblings.
      */
     public static class NodeDepthComparator implements Comparator<Node> {
 
         @Override
         public int compare(Node lhs, Node rhs) {
             try {
                 if (lhs.getDepth() != rhs.getDepth())
                     return lhs.getDepth() - rhs.getDepth();
                 return getSiblingIndex(lhs) - getSiblingIndex(rhs);
             } catch (RepositoryException e) {
                 throw new RuntimeRepositoryException(e);
             }
         }
 
         private int getSiblingIndex(Node node) throws RepositoryException {
             if (node.getDepth() == 0) {
                 return 0;
             }
             int index = 0;
             NodeIterator nodes = node.getParent().getNodes();
             while (nodes.hasNext()) {
                 if (NodeUtil.isSame(node, nodes.nextNode())) {
                     return index;
                 }
                 index++;
             }
             return -1;
         }
     }
 }