/**
    * This file Copyright (c) 2011 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.templating.functions;
  
  import info.magnolia.cms.beans.config.ServerConfiguration;
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.cms.core.MetaData;
  import info.magnolia.cms.core.MgnlNodeType;
  import info.magnolia.cms.core.NodeData;
  import info.magnolia.cms.i18n.I18nContentSupportFactory;
  import info.magnolia.cms.util.ContentUtil;
  import info.magnolia.cms.util.QueryUtil;
  import info.magnolia.cms.util.SiblingsHelper;
  import info.magnolia.jcr.inheritance.InheritanceNodeWrapper;
  import info.magnolia.jcr.util.ContentMap;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.util.SessionUtil;
  import info.magnolia.jcr.wrapper.HTMLEscapingNodeWrapper;
  import info.magnolia.link.LinkUtil;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.rendering.template.configured.ConfiguredInheritance;
  import info.magnolia.repository.RepositoryConstants;
  import info.magnolia.templating.inheritance.DefaultInheritanceContentDecorator;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  import javax.jcr.Node;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Property;
  import javax.jcr.PropertyType;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * An object exposing several methods useful for templates. It is exposed in templates as <code>cmsfn</code>.
   *
   * @version $Id$
   */
  public class TemplatingFunctions {
  
      private static final Logger log = LoggerFactory.getLogger(TemplatingFunctions.class);
  
      private final Provider<AggregationState> aggregationStateProvider;
  
      //TODO: To review with Philipp. Should not use Provider, but has deep impact on CategorizationSupportImpl PageSyndicator CategorySyndicator....
      @Inject
      public TemplatingFunctions(Provider<AggregationState> aggregationStateProvider) {
          this.aggregationStateProvider = aggregationStateProvider;
      }
  
  
      public Node asJCRNode(ContentMap contentMap) {
          return contentMap == null ? null : contentMap.getJCRNode();
      }
  
      public ContentMap asContentMap(Node content) {
          return content == null ? null : new ContentMap(content);
      }
  
      public List<Node> children(Node content) throws RepositoryException {
         return content == null ? null : asNodeList(NodeUtil.getNodes(content, NodeUtil.EXCLUDE_META_DATA_FILTER));
     }
 
     public List<Node> children(Node content, String nodeTypeName) throws RepositoryException {
         return content == null ? null : asNodeList(NodeUtil.getNodes(content, nodeTypeName));
     }
 
     public List<ContentMap> children(ContentMap content) throws RepositoryException {
         return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), NodeUtil.EXCLUDE_META_DATA_FILTER));
     }
 
     public List<ContentMap> children(ContentMap content, String nodeTypeName) throws RepositoryException {
         return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), nodeTypeName));
     }
 
     public ContentMap root(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode()));
     }
 
     public ContentMap root(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode(), nodeTypeName));
     }
 
     public Node root(Node content) throws RepositoryException {
         return this.root(content, null);
     }
 
     public Node root(Node content, String nodeTypeName) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (nodeTypeName == null) {
             return (Node) content.getAncestor(0);
         }
         if (isRoot(content) && content.isNodeType(nodeTypeName)) {
             return content;
         }
 
         Node parentNode = this.parent(content, nodeTypeName);
         while (parent(parentNode, nodeTypeName) != null) {
             parentNode = this.parent(parentNode, nodeTypeName);
         }
         return parentNode;
     }
 
     public ContentMap parent(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode()));
     }
 
     public ContentMap parent(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode(), nodeTypeName));
     }
 
     public Node parent(Node content) throws RepositoryException {
         return this.parent(content, null);
     }
 
     public Node parent(Node content, String nodeTypeName) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (isRoot(content)) {
             return null;
         }
         if (nodeTypeName == null) {
             return content.getParent();
         }
         Node parent = content.getParent();
         while (!parent.isNodeType(nodeTypeName)) {
             if (isRoot(parent)) {
                 return null;
             }
             parent = parent.getParent();
         }
         return parent;
     }
 
     /**
      * Returns the page's {@link ContentMap} of the passed {@link ContentMap}. If the passed {@link ContentMap} represents a page, the passed {@link ContentMap} will be returned.
      * If the passed {@link ContentMap} has no parent page at all, null is returned.
      *
      * @param content the {@link ContentMap} to get the page's {@link ContentMap} from.
      * @return returns the page {@link ContentMap} of the passed content {@link ContentMap}.
      * @throws RepositoryException
      */
     public ContentMap page(ContentMap content) throws RepositoryException {
         return content == null ? null : asContentMap(page(content.getJCRNode()));
     }
 
     /**
      * Returns the page {@link Node} of the passed node. If the passed {@link Node} is a page, the passed {@link Node} will be returned.
      * If the passed Node has no parent page at all, null is returned.
      *
      * @param content the {@link Node} to get the page from.
      * @return returns the page {@link Node} of the passed content {@link Node}.
      * @throws RepositoryException
      */
     public Node page(Node content) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (content.isNodeType(MgnlNodeType.NT_PAGE)) {
             return content;
         }
         return parent(content, MgnlNodeType.NT_PAGE);
     }
 
     public List<ContentMap> ancestors(ContentMap contentMap) throws RepositoryException {
         return ancestors(contentMap, null);
     }
 
     public List<ContentMap> ancestors(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         List<Node> ancestorsAsNodes = this.ancestors(contentMap.getJCRNode(), nodeTypeName);
         return asContentMapList(ancestorsAsNodes);
     }
 
     public List<Node> ancestors(Node content) throws RepositoryException {
         return content == null ? null : this.ancestors(content, null);
     }
 
     public List<Node> ancestors(Node content, String nodeTypeName) throws RepositoryException {
         if (content == null) {
             return null;
         }
         List<Node> ancestors = new ArrayList<Node>();
         int depth = content.getDepth();
         for (int i = 1; i < depth; ++i) {
             Node possibleAncestor = (Node) content.getAncestor(i);
             if (nodeTypeName == null) {
                 ancestors.add(possibleAncestor);
             } else {
                 if (possibleAncestor.isNodeType(nodeTypeName)) {
                     ancestors.add(possibleAncestor);
                 }
             }
         }
         return ancestors;
     }
 
     public Node inherit(Node content) throws RepositoryException {
         return inherit(content, null);
     }
 
     public Node inherit(Node content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         Node inheritedNode = wrapForInheritance(content);
 
         if (StringUtils.isBlank(relPath)) {
             return inheritedNode;
         }
 
         try {
             Node subNode = inheritedNode.getNode(relPath);
             return NodeUtil.unwrap(subNode);
         } catch (PathNotFoundException e) {
             // TODO fgrilli: rethrow exception?
         }
         return null;
     }
 
     public ContentMap inherit(ContentMap content) throws RepositoryException {
         return inherit(content, null);
     }
 
     public ContentMap inherit(ContentMap content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         Node node = inherit(content.getJCRNode(), relPath);
         return node == null ? null : new ContentMap(node);
     }
 
 
     public Property inheritProperty(Node content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (StringUtils.isBlank(relPath)) {
             throw new IllegalArgumentException("relative path cannot be null or empty");
         }
         try {
             Node inheritedNode = wrapForInheritance(content);
             return inheritedNode.getProperty(relPath);
 
         } catch (PathNotFoundException e) {
             // TODO fgrilli: rethrow exception?
         } catch (RepositoryException e) {
             // TODO fgrilli:rethrow exception?
         }
 
         return null;
     }
 
     public Property inheritProperty(ContentMap content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         return inheritProperty(content.getJCRNode(), relPath);
     }
 
     public List<Node> inheritList(Node content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (StringUtils.isBlank(relPath)) {
             throw new IllegalArgumentException("relative path cannot be null or empty");
         }
         Node inheritedNode = wrapForInheritance(content);
         Node subNode = inheritedNode.getNode(relPath);
         return children(subNode);
     }
 
     public List<ContentMap> inheritList(ContentMap content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         if (StringUtils.isBlank(relPath)) {
             throw new IllegalArgumentException("relative path cannot be null or empty");
         }
         Node node = asJCRNode(content);
         Node inheritedNode = wrapForInheritance(node);
         Node subNode = inheritedNode.getNode(relPath);
         return children(new ContentMap(subNode));
     }
 
     public boolean isInherited(Node content) {
         if (content instanceof InheritanceNodeWrapper) {
             return ((InheritanceNodeWrapper) content).isInherited();
         }
         return false;
     }
 
     public boolean isInherited(ContentMap content) {
         return isInherited(asJCRNode(content));
     }
 
     public boolean isFromCurrentPage(Node content) {
         return !isInherited(content);
     }
 
     public boolean isFromCurrentPage(ContentMap content) {
         return isFromCurrentPage(asJCRNode(content));
     }
 
     /**
      * Create link for the Node identified by nodeIdentifier in the specified workspace.
      */
     public String link(String workspace, String nodeIdentifier) {
         try {
             return LinkUtil.createLink(workspace, nodeIdentifier);
         } catch (RepositoryException e) {
             return null;
         }
     }
 
     /**
      * There should be no real reason to use this method except to produce link to binary content stored in jcr:data property in which case one should call {@link #link(Node)} while passing parent node as a parameter. In case you find other valid reason to use this method, please raise it in a forum discussion or create issue. Otherwise this method will be removed in the future.
      * 
      * @deprecated since 4.5.4. There is no valid use case for this method.
      */
     @Deprecated
     public String link(Property property) {
         try {
             Node parentNode = null;
             String propertyName = null;
             if (property.getType() == PropertyType.BINARY) {
                 parentNode = property.getParent().getParent();
                 propertyName = property.getParent().getName();
             } else {
                 parentNode = property.getParent();
                 propertyName = property.getName();
             }
             NodeData equivNodeData = ContentUtil.asContent(parentNode).getNodeData(propertyName);
             return LinkUtil.createLink(equivNodeData);
         } catch (Exception e) {
             return null;
         }
     }
 
     // TODO fgrilli: LinkUtil needs to be Node capable and not only Content. Switch to node based impl when SCRUM-242
     // will be done.
     public String link(Node content) {
         return content == null ? null : LinkUtil.createLink(ContentUtil.asContent(content));
     }
 
     public String link(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : this.link(asJCRNode(contentMap));
     }
 
     /**
      * Get the language used currently.
      * @return The language as a String.
      */
     public String language(){
         return I18nContentSupportFactory.getI18nSupport().getLocale().toString();
     }
     /**
      * Returns an external link prepended with <code>http://</code> in case the protocol is missing or an empty String
      * if the link does not exist.
      *
      * @param content The node where the link property is stored on.
      * @param linkPropertyName The property where the link value is stored in.
      * @return The link prepended with <code>http://</code>
      */
     public String externalLink(Node content, String linkPropertyName) {
         String externalLink = PropertyUtil.getString(content, linkPropertyName);
         if (StringUtils.isBlank(externalLink)) {
             return StringUtils.EMPTY;
         }
         if (!hasProtocol(externalLink)) {
             externalLink = "http://" + externalLink;
         }
         return externalLink;
     }
 
     /**
      * Returns an external link prepended with <code>http://</code> in case the protocol is missing or an empty String
      * if the link does not exist.
      *
      * @param content The node's map representation where the link property is stored on.
      * @param linkPropertyName The property where the link value is stored in.
      * @return The link prepended with <code>http://</code>
      */
     public String externalLink(ContentMap content, String linkPropertyName) {
         return externalLink(asJCRNode(content), linkPropertyName);
     }
 
     /**
      * Return a link title based on the @param linkTitlePropertyName. When property @param linkTitlePropertyName is
      * empty or null, the link itself is provided as the linkTitle (prepended with <code>http://</code>).
      *
      * @param content The node where the link property is stored on.
      * @param linkPropertyName The property where the link value is stored in.
      * @param linkTitlePropertyName The property where the link title value is stored
      * @return the resolved link title value
      */
     public String externalLinkTitle(Node content, String linkPropertyName, String linkTitlePropertyName) {
         String linkTitle = PropertyUtil.getString(content, linkTitlePropertyName);
         if (StringUtils.isNotEmpty(linkTitle)) {
             return linkTitle;
         }
         return externalLink(content, linkPropertyName);
     }
 
     /**
      * Return a link title based on the @param linkTitlePropertyName. When property @param linkTitlePropertyName is
      * empty or null, the link itself is provided as the linkTitle (prepended with <code>http://</code>).
      *
      * @param content The node where the link property is stored on.
      * @param linkPropertyName The property where the link value is stored in.
      * @param linkTitlePropertyName The property where the link title value is stored
      * @return the resolved link title value
      */
     public String externalLinkTitle(ContentMap content, String linkPropertyName, String linkTitlePropertyName) {
         return externalLinkTitle(asJCRNode(content), linkPropertyName, linkTitlePropertyName);
     }
 
     public boolean isEditMode() {
         // TODO : see CmsFunctions.isEditMode, which checks a couple of other properties.
         return isAuthorInstance() && !isPreviewMode();
     }
 
     public boolean isPreviewMode() {
         return this.aggregationStateProvider.get().isPreviewMode();
     }
 
     public boolean isAuthorInstance() {
         return Components.getComponent(ServerConfiguration.class).isAdmin();
     }
 
     public boolean isPublicInstance() {
         return !isAuthorInstance();
     }
 
     /**
      * Util method to create html attributes <code>name="value"</code>. If the value is empty an empty string will be returned.
      * This is mainly helpful to avoid empty attributes.
      */
     public String createHtmlAttribute(String name, String value) {
         value = StringUtils.trim(value);
         if (StringUtils.isNotEmpty(value)) {
             return new StringBuffer().append(name).append("=\"").append(value).append("\"").toString();
         }
         return StringUtils.EMPTY;
     }
 
     /**
      * Returns an instance of SiblingsHelper for the given node.
      */
     public SiblingsHelper siblings(Node node) throws RepositoryException {
         return SiblingsHelper.of(ContentUtil.asContent(node));
     }
 
     public SiblingsHelper siblings(ContentMap node) throws RepositoryException {
         return siblings(asJCRNode(node));
     }
 
     /**
      * Return the Node for the Given Path
      * from the website repository.
      */
     public Node content(String path){
         return content(RepositoryConstants.WEBSITE, path);
     }
 
     /**
      * Return the Node for the Given Path
      * from the given repository.
      */
     public Node content(String repository, String path){
         return SessionUtil.getNode(repository, path);
     }
 
     /**
      * Return the Node by the given identifier
      * from the website repository.
      */
     public Node contentByIdentifier(String id){
         return contentByIdentifier(RepositoryConstants.WEBSITE, id);
     }
 
     /**
     * Return the Node by the given identifier
     * from the given repository.
     */
     public Node contentByIdentifier(String repository, String id){
         return SessionUtil.getNodeByIdentifier(repository, id);
     }
 
     public List<ContentMap> asContentMapList(Collection<Node> nodeList) {
         if (nodeList != null) {
             List<ContentMap> contentMapList = new ArrayList<ContentMap>();
             for (Node node : nodeList) {
                 contentMapList.add(asContentMap(node));
             }
             return contentMapList;
         }
         return null;
     }
 
     public List<Node> asNodeList(Collection<ContentMap> contentMapList) {
         if (contentMapList != null) {
             List<Node> nodeList = new ArrayList<Node>();
             for (ContentMap node : contentMapList) {
                 nodeList.add(node.getJCRNode());
             }
             return nodeList;
         }
         return null;
     }
 
     // TODO fgrilli: should we unwrap children?
     protected List<Node> asNodeList(Iterable<Node> nodes) {
         List<Node> childList = new ArrayList<Node>();
         for (Node child : nodes) {
             childList.add(child);
         }
         return childList;
     }
 
     // TODO fgrilli: should we unwrap children?
     protected List<ContentMap> asContentMapList(Iterable<Node> nodes) {
         List<ContentMap> childList = new ArrayList<ContentMap>();
         for (Node child : nodes) {
             childList.add(new ContentMap(child));
         }
         return childList;
     }
 
     /**
      * Checks if passed string has a <code>http://</code> protocol.
      *
      * @param link The link to check
      * @return If @param link contains a <code>http://</code> protocol
      */
     private boolean hasProtocol(String link) {
         return link != null && link.contains("://");
     }
 
     /**
      * Checks if the passed {@link Node} is the jcr root '/' of the workspace.
      * @param content {@link Node} to check if its root.
      * @return if @param content is the jcr workspace root.
      * @throws RepositoryException
      */
     private boolean isRoot(Node content) throws RepositoryException {
         return content.getDepth() == 0;
     }
 
     /**
      * Removes escaping of HTML on properties.
      */
     public ContentMap decode(ContentMap content){
         return asContentMap(decode(content.getJCRNode()));
     }
 
     /**
      * Removes escaping of HTML on properties.
      */
     public Node decode(Node content){
         return NodeUtil.deepUnwrap(content, HTMLEscapingNodeWrapper.class);
     }
 
     /**
      * Adds escaping of HTML on properties as well as changing line breaks into &lt;br/&gt; tags.
      */
     public Node encode(Node content){
         return content != null ? new HTMLEscapingNodeWrapper(content, true) : null;
     }
 
     private Node wrapForInheritance(Node destination) throws RepositoryException {
         ConfiguredInheritance inheritanceConfiguration = new ConfiguredInheritance();
         inheritanceConfiguration.setEnabled(true);
         return new DefaultInheritanceContentDecorator(destination, inheritanceConfiguration).wrapNode(destination);
     }
 
     /**
      * Returns the string representation of a property from the metaData of the node or <code>null</code> if the node has no Magnolia metaData or if no matching property is found.
      */
     public String metaData(Node content, String property){
         try {
             if(content.hasNode(MetaData.DEFAULT_META_NODE)){
                 Node node = content.getNode(MetaData.DEFAULT_META_NODE);
                 if(node.hasProperty(property)) {
                     return PropertyUtil.getPropertyOrNull(node, property).getString();
                 } else if(node.hasProperty(RepositoryConstants.NAMESPACE_PREFIX + ":" + property)) {
                     return PropertyUtil.getPropertyOrNull(node, RepositoryConstants.NAMESPACE_PREFIX + ":" + property).getString();
                 }
             }
         } catch (RepositoryException e) {
             throw new RuntimeException(e);
         }
         return null;
     }
 
     /**
      * @see {@link TemplatingFunctions#metaData(Node, String)}.
      */
     public String metaData(ContentMap content, String property){
         return metaData(content.getJCRNode(), property);
     }
     
     /**
      * Executes query and returns result as Collection of Nodes.
      * 
      * @param workspace
      * @param statement has to be in formal form for chosen language
      * @param language
      * @param returnItemType
      */
     public Collection<Node> search(String workspace, String statement, String language, String returnItemType){
         try {
             return NodeUtil.getCollectionFromNodeIterator(QueryUtil.search(workspace, statement, language, returnItemType));
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
         return null;
     }
     
     /**
      * Executes simple SQL2 query and returns result as Collection of Nodes.
      * 
      * @param workspace
      * @param statement should be set of labels target has to contain inserted as one string each separated by comma
      * @param returnItemType
      * @param startPath can be inserted, for results without limitation set it to slash
      */
     public Collection<Node> simpleSearch(String workspace, String statement, String returnItemType, String startPath){
         if(StringUtils.isEmpty(statement)){
             log.error("Cannot search with empty statement.");
             return null;
         }
         String query = QueryUtil.buildQuery(statement, startPath);
         try {
             return NodeUtil.getCollectionFromNodeIterator(QueryUtil.search(workspace, query, "JCR-SQL2", returnItemType));
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
         return null;
     }
 }