/**
    * This file Copyright (c) 2008-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.module.templatingkit.functions;
  
  import info.magnolia.cms.util.ContentUtil;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.jcr.RuntimeRepositoryException;
  import info.magnolia.jcr.util.ContentMap;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.wrapper.I18nNodeWrapper;
  import info.magnolia.module.templatingkit.STKModule;
  import info.magnolia.module.templatingkit.categorization.CategorizationSupport;
  import info.magnolia.module.templatingkit.dam.Asset;
  import info.magnolia.module.templatingkit.dam.AssetNotFoundException;
  import info.magnolia.module.templatingkit.dam.DAMException;
  import info.magnolia.module.templatingkit.dam.DAMSupport;
  import info.magnolia.module.templatingkit.dam.NoSuchVariationException;
  import info.magnolia.module.templatingkit.sites.Site;
  import info.magnolia.module.templatingkit.sites.SiteManager;
  import info.magnolia.module.templatingkit.style.CssSelectorBuilder;
  import info.magnolia.module.templatingkit.style.Theme;
  import info.magnolia.module.templatingkit.style.ThemeImpl;
  import info.magnolia.module.templatingkit.templates.AbstractSTKTemplateModel;
  import info.magnolia.module.templatingkit.templates.category.TemplateCategory;
  import info.magnolia.module.templatingkit.templates.category.TemplateCategoryUtil;
  import info.magnolia.rendering.template.TemplateDefinition;
  import info.magnolia.repository.RepositoryConstants;
  import info.magnolia.templating.functions.TemplatingFunctions;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  import javax.inject.Singleton;
  import javax.jcr.Node;
  import javax.jcr.Property;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.mutable.MutableInt;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This is an component exposing a couple of methods useful for STK templates.
   * It's exposed in templates as "stkfn".
   *
   * @version $Id$
   */
  @Singleton
  public class STKTemplatingFunctions{
  
      private static Logger log = LoggerFactory.getLogger(STKTemplatingFunctions.class);
  
      public static final String SITEROOT_TEMPLATE_CATEGORY = TemplateCategory.HOME;
  
      protected static final String TITLE_PROP_NAME = "title";
      protected static final String SITE_TITLE_PROP_NAME = "siteTitle";
      protected static final String METADATA_NODE_NAME = "MetaData";
      protected static final String TEMPLATE_PROP_NAME = "mgnl:template";
  
      //Injected variables
      private CssSelectorBuilder cssSelectorBuilder;
      private CategorizationSupport categorizationSupport;
      private SiteManager siteManager;
     private TemplatingFunctions templatingFunctions;
     private Provider<STKModule> moduleProvider;
 
     @Inject
     public STKTemplatingFunctions(TemplatingFunctions templatingFunctions, CssSelectorBuilder cssSelectorBuilder, CategorizationSupport categorizationSupport, SiteManager siteManager, Provider<STKModule> moduleProvider) {
         this.templatingFunctions = templatingFunctions;
         this.cssSelectorBuilder = cssSelectorBuilder;
         this.categorizationSupport = categorizationSupport;
         this.siteManager = siteManager;
         this.moduleProvider = moduleProvider;
     }
 
     /**
      * Method used to get the SearchPageLink.
      *   This Search page Link is defined on the Main PageInfo/Site configuration (Search Page
      * Path to search result page).
      *   Method is used from a STKComponent and STKArea Model.
      * @param content: Current Content node.
      * @return relative path to the defined result page i.e.
      *   '/magnolia-empty-webapp/demo-project/service/search-result.html'
      */
     public String searchPageLink(Node content) {
         String searchResultPageUUID = PropertyUtil.getString(siteRoot(content), "searchUUID");
         return (StringUtils.isEmpty(searchResultPageUUID)) ? null : templatingFunctions.link(RepositoryConstants.WEBSITE, searchResultPageUUID);
     }
     public String searchPageLink(ContentMap content) {
         return searchPageLink(content.getJCRNode());
     }
 
     /**
      * Return the Home Site Name = the physical node's object name.
      */
     public String homeName(Node content) {
         return NodeUtil.getName(siteRoot(content));
     }
     public String homeName(ContentMap content) {
         return homeName(content.getJCRNode());
     }
 
     /**
      * Return the HomeTitle value.
      * Referred by the  property 'name' of the root Node
      */
     public String homeTitle(Node content) {
         return PropertyUtil.getString(siteRoot(content), TITLE_PROP_NAME );
     }
     public String homeTitle(ContentMap content) {
         return homeTitle(content.getJCRNode());
     }
 
     /**
      * Return the SiteTitle value.
      * Referred by the  property 'siteTitle' of the root Node
      */
     public String siteTitle(Node content) {
         return PropertyUtil.getString(siteRoot(content), SITE_TITLE_PROP_NAME );
     }
     public String siteTitle(ContentMap content) {
         return siteTitle(content.getJCRNode());
     }
 
     /**
      * Return the home link of this site.
      */
     public String homeLink(Node content) {
         return templatingFunctions.link(siteRoot(content));
     }
 
     public String homeLink(ContentMap content) {
         return homeLink(content.getJCRNode());
     }
 
     public Site site() {
         return siteManager.getCurrentSite();
     }
 
     /**
      * Returns the according {@link Site} of the passed content {@link Node}.
      *
      * @param content The {@link Node} to determine its {@link Site} from
      * @return {@link Site} The according {@link Site} of the passed @param content
      */
     public Site site(Node content){
         try {
             return (content == null) ? null : siteManager.getAssignedSite(content);
         } catch (IllegalStateException e) {
             log.error("Unable to access assigned site ({}) until following issue is resolved: {}", content.toString(), e.getMessage());
             return null;
         }
     }
 
     // TODO dlipp/had: is that a good place to keep that code - you might have to access it from non-template related code. Maybe we shouldn't completely drop STKUtil but
     // keep it for common stuff.
     public Theme theme(Site site) {
         final String theme = site.getTheme().getName();
         return StringUtils.isBlank(theme) ? new ThemeImpl() : moduleProvider.get().getTheme(theme);
 
     }
     /**
      * Returns the according {@link Site} of the passed content {@link ContentMap}.
      *
      * @param content The {@link ContentMap} to determine its {@link Site} from
      * @return {@link Site} The according {@link Site} of the passed @param content
      */
     public Site site(ContentMap content){
         return site(content.getJCRNode());
     }
 
     /**
      * Returns the site's root {@link Node} of the @param content {@link Node}.
      * The root {@link Node} is defined as the page {@link Node} having template category TemplateCategory.HOME.
      * If no ancestor page exists with category TemplateCategory.HOME, the JCR workspace root is returned.
      *
      * @param content The {@link Node} to determine its site root
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content) {
         return this.siteRoot(content, SITEROOT_TEMPLATE_CATEGORY);
     }
 
     /**
      * Returns the site's root {@link ContentMap} of the @param content {@link ContentMap}.
      * The root {@link ContentMap} is defined as the page {@link Node} having template category TemplateCategory.HOME.
      * If no ancestor page exists with category TemplateCategory.HOME, the JCR workspace root is returned.
      *
      * @param content The {@link ContentMap} to determine its site root
      * @return {@link ContentMap} The site root {@link ContentMap} of the passed @param content
      */
     public ContentMap siteRoot(ContentMap content) {
         return this.siteRoot(content, SITEROOT_TEMPLATE_CATEGORY);
     }
 
     /**
      * Returns the site's root {@link Node} of the passed @param content {@link Node}.
      * The root {@link Node} is defined as the page {@link Node} with template its category as @param siteRootTemplateCategory.
      * If no ancestor page exists with category TemplateCategory.HOME, the JCR workspace root is returned.
      *
      * @param content The {@link Node} to determine its site root
      * @param siteRootTemplateCategory The {@link TemplateCategory} value of the site root to detect.
      *        If null or EMPTY is passed, the default value SITEROOT_TEMPLATE_CATEGORY is used instead.
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public ContentMap siteRoot(ContentMap content, String siteRootTemplateCategory) {
         return templatingFunctions.asContentMap(siteRoot(content.getJCRNode(), siteRootTemplateCategory));
     }
 
     /**
      *
      * Returns the site's root {@link Node} of the passed @param content {@link Node}.
      * The root {@link Node} is defined as the page {@link Node} with template its category as @param siteRootTemplateCategory.
      * If no ancestor page exists with category TemplateCategory.HOME, the JCR workspace root is returned.
      *
      * @param content The {@link Node} to determine its site root
      * @param siteRootTemplateCategory The {@link TemplateCategory} value of the site root to detect.
      *        If null or EMPTY is passed, the default value SITEROOT_TEMPLATE_CATEGORY is used instead.
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content, String siteRootTemplateCategory) {
         if(StringUtils.isEmpty(siteRootTemplateCategory)){
             siteRootTemplateCategory = SITEROOT_TEMPLATE_CATEGORY;
         }
         try {
             Node page = this.templatingFunctions.page(content);
             Node root = TemplateCategoryUtil.findParentWithTemplateCategory(page, siteRootTemplateCategory);
             return (root == null) ? (Node)page.getAncestor(0) : root;
         }
         catch (RepositoryException e) {
             throw new RuntimeException("Can't access site root.", e);
         }
     }
 
     public List<ContentMap> ancestorsInSite(ContentMap content) throws RepositoryException {
         return ancestorsInSite(content, null);
     }
 
     public List<Node> ancestorsInSite(Node content) throws RepositoryException {
         return ancestorsInSite(content, null);
     }
 
     public List<ContentMap> ancestorsInSite(ContentMap content, String nodeTypeName) throws RepositoryException {
         return templatingFunctions.asContentMapList(ancestorsInSite(content.getJCRNode(), nodeTypeName));
     }
 
     public List<Node> ancestorsInSite(Node content, String nodeTypeName) throws RepositoryException {
         List<Node> allAncestors = templatingFunctions.ancestors(content, nodeTypeName);
         Node siteRoot = siteRoot(content);
 
         List<Node> ancestoresInSite = new ArrayList<Node>();
         for(Node current: allAncestors){
             if(current.getDepth() >= siteRoot.getDepth()){
                 ancestoresInSite.add(current);
             }
         }
         return ancestoresInSite;
     }
 
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public String getAssetLink(Node content, String nodeDataPrefix){
         return getAssetLink( content,  nodeDataPrefix,  DAMSupport.VARIATION_ORIGINAL);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public String getAssetLink(ContentMap content, String nodeDataPrefix){
         return getAssetLink(content.getJCRNode(), nodeDataPrefix);
     }
 
     public String getAssetLink(ContentMap content, String nodeDataPrefix, AbstractSTKTemplateModel<? extends TemplateDefinition> model){
         return getAssetLink(content.getJCRNode(), nodeDataPrefix, resolveImageVariationName(model));
     }
 
     public String getAssetLink(ContentMap content, String nodeDataPrefix, String variationName){
         return getAssetLink(content.getJCRNode(), nodeDataPrefix,variationName);
     }
 
     public String getAssetLink(Node content, String nodeDataPrefix, String variationName){
         final Asset asset = getAsset(content, nodeDataPrefix, variationName);
         if(asset != null){
             try {
                 return asset.getLink();
             }
             catch (DAMException e) {
                 log.warn("Failed to get asset link with exception: " + e.getMessage(), e);
                 return null;
             }
         }
         return null;
     }
 
 
     public String resolveImageVariationName(AbstractSTKTemplateModel<? extends TemplateDefinition> model) {
         final String cssSelector = cssSelectorBuilder.createCssSelector(model);
         try {
             return theme(site(model.getNode())).getImaging().resolveVariationName(cssSelector);
         }
         catch (NoSuchVariationException e) {
             log.warn(e.getMessage());
             return DAMSupport.VARIATION_ORIGINAL;
         }
     }
 
     public  Asset getAssetVariation(Asset original, String variationName){
         if(!variationName.equals(DAMSupport.VARIATION_ORIGINAL)){
             try {
                 return original.getVariation(variationName);
             }
             catch (NoSuchVariationException e) {
                 log.warn("Can't find the variation " + variationName + " for asset [" + original + "]. Will use the original instead.");
             }
             catch(DAMException e){
                 log.warn("Failed to get asset variation " + variationName + " with exception: " + e.getMessage(), e);
                 return null;
             }
         }
         return original;
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      * FIXME I18nContentWrapper --> I18nNodeWrapper
      */
     public Node wrap(Node content){
         return (content == null)  ? null :  templatingFunctions.encode(new I18nNodeWrapper(content));
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public List<ContentMap> getCategories(Node page) {
         return categorizationSupport.getCategories(page);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public String getCategoryLink(Node page, String categoryName) {
         return categorizationSupport.getCategoryLink(page, categoryName);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public List<Node> getContentListByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory) throws RepositoryException {
         return getContentListByTemplateCategorySubCategory(siteRoot, category, subCategory, Integer.MAX_VALUE, null, null);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory, int maxResultSize, String andClause, String orderBy) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateCategorySubCategory(siteRoot, category, subCategory, maxResultSize, andClause, orderBy);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public Node getNearestContentByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory, Node current) throws RepositoryException {
        return TemplateCategoryUtil.getNearestContentByTemplateCategorySubCategory(siteRoot,  category,  subCategory,current);
     }
     
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateName(Node searchRoot, String templateName) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateName(searchRoot, templateName);
     }
     
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateName(Node searchRoot, String templateName, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateName(searchRoot, templateName, maxResultSize, andClause, orderByClause);
     }
     
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateNames(Node searchRoot, Set<String> templateIds, int maxResultSize, String andClause, String orderByClause) throws RepositoryException{
         return TemplateCategoryUtil.getContentListByTemplateNames(searchRoot, templateIds, maxResultSize, andClause, orderByClause);
     }
 
     /**
      * Returns a {@link Node} object which is referenced by its id, stored in the @param propertyName.
      * @param content the node with a property containing the referenced id value.
      * @param idPropertyName The name of the property which contains the id of the referenced {@link Node}.
      * @param referencedWorkspace The workspace in which the referenced {@link Node} exists.
      * @return the referenced {@link Node}
      */
     public Node getReferencedContent(Node content, String idPropertyName, String referencedWorkspace){
         try {
             if(content.hasProperty(idPropertyName)){
                 String identifier = PropertyUtil.getString(content, idPropertyName);
                 return wrap(NodeUtil.getNodeByIdentifier(referencedWorkspace, identifier));
             }
         } catch (RepositoryException e) {
             log.error("can't read value '" + idPropertyName + "' of the Node '" + content.toString() + "'.", e);
             throw new RuntimeRepositoryException(e);
         }
         return null;
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public Asset getAsset(Node content, String nodeDataPrefix, String variationName){
         try{
             final Asset asset = moduleProvider.get().getDamSupport().getAsset(ContentUtil.asContent(content), nodeDataPrefix);
             return getAssetVariation(asset, variationName);
         }
         catch(AssetNotFoundException e){
             return null;
         }
         catch(DAMException e){
             log.warn("Failed to get asset with exception: " + e.getMessage(), e);
             return null;
         }
     }
 
     public Asset getAsset(Node content, String nodeDataPrefix){
         return getAsset(content, nodeDataPrefix, DAMSupport.VARIATION_ORIGINAL);
     }
 
     public Asset getAsset(ContentMap content, String nodeDataPrefix){
         return getAsset(content.getJCRNode(), nodeDataPrefix);
     }
 
 
     /**
      * Return a Node List with a maximum number or result less or equal to maxResults.
      */
     public List<Node> cutList(List<Node> itemsList, final int maxResults){
         if(itemsList.size() > maxResults) {
             return itemsList.subList(0, maxResults);
         }
         return itemsList;
     }
 
     // TODO : use WordUtils.abbreviate and/or add tests
     public String abbreviateString(String stringToCut, int size) {
         return abbreviateString(stringToCut, size, " ...");
     }
 
     public String abbreviateString(String stringToCut, int size, String closureString) {
         if(stringToCut.length() > size) {
             int sizeMinusClosue= size - closureString.length();
             String cuttedString = StringUtils.left(stringToCut, sizeMinusClosue);
 
             //If the character after the cut was a space, no word was cutted -> no cutting on last space needed.
             String firstCharAfterCut = stringToCut.substring(sizeMinusClosue, sizeMinusClosue+1);
             if(!firstCharAfterCut.equals(" ")){
                 cuttedString = StringUtils.substringBeforeLast(cuttedString, " ");
             }
 
             return cuttedString + closureString;
 
         }
         return stringToCut;
     }
 
     /**
      * Increases the context bound counter and returns the value. This is for instance useful to create unique page wide ids.
      */
     public int count(String name){
         String attributeName = STKTemplatingFunctions.class.getName() +  name;
         if(!MgnlContext.hasAttribute(attributeName)){
             MgnlContext.setAttribute(attributeName, new MutableInt(0));
         }
         MutableInt counter = (MutableInt) MgnlContext.getAttribute(attributeName);
         counter.increment();
         return counter.intValue();
     }
 
     public String getDivIdAbbreviation(String divID){
         return getDivIdAbbreviation(divID, "-");
     }
 
     public String getDivIdAbbreviation(String divID, String delimiter){
         String result = StringUtils.EMPTY;
         if(StringUtils.isNotEmpty(divID) && StringUtils.isNotEmpty(delimiter)){
             String[] values = divID.split("\\"+delimiter);
             for(String value : values ){
                 result += value.substring(0, 1);
             }
         }
         return result;
     }
 
     /**
      * Return a property from the metaData of the node.
      */
     public String metaDataProperty(Node content, String property){
         try {
             if(content.hasNode(METADATA_NODE_NAME)){
                 Node node = content.getNode(METADATA_NODE_NAME);
                 Property metaDataProp = PropertyUtil.getProperty(node, property);
                 if(metaDataProp != null){
                     return metaDataProp.getString();
                 }
             }
         } catch (RepositoryException e) {
             throw new RuntimeException(e);
         }
         return null;
     }
 
     public String metaDataProperty(ContentMap content, String property){
         return metaDataProperty(content.getJCRNode(), property);
     }
 
     /**
      * Return the template id associated with this content.
      */
     public String metaDataTemplate(Node content){
         return metaDataProperty(content,TEMPLATE_PROP_NAME);
     }
 
     public String metaDataTemplate(ContentMap content){
         return metaDataProperty(content,TEMPLATE_PROP_NAME);
     }
 
     /**
      * For test purpose only.
      */
     public void setCssSelectorBuilder(CssSelectorBuilder cssSelectorBuilder){
         this.cssSelectorBuilder = cssSelectorBuilder;
     }
 
     /**
      * For test purpose only.
      */
     public void setCategorizationSupport(CategorizationSupport categorizationSupport){
         this.categorizationSupport = categorizationSupport;
     }
 
 }