/*
 *  Copyright 2016 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.ametys.web.transformation.xslt;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.Response;
import org.apache.cocoon.xml.dom.DOMBuilder;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import org.ametys.cms.CmsConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.dom.AmetysNodeList;
import org.ametys.core.util.dom.EmptyElement;
import org.ametys.core.util.dom.MapElement;
import org.ametys.core.util.dom.MapElement.MapNode;
import org.ametys.core.util.dom.SourceElement;
import org.ametys.core.util.dom.StringElement;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.explorer.resources.dom.ResourceCollectionElement;
import org.ametys.plugins.explorer.resources.dom.ResourceElement;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.Repeater;
import org.ametys.plugins.repository.data.holder.group.RepeaterEntry;
import org.ametys.plugins.repository.data.type.ModelItemTypeConstants;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.repository.model.RepositoryDataContext;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.ExpressionContext;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.MetadataExpression;
import org.ametys.plugins.repository.query.expression.NotExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemType;
import org.ametys.web.URIPrefixHandler;
import org.ametys.web.WebConstants;
import org.ametys.web.cache.PageHelper;
import org.ametys.web.parameters.view.ViewParametersManager;
import org.ametys.web.parameters.view.ViewParametersManager.ViewParameterHolder;
import org.ametys.web.parameters.view.ViewParametersModel;
import org.ametys.web.renderingcontext.RenderingContext;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.content.WebContent;
import org.ametys.web.repository.dom.PageElement;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.page.PageDAO;
import org.ametys.web.repository.page.SitemapElement;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.page.ZoneItem.ZoneType;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.service.Service;
import org.ametys.web.service.ServiceExtensionPoint;
import org.ametys.web.skin.SkinsManager;
import org.ametys.web.tags.TagExpression;
import org.ametys.web.url.UrlPreview;
import org.ametys.web.url.UrlPreviewComponent;

/**
 * Helper component to be used from XSL stylesheets.
 */
public class AmetysXSLTHelper extends org.ametys.cms.transformation.xslt.AmetysXSLTHelper
{
    static final int _PAGINATION_CURRENT = -1;
    static final int _PAGINATION_SEPARATOR = -2;
    static final int _PAGINATION_SPACE = -3;
    
    private static final String __NAME_ATTRIBUTE = "name";
    private static final String __TYPE_ATTRIBUTE = "type";
    private static final String __REPEATER_ENTRY_TYPE = ModelItemTypeConstants.REPEATER_TYPE_ID + "_entry";
    
    private static SiteManager _siteManager;
    private static RenderingContextHandler _renderingContextHandler;
    private static URIPrefixHandler _prefixHandler;
    private static ServiceExtensionPoint _serviceEP;
    private static PopulationContextHelper _populationContextHelper;
    private static UrlPreviewComponent _urlPreview;
    private static ViewParametersManager _viewParametersManager;
    private static PageDAO _pageDAO;
    private static SkinsManager _skinsManager;
    private static PageHelper _pageHelper;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _pageDAO = (PageDAO) manager.lookup(PageDAO.ROLE);
        _renderingContextHandler = (RenderingContextHandler) manager.lookup(RenderingContextHandler.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        _prefixHandler = (URIPrefixHandler) manager.lookup(URIPrefixHandler.ROLE);
        _serviceEP = (ServiceExtensionPoint) manager.lookup(ServiceExtensionPoint.ROLE);
        _populationContextHelper = (PopulationContextHelper) manager.lookup(PopulationContextHelper.ROLE);
        _urlPreview = (UrlPreviewComponent) manager.lookup(UrlPreviewComponent.ROLE);
        _viewParametersManager = (ViewParametersManager) manager.lookup(ViewParametersManager.ROLE);
        _skinsManager = (SkinsManager) manager.lookup(SkinsManager.ROLE);
        _pageHelper = (PageHelper) manager.lookup(PageHelper.ROLE);
    }
    
    /**
     * Returns the current URI prefix, depending on the rendering context.
     * @return the current URI prefix.
     */
    public static String uriPrefix()
    {
        return _prefixHandler.getUriPrefix();
    }
    
    /**
     * Returns the URI prefix corresponding to the current site, depending on the rendering context.
     * @return the URI prefix corresponding to the current site.
     */
    public static String siteUriPrefix()
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        return _prefixHandler.getUriPrefix(siteName);
    }
    
    /**
     * Returns the absolute URI prefix, depending on the rendering context.
     * @return the absolute URI prefix.
     */
    public static String absoluteUriPrefix()
    {
        return _prefixHandler.getAbsoluteUriPrefix();
    }
    
    /**
     * Returns the absolute URI prefix corresponding to the current site, depending on the rendering context.
     * @return the absolute URI prefix corresponding to the current site.
     */
    public static String absoluteSiteUriPrefix()
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        return _prefixHandler.getAbsoluteUriPrefix(siteName);
    }
    
    /**
     * Returns the absolute URI prefix corresponding to the given site, depending on the rendering context.
     * @param siteName The site name. Can be null to get the current site.
     * @return the absolute URI prefix corresponding to the current site.
     */
    public static String absoluteSiteUriPrefix(String siteName)
    {
        if (StringUtils.isEmpty(siteName))
        {
            return absoluteSiteUriPrefix();
        }
        return _prefixHandler.getAbsoluteUriPrefix(siteName);
    }
    
    /**
     * Returns the current skin name.
     * @return the current skin name.
     */
    public static String skin()
    {
        return _skinsManager.getSkinNameFromRequest();
    }
    
    /**
     * Returns the current template name.
     * @return the current template name.
     */
    public static String template()
    {
        Request request = ContextHelper.getRequest(_context);
        return (String) request.getAttribute("template");
    }
    
    /**
     * Returns the current sitemap name.
     * @return the current sitemap name.
     */
    public static String lang()
    {
        Request request = ContextHelper.getRequest(_context);
        String lang = (String) request.getAttribute("sitemapLanguage");
        
        return StringUtils.isNotBlank(lang)
            ? lang
            : org.ametys.cms.transformation.xslt.AmetysXSLTHelper.lang();
    }
    
    /**
     * Returns the current sitemap name.
     * @param pageId The page identifier to get sitemap on
     * @return the current sitemap name.
     */
    public static String lang(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getSitemapName();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get sitemap lang on page '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Computes the URI for the given resource in the current site's skin.<br>
     * If the URI is requested by the front-office, it will be absolutized.
     * @param path the resource path.
     * @return the URI for the given resource.
     */
    public static String skinURL(String path)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        Site site = _siteManager.getSite(siteName);
        String skin = (String) request.getAttribute("skin");
        
        String resourcePath = "/skins/" + skin + "/resources/" + path;
        
        return _getResourceURL(request, site, resourcePath);
    }
    
    /**
     * Computes the URI for the given image with a given heigth and width in the current site's skin.<br>
     * If the URI is requested by the front-office, it will be absolutized.
     * @param path the resource path
     * @param height the height for the resource to get
     * @param width the width for the resource to get
     * @return the URI of the given resource
     */
    public static String skinImageURL(String path, int height, int width)
    {
        String skinPath = skinURL(path);
        return StringUtils.substringBeforeLast(skinPath, ".") + "_" + height + "x" + width + "." + StringUtils.substringAfterLast(skinPath, "."); 
    }
    
    /**
     * Computes the base 64 representation of the image at the specified path. <br>
     * @param skin the skin to search in
     * @param path the path of the image
     * @return the base 64-encoded image
     * @throws IOException if an error occurs while trying to get the file
     */
    public static String skinImageBase64(String skin, String path) throws IOException
    {
        Source source = null;
        try
        {
            source = _sourceResolver.resolveURI("skin:" + skin + "://resources/" + path);
            return _getResourceBase64(source); 
        }
        finally 
        {
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Computes the base 64 representation of the image at the specified path. <br>
     * @param path the path of the image
     * @return the base 64-encoded image
     * @throws IOException if an error occurs while trying to get the file
     */
    public static String skinImageBase64 (String path) throws IOException
    {
        Source source = null;
        try
        {
            source = _sourceResolver.resolveURI("skin://resources/" + path);
            return _getResourceBase64(source); 
        }
        finally 
        {
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Computes the URI for the given image with a given heigth and width in the current site's skin.<br>
     * If the URI is requested by the front-office, it will be absolutized.
     * @param path the resource path
     * @param maxHeight the maximum height for the resource to get
     * @param maxWidth the maximum width for the resource to get
     * @return the URI of the given resource
     */
    public static String skinBoundedImageURL(String path, int maxHeight, int maxWidth)
    {
        String skinPath = skinURL(path);
        return StringUtils.substringBeforeLast(skinPath, ".") + "_max" + maxHeight + "x" + maxWidth + "." + StringUtils.substringAfterLast(skinPath, "."); 
    }
    
    /**
     * Computes the URI for the given resource in the current template.<br>
     * If the URI is requested by the front-office, it will be absolutized.
     * @param path the resource path.
     * @return the URI for the given resource.
     */
    public static String templateURL(String path)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        Site site = _siteManager.getSite(siteName);
        String skin = (String) request.getAttribute("skin");
        String template = (String) request.getAttribute("template");
        
        String resourcePath = "/skins/" + skin + "/templates/" + template + "/resources/" + path;
        
        return _getResourceURL(request, site, resourcePath);
    }
    
    /**
     * Computes the URI for the given resource in the given plugin.<br>
     * If the URI is requested by the front-office, it will be absolutized.
     * @param plugin the plugin name.
     * @param path the resource path.
     * @return the URI for the given resource.
     */
    public static String pluginResourceURL(String plugin, String path)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        Site site = _siteManager.getSite(siteName);
        
        String resourcePath = "/plugins/" + plugin + "/resources/" + path;
        
        return _getResourceURL(request, site, resourcePath);
    }
    
    private static String _getResourceURL(Request request, Site site, String resourcePath)
    {
        String prefix;
        switch (_renderingContextHandler.getRenderingContext())
        {
            case FRONT:
                String[] aliases = site.getUrlAliases();
                int position = Math.abs(resourcePath.hashCode()) % aliases.length;
                
                boolean absolute = request.getAttribute("forceAbsoluteUrl") != null ? (Boolean) request.getAttribute("forceAbsoluteUrl") : false;
                prefix = position == 0 && !absolute ? siteUriPrefix() : aliases[position];  
                return prefix + resourcePath;
                
            default:
                prefix = StringUtils.trimToEmpty((String) request.getAttribute(CmsConstants.PATH_PREFIX_ATTRIBUTE));
                return request.getContextPath() + prefix + resourcePath;
        }
    }
    
    /**
     * Returns the current {@link RenderingContext}.
     * @return the current {@link RenderingContext}.
     */
    public static String renderingContext()
    {
        return _renderingContextHandler.getRenderingContext().toString();
    }
    
    /**
     * Return the name of the zone beeing handled
     * @param defaultValue If no page is handled currently, this value is returned (can be null, empty...)
     * @return the name or the default value (so can be null or empty)
     */
    public static String zone(String defaultValue)
    {
        Request request = ContextHelper.getRequest(_context);
        
        return StringUtils.defaultIfEmpty((String) request.getAttribute(Zone.class.getName()), defaultValue);
    }

    /**
     * Return the value of a site parameter as a String.
     * @param parameter the parameter ID.
     * @return the parameter value as a String.
     */
    public static String siteParameter(String parameter)
    {
        Request request = ContextHelper.getRequest(_context);
        
        String siteName = (String) request.getAttribute("site");
        if (StringUtils.isBlank(siteName))
        {
            // In BO xsl
            siteName = (String) request.getAttribute("siteName");
        }
        
        return siteParameter(siteName, parameter);
    }
    
    /**
     * Return the value of a site parameter as a String.
     * @param siteName the site name
     * @param parameter the parameter ID.
     * @return the parameter value as a String.
     */
    public static String siteParameter(String siteName, String parameter)
    {
        try
        {
            Site site = _siteManager.getSite(siteName);
            Object value = site.getValue(parameter);
            if (value != null)
            {
                return value.toString();
            }
            else
            {
                return null;
            }
        }
        catch (Exception e)
        {
            String message = "Error retrieving the value of the site parameter " + parameter;
            _logger.error(message, e);
            throw new RuntimeException(message, e);
        }
    }
    
    /**
     * Returns the sitemap' names handled by the current site
     * @return The available languages
     */
    public static NodeList siteLanguages()
    {
        Request request = ContextHelper.getRequest(_context);
        
        String siteName = (String) request.getAttribute("site");
        if (StringUtils.isBlank(siteName))
        {
            // In BO xsl
            siteName = (String) request.getAttribute("siteName");
        }
        
        return siteLanguages(siteName);
    }
    
    /**
     * Returns the sitemap' names handled by a site
     * @param siteName The site name
     * @return The available languages
     */
    public static NodeList siteLanguages(String siteName)
    {
        List<StringElement> languages = new ArrayList<>(); 
        
        try
        {
            Site site = _siteManager.getSite(siteName);
            AmetysObjectIterable<Sitemap> sitemaps = site.getSitemaps();
            for (Sitemap sitemap : sitemaps)
            {
                languages.add(new StringElement("lang", sitemap.getName()));
            }
        }
        catch (Exception e)
        {
            String message = "Error retrieving the available languages for the site " + siteName;
            _logger.error(message, e);
            throw new RuntimeException(message, e);
        }
        
        return new AmetysNodeList(languages);
    }
    
    /**
     * Get the service parameters as a {@link Node}.
     * @return the service parameters as a {@link Node}.
     */
    public static Node serviceParameters()
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        return _serviceParameters(zoneItem);
    }
    
    static Node _serviceParameters(ZoneItem zoneItem)
    {
        Map<String, MapNode> values = new HashMap<>();
        
        ModelAwareDataHolder dataHolder = zoneItem.getServiceParameters();
        String serviceId = zoneItem.getServiceId();
        Service service = _serviceEP.getExtension(serviceId);
        
        for (String parameterName : dataHolder.getDataNames())
        {
            ModelItem modelItem = service.getModelItem(parameterName);
            values.putAll(_getParameterValue(parameterName, modelItem, dataHolder, null));
        }
        
        return new MapElement("serviceParameters", values);
    }
    
    /**
     * Returns the value of the given parameter for the current service, or the empty string if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current service.
     */
    public static Node serviceParameter(String parameterPath)
    {
        return serviceParameter(parameterPath, "");
    }
    
    /**
     * Returns the value of the given parameter for the current service, or the provided default value if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @param defaultValue the default value. Note that default value is ignored if the parameter is a composite parameter.
     * @return the value of the given parameter for the current service.
     */
    public static Node serviceParameter(String parameterPath, Object defaultValue)
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        return _serviceParameter(zoneItem, parameterPath, defaultValue);
    }
    
    static Node _serviceParameter(ZoneItem zoneItem, String parameterPath, Object defaultValue)
    {
        ModelAwareDataHolder dataHolder = zoneItem.getServiceParameters();
        
        String serviceId = zoneItem.getServiceId();
        String definitionPath = ModelHelper.getDefinitionPathFromDataPath(parameterPath);
        
        Service service = _serviceEP.getExtension(serviceId);
        ModelItem paramDef;
        if (service.hasModelItem(definitionPath))
        {
            paramDef = service.getModelItem(definitionPath);
        }
        else
        {
            // The parameter is unknown
            if (defaultValue == null
                || defaultValue instanceof String && StringUtils.isEmpty((String) defaultValue))
            {
                return null;
            }
            else
            {
                return new StringElement(parameterPath, Collections.EMPTY_MAP, defaultValue.toString());
            }
        }
        
        Map<String, MapNode> value = _getParameterValue(parameterPath, paramDef, dataHolder, defaultValue);
        
        if (!value.containsKey(parameterPath))
        {
            return null;
        }
        else if (paramDef instanceof RepeaterDefinition
                || paramDef instanceof ElementDefinition && ((ElementDefinition) paramDef).isMultiple())
        {
            MapNode node = value.get(parameterPath);
            @SuppressWarnings("unchecked")
            Map<String, ? extends Object> values = (Map<String, ? extends Object>) node.getValue();
            return new MapElement(parameterPath, node.getAttributes(), values);
        }
        else 
        {
            return new StringElement(parameterPath, value.get(parameterPath).getAttributes(), (String) value.get(parameterPath).getValue());
        }
    }
    
    private static String _convertTagName(String name)
    {
        char c = name.charAt(0);
        if (c >= '0' && c <= '9')
        {
            String hex = Integer.toHexString(c);
            return "_x" + StringUtils.leftPad(hex, 4, '0') + "_" + name.substring(1);
        }
        else
        {
            return name;
        }
    }
    
    @SuppressWarnings("unchecked")
    private static Map<String, MapNode> _getParameterValue(String parameterPath, ModelItem modelItem, ModelAwareDataHolder dataHolder, Object defaultValue)
    {
        String[] pathSegments = StringUtils.split(parameterPath, ModelItem.ITEM_PATH_SEPARATOR);
        String parameterName = pathSegments[pathSegments.length - 1];
        Map<String, MapNode> paramValues = new HashMap<>();
        
        if (modelItem instanceof RepeaterDefinition)
        {
            if (!dataHolder.hasValue(parameterPath))
            {
                return paramValues;
            }
                    
            Map<String, String> attributes = new HashMap<>();
            attributes.put(__NAME_ATTRIBUTE, parameterName);
            attributes.put(__TYPE_ATTRIBUTE, ModelItemTypeConstants.REPEATER_TYPE_ID);
            
            Map<String, Object> children = new HashMap<>();
            
            Repeater repeater = dataHolder.getRepeater(parameterPath);
            for (RepeaterEntry entry : repeater.getEntries())
            {
                Map<String, Object> entryValue = new HashMap<>();
                
                for (ModelItem childModelItem : ((RepeaterDefinition) modelItem).getChildren())
                {
                    // Default value is ignored if parameter is a repeater
                    Map<String, MapNode> childParamValues = _getParameterValue(childModelItem.getName(), childModelItem, entry, null);
                    entryValue.putAll(childParamValues);
                }
                
                Map<String, String> entryAttributes = new HashMap<>();
                entryAttributes.put(__NAME_ATTRIBUTE, String.valueOf(entry.getPosition()));
                entryAttributes.put(__TYPE_ATTRIBUTE, __REPEATER_ENTRY_TYPE);
                
                MapNode entryNode = new MapNode(entryValue, entryAttributes);
                children.put(_convertTagName(String.valueOf(entry.getPosition())), entryNode);
            }
            
            MapNode node = new MapNode(children, attributes);
            paramValues.put(parameterPath, node);
        }
        else 
        {
            if (!_hasParameterValueOrDefaultValue(parameterPath, dataHolder, defaultValue))
            {
                return paramValues;
            }
            
            Map<String, String> attributes = new HashMap<>();
            attributes.put(__NAME_ATTRIBUTE, parameterName);
            ElementDefinition elementDefinition = (ElementDefinition) modelItem;
            ElementType elementType = elementDefinition.getType();
            attributes.put(__TYPE_ATTRIBUTE, elementType.getId());
            
            if (elementDefinition.isMultiple())
            {
                Map<String, List<String>> values = new HashMap<>();
                List<String> value = new ArrayList<>();
                Object[] valueArray = (Object[]) dataHolder.getValueOrDefault(parameterPath, defaultValue);
                for (Object arrayItem : valueArray)
                {
                    value.add(elementType.toString(arrayItem));
                }
                values.put("value", value);
                
                MapNode node = new MapNode(values, attributes);
                paramValues.put(parameterPath, node);
            }
            else
            {
                
                String value = elementType.toString(dataHolder.getValueOrDefault(parameterPath, defaultValue));
                MapNode node = new MapNode(value, attributes);
                paramValues.put(parameterPath, node);
            }
        }
        
        return paramValues;
    }
    
    private static boolean _hasParameterValueOrDefaultValue(String parameterPath, ModelAwareDataHolder dataHolder, Object defaultValue)
    {
        if (dataHolder.hasValue(parameterPath))
        {
            return true;
        }
        else
        {
            if (defaultValue != null)
            {
                return defaultValue instanceof String ? StringUtils.isNotEmpty((String) defaultValue) : true;
            }
            else
            {
                return false;
            }
        }
    }
    
    /**
     * Returns the current site
     * @return the current site
     */
    public static String site()
    {
        Request request = ContextHelper.getRequest(_context);
        return (String) request.getAttribute("site");
    }
    
    /**
     * Returns the current site
     * @param pageId The identifier ot the page
     * @return the current site
     */
    public static String site(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getSiteName();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get site on page '" + pageId + "'", e);
            return "";
        }
    }

    /**
     * Return the current sitemap as a {@link Node}.
     * Invisible pages will not be displayed
     * @return the current sitemap.
     * @deprecated Use the version with depth argument
     */
    @Deprecated
    public static Node sitemap()
    {
        throw new UnsupportedOperationException("DEPRECATED Use the ametys:sitemap(DEPTH) where DEPTH can be 1 to get root pages, 2 or more to get their children at n levels ; 0 to get only sitemap infos ; -1 to get infinite sitemap (to avoid)");
    }
    
    /**
     * Return the current sitemap as a {@link Node}.
     * Invisible pages will not be displayed
     * @param depth The depth to get. 1 for root pages, -1 for infinite.
     * @return the current sitemap.
     */
    public static Node sitemap(long depth)
    {
        return sitemap(depth, false);
    }
    
    /**
     * Return the current sitemap as a {@link Node}.
     * @param includeInvisiblePages Should return child invisible pages
     * @return the current sitemap.
     * @deprecated Use the version with depth argument
     */
    @Deprecated
    public static Node sitemap(boolean includeInvisiblePages)
    {
        throw new UnsupportedOperationException("DEPRECATED Use the ametys:sitemap(DEPTH, includeInvisiblePages) where DEPTH can be 1 to get root pages, 2 or more to get their children at n levels ; 0 to get only sitemap infos ; -1 to get infinite sitemap (to avoid)");
    }
    
    /**
     * Return the current sitemap as a {@link Node}.
     * @param depth The depth to get. 1 for root pages, -1 for infinite.
     * @param includeInvisiblePages Should return child invisible pages
     * @return the current sitemap.
     */
    public static Node sitemap(long depth, boolean includeInvisiblePages)
    {
        Request request = ContextHelper.getRequest(_context);
        Sitemap sitemap = (Sitemap) request.getAttribute(Sitemap.class.getName());
        
        if (sitemap == null)
        {
            // Try to get sitemap from content
            Content content = (Content) request.getAttribute(Content.class.getName());
            if (content instanceof WebContent)
            {
                sitemap = ((WebContent) content).getSite().getSitemap(content.getLanguage());
            }
        }
        
        if (sitemap == null)
        {
            return new EmptyElement("sitemap");
        }
        
        Page page = (Page) request.getAttribute(WebConstants.REQUEST_ATTR_PAGE);
        
        return new org.ametys.web.repository.dom.SitemapElement(sitemap, page != null ? page.getPathInSitemap() : null, _rightManager, _renderingContextHandler, _currentUserProvider.getUser(), depth, includeInvisiblePages, _tagProviderExtPt);
    }

    /**
     * Return the subsitemap of the given page as a {@link Node}.
     * Invisible child pages will not be returned;
     * @param pageId The root page
     * @return The page as node.
     * @deprecated Use the version with depth argument
     */
    @Deprecated
    public static Node sitemap(String pageId)
    {
        throw new UnsupportedOperationException("DEPRECATED Use the ametys:sitemap(pageId, DEPTH) where DEPTH can be 1 (or more) to get page and children at n levels ; 0 to get only this page infos ; -1 to get infinite sitemap (to avoid)");
    }

    /**
     * Return the subsitemap of the given page as a {@link Node}.
     * Invisible child pages will not be returned;
     * @param pageId The root page
     * @param depth The depth to get. 0 for the root page only, 1 for its child pages, -1 for infinite child pages.
     * @return The page as node.
     */
    public static Node sitemap(String pageId, long depth)
    {
        return sitemap(pageId, depth, false);
    }
        
    /**
     * Return the subsitemap of the given page as a {@link Node}.
     * @param pageId The root page
     * @param includeInvisiblePages Should return child invisible pages
     * @return The page as node.
     */
    public static Node sitemap(String pageId, boolean includeInvisiblePages)
    {
        return sitemap(pageId, -1, includeInvisiblePages);
    }
    
    /**
     * Return the subsitemap of the given page as a {@link Node}.
     * @param pageId The root page
     * @param depth The depth to get. 0 for the root page only, 1 for its child pages, -1 for infinite child pages.
     * @param includeInvisiblePages Should return child invisible pages
     * @return The page as node.
     */
    public static Node sitemap(String pageId, long depth, boolean includeInvisiblePages)
    {
        Page rootPage = null;
        try
        {
            rootPage = _ametysObjectResolver.resolveById(pageId);
        }
        catch (UnknownAmetysObjectException e)
        {
            return new EmptyElement("page");
        }
        
        Page page = _getPageFromRequest();
        return new PageElement(rootPage, _rightManager, _renderingContextHandler, page != null ? page.getPathInSitemap() : null,  _currentUserProvider.getUser(), depth, includeInvisiblePages, _tagProviderExtPt);
    }
    
    /**
     * Computes the breadcrumb of the current page.
     * @return a NodeList containing all ancestor pages, rooted at the sitemap.
     */
    public static NodeList breadcrumb()
    {
        Page page = _getPageFromRequest();
        return _breadcrumb(page);
    }
    
    /**
     * Computes the breadcrumb of a given page.
     * @param pageId The page id
     * @return a NodeList containing all ancestor pages, rooted at the sitemap.
     */
    public static NodeList breadcrumb(String pageId)
    {
        Page page = _ametysObjectResolver.resolveById(pageId);
        return _breadcrumb(page);
    }
    
    private static NodeList _breadcrumb(Page page)
    {
        List<Element> result = new ArrayList<>();

        AmetysObject parent = page.getParent();
        while (parent instanceof Page)
        {
            Element node = new StringElement("page", (Map<String, String>) null, parent.getId());
            result.add(node);
            parent = parent.getParent();
        }
        
        Collections.reverse(result);
        return new AmetysNodeList(result);
    }

    /**
     * Returns a DOM {@link Element} representing files and folder of the resources explorer, 
     * under the {@link ResourceCollection} corresponding to the given id.
     * @param collectionId the id of the root {@link ResourceCollection}.
     * @return an Element containing files and folders.
     */
    public static Node resourcesById(String collectionId)
    {
        ResourceCollection collection = _ametysObjectResolver.resolveById(collectionId);
        return new ResourceCollectionElement(collection);
    }
    
    /**
     * Returns a DOM {@link Element} representing files and folder of the resources explorer, 
     * under the {@link ResourceCollection} corresponding to the given path. <br>
     * This path is intended to be relative to the current site's resource explorer.
     * @param path the path of the root {@link ResourceCollection}, relative to the current site's resource explorer.
     * @return an Element containing files and folders or null if the specified resource does not exist.
     */
    public static Node resourcesByPath(String path)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        Site site = _siteManager.getSite(siteName);
        
        try
        {
            ResourceCollection collection = site.getRootResources().getChild(path);
            return new ResourceCollectionElement(collection);
        }
        catch (UnknownAmetysObjectException ex)
        {
            return null;
        }
    }

    /**
     * Returns a DOM {@link Element} representing a single file of the resources explorer. <br>
     * This path is intended to be relative to the current site's resource explorer.
     * @param path the path of the {@link Resource}, relative to the current site's resource explorer.
     * @return an Element containing a file or null if the specified resource does not exist.
     */
    public static Node resourceByPath(String path)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        Site site = _siteManager.getSite(siteName);

        try
        {
            Resource resource = site.getRootResources().getChild(path);
            return new ResourceElement(resource, null);
        }
        catch (UnknownAmetysObjectException ex)
        {
            return null;
        }
    }

    /**
     * Returns a DOM {@link Element} representing files and folder of a skin directory. <br>
     * This path is intended to be relative to the current skin's 'resources' directory.
     * @param path the path of the root {@link ResourceCollection}, relative to the current skin's 'resources' directory. Can be a file path to test its existance.
     * @return an Element containing files and folders. node name is 'collection' or 'resource' with an attribute 'name'. Return null if the path does not exits.
     * @throws IOException if an error occurred while listing files.
     */
    public static Node skinResources(String path) throws IOException
    {
        Source source = _sourceResolver.resolveURI("skin://resources/" + path);
        if (source.exists())
        {
            return new SourceElement(source);
        }
        else
        {
            return null;
        }
    }
    
    //*************************
    // Page methods
    //*************************
    
    /**
     * Get the site name of a page.
     * @param pageId The page id.
     * @return The name or empty if the page does not exist.
     */
    public static String pageSiteName(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getSiteName();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get site name on page with id '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Get the title of a page.
     * @param sitename the site name.
     * @param lang the sitemap name.
     * @param path the page path.
     * @return The name or empty if the meta or the page does not exist.
     */
    public static String pageTitle(String sitename, String lang, String path)
    {
        try
        {
            Page page = _getPage(sitename, lang, path);
            return page.getTitle();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.warn("Unknown page at path '" + sitename + "/" + lang + "/" + path + "'", e);
            return "";
        }
    }
    
    /**
     * Determines if page exists
     * @param sitename the site name.
     * @param lang the sitemap name.
     * @param path the page path.
     * @return <code>false</code> the page does not exist.
     */
    public static boolean pageExists(String sitename, String lang, String path)
    {
        try
        {
            _getPage(sitename, lang, path);
            return true;
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.debug("Page at path '" + sitename + "/" + lang + "/" + path + "' does not exists", e);
            return false;
        }
    }
    
    /**
     * Get the title of a page.
     * @param pageId The page id.
     * @return The name or empty if the meta or the page does not exist.
     */
    public static String pageTitle(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getTitle();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get title on page with id '" + pageId + "'", e);
            return "";
        }
    }

    /**
     * Get the long title of a page
     * @param sitename the site name
     * @param lang the page's language
     * @param path the page's path
     * @return The name or empty if the meta or the page does not exist
     */
    public static String pageLongTitle(String sitename, String lang, String path)
    {
        try
        {
            Page page = _getPage(sitename, lang, path);
            return page.getLongTitle();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get long title on page '" + sitename + "/" + lang + "/" + path + "'", e);
            return "";
        }
    }
    /**
     * Get the long title of a page
     * @param pageId The page id
     * @return The name or empty if the meta or the page does not exist
     */
    public static String pageLongTitle(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getLongTitle();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get long title on page with id '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Get the type of a page.
     * @param pageId The page id.
     * @return The type or empty if the page does not exist.
     */
    public static String pageType(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getType().name();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get type of page with id '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Get the linked url of a page.
     * @param pageId The page id.
     * @return The linked url or empty if the page does not exist or if it is not a LINK page
     */
    public static String pageUrl(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getType() == PageType.LINK ? page.getURL() : "";
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get type of page with id '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Get the linked URL type of a page.
     * @param pageId The page id.
     * @return The linked URL type or empty if the page does not exist or if it is not a LINK page
     */
    public static String pageUrlType(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getType() == PageType.LINK ? page.getURLType().name() : "";
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get type of page with id '" + pageId + "'", e);
            return "";
        }
    }

    /**
     * Get the data of a page at the given path
     * @param sitename the site name
     * @param lang the page's language
     * @param path the page's path
     * @param dataPath The data path (use '/' as separator for composites and repeaters)
     * @return The value or empty if the data or the page does not exist
     */
    public static String pageMetadata(String sitename, String lang, String path, String dataPath)
    {
        try
        {
            Page page = _getPage(sitename, lang, path);
            return _getPageData(page, dataPath);
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get data at path '" + dataPath + "' on page '" + sitename + "/" + lang + "/" + path + "'", e);
            return StringUtils.EMPTY;
        }
    }
    
    /**
     * Get the data of a page at the given path
     * @param pageId The page id
     * @param dataPath The data path (use '/' as separator for composites and repeaters)
     * @return The value or empty if the data or the page does not exist
     */
    public static String pageMetadata(String pageId, String dataPath)
    {
        try
        {
            Page page = _getPage(pageId);
            return _getPageData(page, dataPath);
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get data at path '" + dataPath + "' on page with id '" + pageId + "'", e);
            return StringUtils.EMPTY;
        }
    }
    
    @SuppressWarnings("unchecked")
    private static String _getPageData(Page page, String dataPath)
    {
        try
        {
            Object value = page.getValue(dataPath);
            if (value != null)
            {
                ModelItemType type = page.getType(dataPath);
                if (type instanceof ElementType)
                {
                    return ((ElementType) type).toString(value);
                }
            }

            _logger.error("Can not get data at path '" + dataPath + "' on page with id '" + page.getId() + "'");
            return StringUtils.EMPTY;
        }
        catch (Exception e)
        {
            _logger.error("Can not get data at path '" + dataPath + "' on page with id '" + page.getId() + "'", e);
            return StringUtils.EMPTY;
        }
    }

    /**
     * Returns true if the given page is visible into navigation elements
     * @param pageId the page id.
     * @return true if the page is visible
     */
    public static boolean pageIsVisible (String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.isVisible();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get visibility status on page with id '" + pageId + "'", e);
            return false;
        }
    }
    
    /**
     * Returns true if the given page is visible into navigation elements
     * @param sitename the site name
     * @param lang the page's language
     * @param path the page's path
     * @return true if the page is visible
     */
    public static boolean pageIsVisible (String sitename, String lang, String path)
    {
        try
        {
            Page page = _getPage(sitename, lang, path);
            return page.isVisible();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get visibility status on page with id '" + sitename + "/" + lang + "/" + path + "'", e);
            return false;
        }
    }
    
    /**
     * Returns true if the given page has restricted access.
     * @param pageId the page id.
     * @return true if the page exists and has restricted access.
     */
    public static boolean pageHasRestrictedAccess(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return !_rightManager.hasAnonymousReadAccess(page);
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get page access info on page with id '" + pageId + "'", e);
            return false;
        }
    }

    /**
     * Returns true if the current user has read access on the specified page
     * @param pageId Page Id
     * @return true if the current user has read access on the specified page
     */
    public static boolean hasReadAccessOnPage(String pageId)
    {
        Page page = _getPage(pageId);
        return _rightManager.currentUserHasReadAccess(page); 
    }
    
    /**
     * Returns true if the current user has the specified right on the current page
     * @param rightId Right Id
     * @return true if the current user has the specified right on the current page
     */
    public static boolean hasRightOnPage(String rightId)
    {
        Page page = _getPageFromRequest();
        return _hasRightOnPage(rightId, page);
    }

    /**
     * Returns true if the current user has the specified right on the specified page
     * @param rightId Right Id
     * @param pageId Page Id
     * @return true if the current user has the specified right on the specified page
     */
    public static boolean hasRightOnPage(String rightId, String pageId)
    {
        Page page = _getPage(pageId);
        return _hasRightOnPage(rightId, page);
    }

    /**
     * Returns true if the current user has the specified right on the specified page
     * @param rightId Right Id
     * @param page Page
     * @return true if the current user has the specified right on the specified page
     */
    private static boolean _hasRightOnPage(String rightId, Page page)
    {
        RightResult rightResult = _rightManager.currentUserHasRight(rightId, page);
        return rightResult == RightResult.RIGHT_ALLOW;
    }

    /**
     * Returns true if the given page has restricted access.
     * @param sitename the site name
     * @param lang the page's language
     * @param path the page's path
     * @return true if the page exists and has restricted access.
     */
    public static boolean pageHasRestrictedAccess(String sitename, String lang, String path)
    {
        try
        {
            Page page = _getPage(sitename, lang, path);
            return !_rightManager.hasAnonymousReadAccess(page);
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get page access info on page with id '" + sitename + "/" + lang + "/" + path + "'", e);
            return false;
        }
    }
    
    private static Page _getPage(String id)
    {
        return _ametysObjectResolver.resolveById(id);
    }
    
    private static Page _getPage(String sitename, String lang, String path)
    {
        Site site = _siteManager.getSite(sitename);
        Sitemap sitemap = site.getSitemap(lang);
        return sitemap.getChild(path);
    }
    
    private static Page _getPageFromRequest()
    {
        Request request = ContextHelper.getRequest(_context);
        return (Page) request.getAttribute(WebConstants.REQUEST_ATTR_PAGE);
    }
    
    /**
     * Returns the path of the current page, relative to the sitemap's root.
     * @return the path of the current Page, or empty if there's no current page.
     */
    public static String pagePath()
    {
        Page page = _getPageFromRequest();
        return page == null ? "" : page.getPathInSitemap();
    }
    
    /**
     * Returns the path in sitemap of a page
     * @param pageId The id of page
     * @return the path of the Page, or empty if not exists
     */
    public static String pagePath(String pageId)
    {
        try
        {
            Page page = _getPage(pageId);
            return page.getPathInSitemap();
        }
        catch (UnknownAmetysObjectException e)
        {
            _logger.error("Can not get title on page with id '" + pageId + "'", e);
            return "";
        }
    }
    
    /**
     * Returns the id of the current page.
     * @return the id of the current Page, or empty if there's no current page.
     */
    public static String pageId()
    {
        Page page = _getPageFromRequest();
        return page == null ? "" : page.getId();
    }
    
    private static Zone _getZone(Page page, String zoneName)
    {
        if (StringUtils.isNotBlank(zoneName) && page.hasZone(zoneName))
        {
            return page.getZone(zoneName);
        }
        
        return null;
    }
    
    private static Zone _getZoneFromRequest(Page page)
    {
        Request request = ContextHelper.getRequest(_context);
        String currentZoneName = (String) request.getAttribute(WebConstants.REQUEST_ATTR_ZONE_NAME);
        if (StringUtils.isNotBlank(currentZoneName) && page.hasZone(currentZoneName))
        {
            return page.getZone(currentZoneName);
        }
        
        return null;
    }
    
    /**
     * Returns the id of the current zone item id.
     * @return the id of the current zone item id, or empty if there's no current zone item.
     */
    public static String zoneItemId()
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        return zoneItem == null ? "" : StringUtils.defaultString(zoneItem.getId());
    }

    private static ZoneItem _getZoneItem(String id)
    {
        return _ametysObjectResolver.resolveById(id);
    }
    
    private static ZoneItem _getZoneItemFromRequest()
    {
        Request request = ContextHelper.getRequest(_context);
        return (ZoneItem) request.getAttribute(WebConstants.REQUEST_ATTR_ZONEITEM);
    }
    
    private static Content _getContentFromRequest()
    {
        Request request = ContextHelper.getRequest(_context);
        return (Content) request.getAttribute(Content.class.getName());
    }
    
    /**
     * Get the position of the current zone item in its zone
     * @return the position of the current zone item or -1 if there's no current zone item.
     */
    public static int zoneItemPosition()
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            Zone zone = zoneItem.getZone();
            int index = 1;
            
            AmetysObjectIterable< ? extends ZoneItem> zoneItems = zone.getZoneItems();
            for (ZoneItem childZoneItem : zoneItems)
            {
                if (childZoneItem.equals(zoneItem))
                {
                    return index;
                }
                index++;
            }
        }
        
        return -1;
    }
    
    /**
     * Determines if the current zone item or (if there is no current zone item) the current page is cacheable
     * This method is only valid for a page.
     * @return true if the current zone item or page is cacheable.
     */
    public static boolean isCacheable()
    {
        Request request = ContextHelper.getRequest(_context);
        if (request.getAttribute("IsZoneItemCacheable") != null)
        {
            return (Boolean) request.getAttribute("IsZoneItemCacheable");
        }
        
        // The method was called from the skin, out of a zone item
        Response response = ContextHelper.getResponse(_context);
        if (response.containsHeader("X-Ametys-Cacheable"))
        {
            return true;
        }
        return false;
    }
    
    /**
     * Determines if we are in an edition mode
     * @return true if we are in edition mode
     */
    public static boolean isEditionMode()
    {
        RenderingContext renderingContext = _renderingContextHandler.getRenderingContext();
        Request request = ContextHelper.getRequest(_context);
        if (renderingContext == RenderingContext.FRONT && request.getParameter("_edition") != null && "true".equals(request.getParameter("_edition")))
        {
            return true;
        }
        return false;
    }
    
    /**
     * Determines if a captcha is required on forms of the current page
     * @return  true if a captcha is required
     */
    public static boolean isCaptchaRequired()
    {
        Page page = _getPageFromRequest();
        return page == null || _pageHelper.isCaptchaRequired(page);
    }
    
    /**
     * Determines if a captcha is required on forms of the given ametys object
     * @param ametysObjectId the ametys object id. Can be a sitemap element or a zone item.
     * @return  true if a captcha is required
     */
    public static boolean isCaptchaRequired(String ametysObjectId)
    {
        if (StringUtils.isBlank(ametysObjectId))
        {
            // The given id is null, so return true for security
            return true;
        }
        
        AmetysObject ametysObject = _ametysObjectResolver.resolveById(ametysObjectId);
        if (ametysObject instanceof SitemapElement sitemapElement)
        {
            return _pageHelper.isCaptchaRequired(sitemapElement);
        }
        else if (ametysObject instanceof ZoneItem zoneItem)
        {
            return _pageHelper.isCaptchaRequired(zoneItem.getZone().getSitemapElement());
        }

        // The ametys object is not a sitemap element or a zone item, so return true for security
        return true;
    }

    /**
     * Returns the id of pages referencing the content and for which the Front-office user can access
     * @param contentId The content's id
     * @return The pages' id
     */
    public static NodeList accessibleReferencedPages (String contentId)
    {
        RenderingContext renderingContext = _renderingContextHandler.getRenderingContext();
        boolean inBackOffice = renderingContext == RenderingContext.BACK || renderingContext == RenderingContext.PREVIEW;
        
        List<StringElement> pages = new ArrayList<>(); 
        
        Content content = _ametysObjectResolver.resolveById(contentId);
        if (content instanceof WebContent)
        {
            Collection<ZoneItem> zoneItems = ((WebContent) content).getReferencingZoneItems();
            
            for (ZoneItem zoneItem : zoneItems)
            {
                String metadataSetName = zoneItem.getViewName();
                SitemapElement sitemapElement = zoneItem.getZone().getSitemapElement();
                
                if (sitemapElement instanceof Page page
                    && (inBackOffice || _rightManager.hasReadAccess(_currentUserProvider.getUser(), page)))
                {
                    Map<String, String> attrs = new HashMap<>();
                    attrs.put("id", page.getId());
                    attrs.put("metadataSetName", metadataSetName);
                    pages.add(new StringElement("page", attrs));
                }
            }
        }
        
        return new AmetysNodeList(pages);
    }
    
    /**
     * Returns the id of pages referencing the content
     * @param contentId The content's id
     * @return The pages' id
     */
    public static NodeList referencedPages (String contentId)
    {
        List<StringElement> pages = new ArrayList<>(); 
        
        Content content = _ametysObjectResolver.resolveById(contentId);
        if (content instanceof WebContent)
        {
            Collection<ZoneItem> zoneItems = ((WebContent) content).getReferencingZoneItems();
            
            for (ZoneItem zoneItem : zoneItems)
            {
                String metadataSetName = zoneItem.getViewName();
                SitemapElement sitemapElement = zoneItem.getZone().getSitemapElement();
                
                if (sitemapElement instanceof Page page)
                {
                    Map<String, String> attrs = new HashMap<>();
                    attrs.put("id", page.getId());
                    attrs.put("metadataSetName", metadataSetName);
                    pages.add(new StringElement("page", attrs));
                }
            }
        }
        
        return new AmetysNodeList(pages);
    }
    
    /**
     * Returns the ids of the contents
     * @param tag The tag id
     * @return Array of contents ids
     */
    public static NodeList findContentsIdsByTag(String tag)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");

        String lang = (String) request.getAttribute("sitemapLanguage");
        if (lang == null)
        {
            // Try to get current language from content
            Content content = (Content) request.getAttribute(Content.class.getName());
            if (content != null)
            {
                lang = content.getLanguage();
            }
        }
        return findContentsIdsByTag(siteName, lang, tag);
    }

    /**
     * Returns the ids of the contents
     * @param sitename site name. '+' for any site, '*'/null for any site, including contents without site, '^' for only contents without site
     * @param lang lang of the contents
     * @param tag The tag id
     * @return Array of contents ids
     */
    public static NodeList findContentsIdsByTag(String sitename, String lang, String tag)
    {
        List<Expression> expressions = new ArrayList<>();
        TagExpression tagExpression = new TagExpression(Operator.EQ, tag);
        expressions.add(tagExpression);

        if (lang != null && !lang.equals("*"))
        {
            LanguageExpression le = new LanguageExpression(Operator.EQ, lang);
            expressions.add(le);
        }

        if (sitename != null)
        {
            ExpressionContext siteExpressionContext = ExpressionContext.newInstance().withInternal(true);
            if (sitename.equals("+"))
            {
                MetadataExpression me = new MetadataExpression("site", siteExpressionContext);
                expressions.add(me);
            }
            else if (sitename.equals("*"))
            {
                // no filter
            }
            else if (sitename.equals("^"))
            {
                MetadataExpression me = new MetadataExpression("site", siteExpressionContext);
                expressions.add(new NotExpression(me));
            }
            else
            {
                StringExpression se = new StringExpression("site", Operator.EQ, sitename, siteExpressionContext);
                expressions.add(se);
            }
        }

        Expression[] expressionsArray = expressions.toArray(new Expression[expressions.size()]);

        String xpath = ContentQueryHelper.getContentXPathQuery(new AndExpression(expressionsArray));
        AmetysObjectIterable<Content> contents = _ametysObjectResolver.query(xpath);
        Iterator<Content> it = contents.iterator();

        List<StringElement> list = new ArrayList<>();
        while (it.hasNext())
        {
            list.add(new StringElement("content", "id", it.next().getId()));
        }
        return new AmetysNodeList(list);
    }

    /**
     * Returns the ids of the pages tagged with the specified tag
     * @param sitename The site id
     * @param lang The language code
     * @param tag The tag id
     * @return Array of pages ids
     */
    public static NodeList findPagesIdsByTag(String sitename, String lang, String tag)
    {
        return findPagesIdsByTag(sitename, lang, tag, false);
    }
    
    /**
     * Returns the ids of the pages tagged with the specified tag
     * @param sitename The site id
     * @param lang The language code
     * @param tag The tag id
     * @param checkReadAccess true to return only pages with read access for current user
     * @return Array of pages ids
     */
    public static NodeList findPagesIdsByTag(String sitename, String lang, String tag, boolean checkReadAccess)
    {
        List<StringElement> list = new ArrayList<>(); 
        for (String pageId : _pageDAO.findPagedIdsByTag(sitename, lang, tag))
        {
            if (!checkReadAccess || _hasReadAccess(pageId))
            {
                list.add(new StringElement("page", "id", pageId));
            }
        }

        return new AmetysNodeList(list);
    }
    
    private static boolean _hasReadAccess(String pageId)
    {
        try
        {
            Page page = _ametysObjectResolver.resolveById(pageId);
            return _rightManager.currentUserHasReadAccess(page);
        }
        catch (UnknownAmetysObjectException e)
        {
            return false;
        }
    }
    
    /**
     * Returns the ids of the pages tagged with the specified tag
     * @param tag The tag id
     * @return Array of pages ids
     */
    public static NodeList findPagesIdsByTag(String tag)
    {
        return findPagesIdsByTag(tag, false);
    }
    
    /**
     * Returns the ids of the pages tagged with the specified tag
     * @param tag The tag id
     * @param checkReadAccess true to return only pages with read access for current user
     * @return Array of pages ids
     */
    public static NodeList findPagesIdsByTag(String tag, boolean checkReadAccess)
    {
        Request request = ContextHelper.getRequest(_context);
        String siteName = (String) request.getAttribute("site");
        
        String lang = (String) request.getAttribute("sitemapLanguage");
        if (lang == null)
        {
            // Try to get current language from content
            Content content = (Content) request.getAttribute(Content.class.getName());
            if (content != null)
            {
                lang = content.getLanguage();
            }
        }
        
        return findPagesIdsByTag(siteName, lang, tag, checkReadAccess);
    }
    
    
    /**
     * Return the given user by its email over all authorized population on current site
     * @param email the concerned user's email
     * @return The informations about the given user
     * @throws SAXException If an error occurred while saxing the user
     */
    public static Node userByMail(String email) throws SAXException
    {
        String siteName = site();
        
        Set<String> userPopulationsOnSite = _populationContextHelper.getUserPopulationsOnContexts(Arrays.asList("/sites/" + siteName, "/sites-fo/" + siteName), false, false);
        
        for (String populationId : userPopulationsOnSite)
        {
            Node user = userByMail(email, populationId);
            if (user != null)
            {
                return user;
            }
        }
        
        return null;
    }
    
    /**
     * Get the preview of a url (title, description, image, favico)
     * @param url the web link
     * @return the url preview
     * @throws SAXException If an error occurred while saxing
     */
    public static Node urlPreview(String url) throws SAXException
    {
        try
        {
            String lang = StringUtils.defaultIfEmpty(lang(), "en");
            UrlPreview urlPreview = _urlPreview.getUrlPreview(url, lang);
            DOMBuilder domBuilder = new DOMBuilder();
            
            urlPreview.toSAX(domBuilder, "preview");
            
            return domBuilder.getDocument();
        }
        catch (IOException e)
        {
            _logger.error("Unable to get preview URL at " + url, e);
            return null;
        }
    }
    
    /**
     * Generates a XML structure to help to creates a complex pagination. 
     * <br>
     * <br>Example: pagination(39, 19, 2, 5, 2) will return
     * 
     * <pre>
     *   &lt;gotofirstpage enabled="true"&gt;1&lt;/gotofirstpage&gt;
     *   &lt;gotopreviouspage enabled="true"&gt;18&lt;/gotopreviouspage&gt;
     *   &lt;page&gt;1&lt;/page&gt;
     *   &lt;page&gt;2&lt;/page&gt;
     *   &lt;separator/&gt;
     *   &lt;page&gt;17&lt;/page&gt;
     *   &lt;page&gt;18&lt;/page&gt;
     *   &lt;current&gt;19&lt;/current&gt;
     *   &lt;page&gt;20&lt;/page&gt;
     *   &lt;page&gt;21&lt;/page&gt;
     *   &lt;separator/&gt;
     *   &lt;page&gt;38&lt;/page&gt;
     *   &lt;page&gt;39&lt;/page&gt;
     *   &lt;gotonextpage enabled="true"&gt;20&lt;/gotonextpage&gt;
     *   &lt;gotolastpage enabled="true"&gt;39&lt;/gotonextpage&gt;
     * </pre>
     *   
     * Example: pagination(5, 2, 2, 5, 2) will return
     *   
     * <pre>
     *   &lt;gotofirstpage enabled="true"&gt;1&lt;/gotofirstpage&gt;
     *   &lt;gotopreviouspage enabled="true"&gt;1&lt;/gotopreviouspage&gt;
     *   &lt;page&gt;1&lt;/page&gt;
     *   &lt;current&gt;2&lt;/page&gt;
     *   &lt;page&gt;3&lt;/page&gt;
     *   &lt;page&gt;4&lt;/page&gt;
     *   &lt;page&gt;5&lt;/page&gt;
     *   &lt;space/&gt;
     *   &lt;space/&gt;
     *   &lt;space/&gt;
     *   &lt;space/&gt;
     *   &lt;gotonextpage enabled="true"&gt;3&lt;/gotonextpage&gt;
     *   &lt;gotolastpage enabled="true"&gt;5&lt;/gotonextpage&gt;
     * </pre>
     *   
     * @param nbPages The total number of pages
     * @param currentPage The currently displayed page (1 based)
     * @param nbFirstPages The max number of pages to display before the 1st separator
     * @param nbCentralPages The max number of pages to display around the current page
     * @param nbLastPages The max number of pages to display after the 2nd separator
     * @return The xml described
     */
    public static AmetysNodeList pagination(int nbPages, int currentPage, int nbFirstPages, int nbCentralPages, int nbLastPages)
    {
        List<Node> elements = new ArrayList<>();

        
        elements.add(new StringElement("gotofirstpage", "enabled", Boolean.toString(currentPage > 1), "1"));
        elements.add(new StringElement("gotopreviouspage", "enabled", Boolean.toString(currentPage > 1), currentPage > 1 ? currentPage - 1 + "" : ""));

        int[] pagination = _pagination(nbPages, currentPage, nbFirstPages, nbCentralPages, nbLastPages);
        for (int page : pagination)
        {
            if (page == _PAGINATION_SEPARATOR)
            {
                elements.add(new StringElement("separator", ""));
            }
            else if (page == _PAGINATION_SPACE)
            {
                elements.add(new StringElement("space", ""));
            }
            else if (page == _PAGINATION_CURRENT)
            {
                elements.add(new StringElement("current", Integer.toString(currentPage)));
            }
            else
            {
                elements.add(new StringElement("page", Integer.toString(page)));
            }
        }
        
        elements.add(new StringElement("gotonextpage", "enabled", Boolean.toString(currentPage < nbPages), currentPage < nbPages ? currentPage + 1 + "" : ""));
        elements.add(new StringElement("gotolastpage", "enabled", Boolean.toString(currentPage < nbPages), nbPages + ""));

        return new AmetysNodeList(elements);
    }
    
    static int[] _pagination(int nbPages, int currentPage, int nbFirstPages, int nbCentralPages, int nbLastPages)
    {
        int displayedPages = nbFirstPages + 1 + nbCentralPages + 1 + nbLastPages;  // The +1 are the room for separators
        
        int[] values = new int[displayedPages];

        int centerOfCentralPages = (int) Math.ceil(nbCentralPages / 2.0);
        int centralCursor = nbFirstPages + 1 + centerOfCentralPages;
        boolean firstSeparator = nbPages > displayedPages && currentPage > centralCursor;
        boolean secondSeparator = nbPages > displayedPages && currentPage <= nbPages - centralCursor;
        
        int cursor = 1;
        
        // Before first separator
        cursor = _paginationFirstPages(nbPages, nbFirstPages, currentPage, values, cursor);
        
        // First separator
        cursor = _paginationFirstSeparator(nbPages, firstSeparator, currentPage, values, cursor);

        int offset = _paginationComputeOffsetAfterFirstSeparator(nbPages, currentPage, nbCentralPages, nbLastPages, centerOfCentralPages, firstSeparator, secondSeparator, cursor);
        
        // Middle part
        cursor = _paginationMiddle(nbPages, currentPage, nbFirstPages, nbCentralPages, values, cursor, offset);
        
        // Second separator
        cursor = _paginationSecondSeparator(nbPages, secondSeparator, currentPage, nbLastPages, values, cursor, offset);
        
        // After second separator
        cursor = _paginationLastPages(nbPages, currentPage, displayedPages, values, cursor, offset);
        
        return values;
    }

    private static int _paginationMiddle(int nbPages, int currentPage, int nbFirstPages, int nbCentralPages, int[] values, int cursorP, int offset)
    {
        int cursor = cursorP;
        for (; cursor <= nbFirstPages + 1 + nbCentralPages; cursor++)
        {
            if (cursor + offset > nbPages)
            {
                values[cursor - 1] = _PAGINATION_SPACE;
            }
            else if (cursor + offset == currentPage)
            {
                values[cursor - 1] = _PAGINATION_CURRENT;
            }
            else
            {
                values[cursor - 1] = offset + cursor;
            }
        }
        return cursor;
    }

    private static int _paginationComputeOffsetAfterFirstSeparator(int nbPages, int currentPage, int nbCentralPages, int nbLastPages, int centerOfCentralPages, boolean firstSeparator, boolean secondSeparator, int cursor)
    {
        if (!firstSeparator)
        {
            return 0;
        }
        else if (!secondSeparator)
        {
            return nbPages - nbLastPages - nbCentralPages - cursor;
        }
        else
        {
            return currentPage + 1 - centerOfCentralPages - cursor;
        }
    }

    private static int _paginationLastPages(int nbPages, int currentPage, int displayedPages, int[] values, int cursorP, int offset)
    {
        int cursor = cursorP;
        for (; cursor <= displayedPages; cursor++)
        {
            if (cursor > nbPages)
            {
                values[cursor - 1] = _PAGINATION_SPACE;
            }
            else if (cursor + offset == currentPage)
            {
                values[cursor - 1] = _PAGINATION_CURRENT;
            }
            else 
            {
                values[cursor - 1] = nbPages - (displayedPages - cursor);
            }
        }
        return cursor;
    }

    private static int _paginationSecondSeparator(int nbPages, boolean secondSeparator, int currentPage, int nbLastPages, int[] values, int cursor, int offset)
    {
        if (cursor + offset > nbPages)
        {
            values[cursor - 1] = _PAGINATION_SPACE;
        }
        else if (currentPage == cursor + offset)
        {
            values[cursor - 1] = _PAGINATION_CURRENT;
        }
        else if (secondSeparator)
        {
            values[cursor - 1] = _PAGINATION_SEPARATOR;
        }
        else 
        {
            values[cursor - 1] = nbPages - nbLastPages;
        }
        return cursor + 1;
    }

    private static int _paginationFirstSeparator(int nbPages, boolean firstSeparator, int currentPage, int[] values, int cursor)
    {
        if (cursor > nbPages)
        {
            values[cursor - 1] = _PAGINATION_SPACE;
        }
        else if (currentPage == cursor)
        {
            values[cursor - 1] = _PAGINATION_CURRENT;
        }
        else if (firstSeparator)
        {
            values[cursor - 1] = _PAGINATION_SEPARATOR;
        }
        else 
        {
            values[cursor - 1] = cursor;
        }
        return cursor + 1;
    }

    private static int _paginationFirstPages(int nbPages, int nbFirstPages, int currentPage, int[] values, int cursorP)
    {
        int cursor = cursorP;
        for (; cursor <= nbFirstPages; cursor++)
        {
            if (cursor > nbPages)
            {
                values[cursor - 1] = _PAGINATION_SPACE;
            }
            else if (cursor == currentPage)
            {
                values[cursor - 1] = _PAGINATION_CURRENT;
            }
            else 
            {
                values[cursor - 1] = cursor;
            }
        }
        return cursor;
    }
    
    /**
     * Get the parameters' values of the current template
     * @return the values of template's parameters
     */
    public static Node templateParameters()
    {
        Map<String, MapNode> parameters = new HashMap<>();
        
        Page page = _getPageFromRequest();
        if (page != null)
        {
            Optional<ViewParametersModel> viewParametersModelOptional = _viewParametersManager.getTemplateViewParametersModel(page.getSite().getSkinId(), page.getTemplate());
            if (viewParametersModelOptional.isPresent())
            {
                ViewParametersModel viewParametersModel = viewParametersModelOptional.get();
                
                Collection< ? extends ModelItem> modelItems = viewParametersModel.getModelItems();
                for (ModelItem modelItem : modelItems)
                {
                    Optional<ViewParameterHolder> templateParameterHolderOptional = _viewParametersManager.getTemplateViewParameterHolderWithInheritance(page, modelItem);
                    if (templateParameterHolderOptional.isPresent())
                    {
                        ViewParameterHolder templateParameterHolder = templateParameterHolderOptional.get();
                        Map<String, MapNode> values = _getParameterValue(templateParameterHolder.getPath(), modelItem, templateParameterHolder.getDataHolder(), null);
                        if (values != null)
                        {
                            parameters.putAll(values);
                        }
                    }
                }
            }
        }
        
        return new MapElement("templateParameters", parameters);
    }
    
    /**
     * Returns the value of the given parameter for the current page template, or the empty node if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current page template.
     */
    public static NodeList templateParameter(String parameterPath)
    {
        return templateParameter(null, parameterPath);
    }
    
    /**
     * Returns the value of the given parameter for the given page template, or the empty node if the parameter does not exist.
     * @param pageId the page id
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the given page template.
     */
    public static NodeList templateParameter(String pageId, String parameterPath)
    {
        Page page = StringUtils.isNotBlank(pageId) ? _getPage(pageId) : _getPageFromRequest();
        if (page != null)
        {
            Optional<ViewParameterHolder> templateParameterHolderOptional = _viewParametersManager.getTemplateViewParameterHolderWithInheritance(page, parameterPath);
            if (templateParameterHolderOptional.isPresent())
            {
                ViewParameterHolder templateParameterHolder = templateParameterHolderOptional.get();
                List<Node> values = _getNodeValues(templateParameterHolder.getDataHolder(), templateParameterHolder.getPath(), null);
                if (values != null)
                {
                    return new AmetysNodeList(values);
                }
            }
        }
        
        return null;
    }
    
    /**
     * Get the parameters of the current zone
     * @return the zone's parameters
     */
    public static Node zoneParameters()
    {
        return zoneParameters(null);
    }
    
    /**
     * Get the parameters of a given zone
     * @param zoneName The zone's name. Can be null or empty to get the current zone.
     * @return the zone's parameters
     */
    public static Node zoneParameters(String zoneName)
    {
        Map<String, MapNode> parameters = new HashMap<>();
        
        Page page = _getPageFromRequest();
        if (page != null)
        {
            Zone zone = _getZoneForParameter(page, zoneName);
            if (zone != null)
            {
                Optional<ViewParametersModel> viewParametersModelOptional = _viewParametersManager.getZoneViewParametersModel(page.getSite().getSkinId(), page.getTemplate(), zone.getName());
                if (viewParametersModelOptional.isPresent())
                {
                    ViewParametersModel viewParametersModel = viewParametersModelOptional.get();
                    
                    Collection< ? extends ModelItem> modelItems = viewParametersModel.getModelItems();
                    for (ModelItem modelItem : modelItems)
                    {
                        Optional<ViewParameterHolder> zoneParameterHolderOptional = _viewParametersManager.getZoneViewParameterHolderWithInheritance(page, zone, modelItem);
                        if (zoneParameterHolderOptional.isPresent())
                        {
                            ViewParameterHolder zoneParameterHolder = zoneParameterHolderOptional.get();
                            Map<String, MapNode> values = _getParameterValue(zoneParameterHolder.getPath(), modelItem, zoneParameterHolder.getDataHolder(), null);
                            if (values != null)
                            {
                                parameters.putAll(values);
                            }
                        }
                    }
                }
            }
        }
        
        return new MapElement("zoneParameters", parameters);
    }
    
    /**
     * Returns the value of the given parameter for the current page and current zone, or the empty node if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current page and current zone.
     */
    public static NodeList zoneParameter(String parameterPath)
    {
        return zoneParameter(null, null, parameterPath);
    }
    
    /**
     * Returns the value of the given parameter for the current page and given zone, or the empty node if the parameter does not exist.
     * @param zoneName the zone name
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current page and given zone.
     */
    public static NodeList zoneParameter(String zoneName, String parameterPath)
    {
        return zoneParameter(null, zoneName, parameterPath);
    }
    
    /**
     * Returns the value of the given parameter for the given page and given zone name, or the empty node if the parameter does not exist.
     * @param pageId the page id
     * @param zoneName the zone name
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the given page and given zone name.
     */
    public static NodeList zoneParameter(String pageId, String zoneName, String parameterPath)
    {
        Page page = StringUtils.isNotBlank(pageId) ? _getPage(pageId) : _getPageFromRequest();
        if (page != null)
        {
            Zone zone = _getZoneForParameter(page, zoneName);
            if (zone != null)
            {
                Optional<ViewParameterHolder> zoneParameterHolderOptional = _viewParametersManager.getZoneViewParameterHolderWithInheritance(page, zone, parameterPath);
                if (zoneParameterHolderOptional.isPresent())
                {
                    ViewParameterHolder zoneParameterHolder = zoneParameterHolderOptional.get();
                    List<Node> values = _getNodeValues(zoneParameterHolder.getDataHolder(), zoneParameterHolder.getPath(), null);
                    if (values != null)
                    {
                        return new AmetysNodeList(values);
                    }
                }
            }
        }
        
        return null;
    }
    
    /**
     * Get the parameters of the current zone item
     * @return the zone items's  parameters
     */
    public static Node zoneItemParameters()
    {
        return zoneItemParameters(null);
    }
    
    /**
     * Get the parameters of a given zone item
     * @param zoneItemId The id of zone item. Can be null or empty to get the current zone item
     * @return the zone items's  parameters
     */
    public static Node zoneItemParameters(String zoneItemId)
    {
        Map<String, MapNode> parameters = new HashMap<>();
        
        ZoneItem zoneItem = StringUtils.isNotBlank(zoneItemId) ? _getZoneItem(zoneItemId) : _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            Optional<ViewParametersModel> viewParametersModelOptional = _viewParametersManager.getZoneItemViewParametersModel(zoneItem);
            if (viewParametersModelOptional.isPresent())
            {
                Collection< ? extends ModelItem> modelItems = viewParametersModelOptional.get().getModelItems();
                for (ModelItem modelItem : modelItems)
                {
                    Map<String, MapNode> values = _getParameterValue(modelItem.getPath(), modelItem, zoneItem.getZoneItemParametersHolder(), null);
                    if (values != null)
                    {
                        parameters.putAll(values);
                    }
                }
            }
        }
        
        return new MapElement("zoneItemParameters", parameters);
    }
    
    /**
     * Returns the value of the given parameter for the current zone item, or the empty node if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current zone item.
     */
    public static NodeList zoneItemParameter(String parameterPath)
    {
        return zoneItemParameter(null, parameterPath);
    }
    
    /**
     * Returns the value of the given parameter for the given zone item, or the empty node if the parameter does not exist.
     * @param zoneItemId the zone item id
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the given zone item.
     */
    public static NodeList zoneItemParameter(String zoneItemId, String parameterPath)
    {
        ZoneItem zoneItem = StringUtils.isNotBlank(zoneItemId) ? _getZoneItem(zoneItemId) : _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            ModelAwareDataHolder dataHolder = zoneItem.getZoneItemParametersHolder();
            List<Node> values = _getNodeValues(dataHolder, parameterPath, null);
            if (values != null)
            {
                return new AmetysNodeList(values);
            }
        }
        
        return null;
    }
    
    /**
     * Get the parameters of the current service
     * @return the service's parameters
     */
    public static Node serviceViewParameters()
    {
        Map<String, MapNode> parameters = new HashMap<>();

        ZoneItem zoneItem = _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            if (zoneItem.getType() == ZoneType.SERVICE)
            {
                Optional<ViewParametersModel> serviceViewParametersModel = _viewParametersManager.getServiceViewParametersModel(zoneItem);
                if (serviceViewParametersModel.isPresent())
                {
                    String viewName = zoneItem.getServiceParameters().getValue(ViewParametersManager.SERVICE_VIEW_DEFAULT_MODEL_ITEM_NAME);
                    
                    Collection< ? extends ModelItem> modelItems = serviceViewParametersModel.get().getModelItems();
                    for (ModelItem modelItem : modelItems)
                    {
                        Map<String, MapNode> values = _getParameterValue(modelItem.getPath(), modelItem, zoneItem.getServiceViewParametersHolder(viewName), null);
                        if (values != null)
                        {
                            parameters.putAll(values);
                        }
                    }
                }
            }
        }
        
        return new MapElement("serviceViewParameters", parameters);
    }
    
    /**
     * Returns the value of the given parameter for the current service, or the empty node if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current service.
     */
    public static NodeList serviceViewParameter(String parameterPath)
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            if (zoneItem.getType() == ZoneType.SERVICE)
            {
                Optional<ModelAwareDataHolder> serviceViewParametersHolder = _viewParametersManager.getServiceViewParametersHolder(zoneItem);
                if (serviceViewParametersHolder.isPresent())
                {
                    List<Node> values = _getNodeValues(serviceViewParametersHolder.get(), parameterPath, null);
                    if (values != null)
                    {
                        return new AmetysNodeList(values);
                    }
                }
            }
        }
        
        return null;
    }
    
    /**
     * Get the parameters of the current content
     * @return the content's parameters
     */
    public static Node contentViewParameters()
    {
        Map<String, MapNode> parameters = new HashMap<>();
        
        ZoneItem zoneItem = _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            if (zoneItem.getType() == ZoneType.CONTENT)
            {
                Content content = _getContentFromRequest();
                Content zoneItemContent = zoneItem.getContent();
                
                // Test if the content in the zone item is the same in the request. For example, can have different content if a content call the method AmetysXSLTHelper#getContentView
                if (content != null && content.getId().equals(zoneItemContent.getId()))
                {
                    Optional<ViewParametersModel> contentViewParametersModel = _viewParametersManager.getContentViewParametersModel(zoneItem);
                    if (contentViewParametersModel.isPresent())
                    {
                        String viewName = zoneItem.getViewName();
                        Collection< ? extends ModelItem> modelItems = contentViewParametersModel.get().getModelItems();
                        for (ModelItem modelItem : modelItems)
                        {
                            Map<String, MapNode> values = _getParameterValue(modelItem.getPath(), modelItem, zoneItem.getContentViewParametersHolder(viewName), null);
                            if (values != null)
                            {
                                parameters.putAll(values);
                            }
                        }
                    }
                }
            }
        }
        
        return new MapElement("contentViewParameters", parameters);
    }
    
    /**
     * Returns the value of the given parameter for the current content, or the empty node if the parameter does not exist.
     * @param parameterPath the parameter path.
     * @return the value of the given parameter for the current content.
     */
    public static NodeList contentViewParameter(String parameterPath)
    {
        ZoneItem zoneItem = _getZoneItemFromRequest();
        if (zoneItem != null)
        {
            if (zoneItem.getType() == ZoneType.CONTENT)
            {
                Content content = _getContentFromRequest();
                Content zoneItemContent = zoneItem.getContent();
                
                // Test if the content in the zone item is the same in the request. For example, can have different content if a content call the method AmetysXSLTHelper#getContentView
                if (content != null && content.getId().equals(zoneItemContent.getId()))
                {
                    Optional<ModelAwareDataHolder> contentViewParametersHolder = _viewParametersManager.getContentViewParametersHolder(zoneItem);
                    if (contentViewParametersHolder.isPresent())
                    {
                        DataContext context = RepositoryDataContext.newInstance()
                                                                   .withObject(content);
                        
                        List<Node> values = _getNodeValues(contentViewParametersHolder.get(), parameterPath, null, context);
                        if (values != null)
                        {
                            return new AmetysNodeList(values);
                        }
                    }
                }
            }
        }
        
        return null;
    }
    
    private static Zone _getZoneForParameter(Page page, String zoneName)
    {
        Zone zone = _getZone(page, zoneName);
        if (zone == null)
        {
            zone = _getZoneFromRequest(page);
            if (zone == null)
            {
                ZoneItem zoneItem = _getZoneItemFromRequest();
                if (zoneItem != null)
                {
                    zone = zoneItem.getZone();
                }
            }
        }
        
        return zone;
    }
}