/**
    * This file Copyright (c) 2008-2012 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.context.MgnlContext;
  import info.magnolia.dam.Dam;
  import info.magnolia.dam.asset.Asset;
  import info.magnolia.dam.asset.DamException;
  import info.magnolia.dam.asset.DamAsset;
  import info.magnolia.dam.asset.variation.AssetVariationProvider;
  import info.magnolia.dam.asset.variation.NoSuchVariationException;
  import info.magnolia.jcr.RuntimeRepositoryException;
  import info.magnolia.jcr.util.ContentMap;
  import info.magnolia.jcr.util.NodeTypes;
  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.DAMSupport;
  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.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".
   */
  @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";
  
      // Injected variables
      private CssSelectorBuilder cssSelectorBuilder;
      private CategorizationSupport categorizationSupport;
      private final SiteManager siteManager;
      private final TemplatingFunctions templatingFunctions;
      private final Provider<STKModule> moduleProvider;
  
     private final Dam dam;
     private final AssetVariationProvider variationProvider;
     @Inject
     public STKTemplatingFunctions(TemplatingFunctions templatingFunctions, CssSelectorBuilder cssSelectorBuilder,
             CategorizationSupport categorizationSupport, SiteManager siteManager, Provider<STKModule> moduleProvider,
             Dam dam, AssetVariationProvider variationProvider) {
         this.templatingFunctions = templatingFunctions;
         this.cssSelectorBuilder = cssSelectorBuilder;
         this.categorizationSupport = categorizationSupport;
         this.siteManager = siteManager;
         this.moduleProvider = moduleProvider;
 
         this.dam = dam;
         this.variationProvider = variationProvider;
     }
 
     /**
      * 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 (original instanceof DamAsset) {
             return variationProvider.createVariation(original, 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;
     }
 
     public Asset getAsset(Node content, String nodeDataPrefix, String variationName) {
         final Asset damAsset = dam != null ? dam.getAsset(content, nodeDataPrefix) : null;
 
         if (damAsset != null) {
             ((DamAsset) damAsset).setVariationProvider(variationProvider);
             try {
                 return damAsset.getVariation(variationName);
             } catch (NoSuchVariationException e) {
                 log.warn("Failed to get variation.", e);
             } catch (DamException e) {
                 log.warn("Failed to get asset.", 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) {
         return templatingFunctions.metaData(content, property);
     }
 
     public String metaDataProperty(ContentMap content, String property){
         return templatingFunctions.metaData(content, property);
     }
 
     /**
      * Return the template id associated with this content.
      */
 
     public String metaDataTemplate(Node content){
         try {
             return NodeTypes.Renderable.getTemplate(content);
         } catch (RepositoryException e) {
             return null;
         }
     }
 
     public String metaDataTemplate(ContentMap content){
         return metaDataTemplate(content.getJCRNode());
     }
 
     /**
      * For test purpose only.
      */
     public void setCssSelectorBuilder(CssSelectorBuilder cssSelectorBuilder) {
         this.cssSelectorBuilder = cssSelectorBuilder;
     }
 
     /**
      * For test purpose only.
      */
     public void setCategorizationSupport(CategorizationSupport categorizationSupport) {
         this.categorizationSupport = categorizationSupport;
     }
 
 }