/*
 *  Copyright 2015 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.repository.page;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.LocaleUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentDAO.TagMode;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.tag.CMSTag;
import org.ametys.cms.tag.CMSTag.TagVisibility;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.cms.trash.element.TrashElementDAO;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.observation.Observer;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
import org.ametys.plugins.explorer.ExplorerNode;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.SimpleAmetysObject;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.tag.TaggableAmetysObject;
import org.ametys.plugins.repository.trash.TrashElement;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.web.ObservationConstants;
import org.ametys.web.WebConstants;
import org.ametys.web.alias.Alias.TargetType;
import org.ametys.web.alias.AliasHelper;
import org.ametys.web.alias.DefaultAlias;
import org.ametys.web.repository.content.SharedContent;
import org.ametys.web.repository.content.WebContent;
import org.ametys.web.repository.content.shared.SharedContentManager;
import org.ametys.web.repository.page.Page.LinkType;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.page.ZoneItem.ZoneType;
import org.ametys.web.repository.page.jcr.DefaultPage;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.rights.PageRightAssignmentContext;
import org.ametys.web.service.Service;
import org.ametys.web.service.ServiceExtensionPoint;
import org.ametys.web.site.CopyUpdaterExtensionPoint;
import org.ametys.web.skin.Skin;
import org.ametys.web.skin.SkinTemplate;
import org.ametys.web.skin.SkinTemplateZone;
import org.ametys.web.skin.SkinsManager;
import org.ametys.web.skin.TemplatesAssignmentHandler;
import org.ametys.web.synchronization.SynchronizeComponent;
import org.ametys.web.tags.TagExpression;

/**
 * DAO for manipulating pages
 */
public class PageDAO extends AbstractSitemapElementsDAO implements Component, Initializable, Observer, Serviceable
{
    /** Constant for untouched binary metadata. */
    public static final String __SERVICE_PARAM_UNTOUCHED_BINARY = "untouched";
    
    /** Avalon Role */
    public static final String ROLE = PageDAO.class.getName();
    
    /** Constant for the {@link Cache} id for the pages in cache by sitename, lang, tag */
    private static final String MEMORY_PAGESTAGCACHE = PageDAO.class.getName() + "$PagesUUIDByTag";
    
    private AmetysObjectResolver _resolver;
    private ObservationManager _observationManager;
    private CurrentUserProvider _currentUserProvider;
    private SkinsManager _skinsManager;
    private TemplatesAssignmentHandler _templatesHandler;
    private ServicesAssignmentHandler _serviceHandler;
    private ContentTypesAssignmentHandler _cTypeHandler;
    private ContentTypeExtensionPoint _contentTypeExtensionPoint;
    private ServiceExtensionPoint _serviceExtensionPoint;
    private WorkflowProvider _workflowProvider;
    private SharedContentManager _sharedContentManager;
    private TagProviderExtensionPoint _tagProvider;
    private CopySiteComponent _copySiteComponent;
    private RightManager _rightManager;
    private SynchronizeComponent _synchronizeComponent;
    private Repository _repository;
    private AmetysObjectResolver _ametysObjectResolver;
    private AbstractCacheManager _cacheManager;
    private CopyUpdaterExtensionPoint _copyUpdaterEP;
    private TrashElementDAO _trashElementDAO;
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }
    
    @Override
    public void deferredService(ServiceManager manager) throws ServiceException
    {
        super.deferredService(manager);
        
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _skinsManager = (SkinsManager) manager.lookup(SkinsManager.ROLE);
        _templatesHandler = (TemplatesAssignmentHandler) manager.lookup(TemplatesAssignmentHandler.ROLE);
        _cTypeHandler = (ContentTypesAssignmentHandler) manager.lookup(ContentTypesAssignmentHandler.ROLE);
        _serviceHandler = (ServicesAssignmentHandler) manager.lookup(ServicesAssignmentHandler.ROLE);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _serviceExtensionPoint = (ServiceExtensionPoint) manager.lookup(ServiceExtensionPoint.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _sharedContentManager = (SharedContentManager) manager.lookup(SharedContentManager.ROLE);
        _tagProvider = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
        _copySiteComponent = (CopySiteComponent) manager.lookup(CopySiteComponent.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _synchronizeComponent = (SynchronizeComponent) manager.lookup(SynchronizeComponent.ROLE);
        _repository = (Repository) manager.lookup(Repository.class.getName());
        _copyUpdaterEP = (CopyUpdaterExtensionPoint) manager.lookup(CopyUpdaterExtensionPoint.ROLE);
        _trashElementDAO = (TrashElementDAO) manager.lookup(org.ametys.plugins.repository.trash.TrashElementDAO.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _createCaches();
        _observationManager.registerObserver(this);
    }
    
    private void _createCaches()
    {
        _cacheManager.createMemoryCache(MEMORY_PAGESTAGCACHE,
                new I18nizableText("plugin.web", "PLUGINS_WEB_PAGEDAO_CACHE_PAGES_BY_TAG_LABEL"),
                new I18nizableText("plugin.web", "PLUGINS_WEB_PAGEDAO_CACHE_PAGES_BY_TAG_DESCRIPTION"),
                true,
                null);
    }
    
    public int getPriority()
    {
        return 0;
    }
    
    public boolean supports(Event event)
    {
        return event.getId().equals(ObservationConstants.EVENT_PAGE_UPDATED) && event.getArguments().containsKey(ObservationConstants.ARGS_PAGE_TAGS);
    }
    
    public void observe(Event event, Map<String, Object> transientVars) throws Exception
    {
        Page page = (Page) event.getArguments().get(ObservationConstants.ARGS_PAGE);
        if (page != null)
        {
            _getMemoryPageTagCache().invalidate(PageTagCacheKey.of(page.getSiteName(), page.getSitemapName()));
        }
    }

    /**
     * Get the properties of given pages
     * @param pageIds the id of pages
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation.
     * @return the properties of pages in a result map
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getPagesInfos (List<String> pageIds, String zoneName, String zoneItemId)
    {
        // Assume that no read access is checked (required for bus message target)
        Map<String, Object> result = new HashMap<>();
        
        List<Map<String, Object>> pages = new ArrayList<>();
        List<String> pagesNotFound = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            try
            {
                Page page = _resolver.resolveById(pageId);
                pages.add(getPageInfos(page, zoneName, zoneItemId));
            }
            catch (UnknownAmetysObjectException e)
            {
                pagesNotFound.add(pageId);
            }
        }
        
        result.put("pages", pages);
        result.put("pagesNotFound", pagesNotFound);
        
        return result;
    }
    
    /**
     * Get the properties of given pages
     * @param pageIds the id of pages
     * @return the properties of pages in a result map
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getPagesInfos (List<String> pageIds)
    {
        // Assume that no read access is checked (required for bus message target)
        return getPagesInfos(pageIds, null, null);
    }
    
    /**
     * Get the page's properties
     * @param pageId the page ID
     * @return the properties
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getPageInfos (String pageId)
    {
        // Assume that no read access is checked (required for bus message target)
        return getPageInfos(pageId, null, null);
    }
    
    /**
     * Get the page's properties
     * @param pageId the page ID
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation.
     * @return the properties
     */
    public Map<String, Object> getPageInfos (String pageId, String zoneName, String zoneItemId)
    {
        // Assume that no read access is checked (required for bus message target)
        Page page = _resolver.resolveById(pageId);
        return getPageInfos(page, zoneName, zoneItemId);
    }

    /**
     * Get the page's properties
     * @param page the page
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation.
     * @return the properties
     */
    public Map<String, Object> getPageInfos (Page page, String zoneName, String zoneItemId)
    {
        Map<String, Object> infos = new HashMap<>();
        boolean isLocked = page instanceof LockablePage lockablePage && lockablePage.isLocked();
        infos.put("id", page.getId());
        infos.put("name", page.getName());
        infos.put("parentId", page.getParent().getId());
        infos.put("title", page.getTitle());
        infos.put("longTitle", page.getLongTitle());
        infos.put("path", page.getPathInSitemap());
        infos.put("siteName", page.getSiteName());
        infos.put("type", page.getType());
        infos.put("lang", page.getSitemapName());
        infos.put("isModifiable", page instanceof ModifiablePage);
        infos.put("isMoveable", page instanceof MoveablePage && !isLocked);
        infos.put("isTaggable", page instanceof TaggableAmetysObject);
        infos.put("isVisible", page.isVisible());
        infos.put("isParentInvisible", _isParentInvisible(page));
        infos.put("locked", isLocked);
        
        // Publication information
        infos.put("publication", _publication2Json(page));
        infos.put("isPreviewable", _isPreviewable(page));
        
        // limitation information
        if (StringUtils.isNotBlank(zoneName))
        {
            infos.put("zoneName", zoneName);
        }
        if (StringUtils.isNotBlank(zoneItemId))
        {
            infos.put("zoneItemId", zoneItemId);
        }

        String skinId = page.getSite().getSkinId();
        Skin skin = _skinsManager.getSkin(skinId);
        infos.put("isPageValid", _synchronizeComponent.isPageValid(page, skin));

        Session liveSession = null;
        try
        {
            liveSession = _repository.login(WebConstants.LIVE_WORKSPACE);
            infos.put("isLiveHierarchyValid", _synchronizeComponent.isHierarchyValid(page, liveSession));
        }
        catch (RepositoryException e)
        {
            throw new RuntimeException("Unable to check live workspace", e);
        }
        finally
        {
            if (liveSession != null)
            {
                liveSession.logout();
            }
        }

        PageType type = page.getType();
        switch (type)
        {
            case CONTAINER:
                infos.putAll(_sitemapElement2json(page, zoneName, zoneItemId));
                break;
            
            case LINK:
                infos.put("url", page.getURL());
                
                LinkType urlType = page.getURLType();
                infos.put("urlType", urlType.toString());
                
                switch (urlType)
                {
                    case PAGE:
                        try
                        {
                            Page targetPage = _resolver.resolveById(page.getURL());
                            infos.put("urlTitle", targetPage.getTitle());
                        }
                        catch (UnknownAmetysObjectException e)
                        {
                            getLogger().error("Page '" + page.getId() + "' redirects to an unexisting page '" + page.getURL() + "'");
                        }
                        break;

                    default:
                        break;
                }
                break;
            default:
                AmetysObjectIterator< ? extends Page> iterator = page.getChildrenPages().iterator();
                if (iterator.hasNext())
                {
                    Page firstSubPage = iterator.next();
                    infos.put("url", firstSubPage.getId());
                    infos.put("urlTitle", firstSubPage.getTitle());
                    infos.put("urlType", LinkType.PAGE.toString());
                    break;

                }
                break;
        }
        
        
        infos.put("rights", getUserRights(page));
        
        return infos;
    }
    
    /**
     * Get the page's properties
     * @param page the page
     * @return the properties
     */
    public Map<String, Object> getPageInfos (Page page)
    {
        return getPageInfos(page, null, null);
    }
    
    /**
     * Check current user right on given page or sitemap
     * @param id The id of the page or sitemap
     * @param rightId The if of right to check
     * @return true if user has right
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public boolean hasRight(String id, String rightId)
    {
        UserIdentity user = _currentUserProvider.getUser();
        SitemapElement page = _resolver.resolveById(id);
        
        return _rightManager.hasRight(user, rightId, page) == RightResult.RIGHT_ALLOW;
    }
    
    /**
     * Create a new page
     * @param parentId The parent id. Can not be null.
     * @param title The page's title. Can not be null.
     * @param longTitle The page's long title. Can be null or blank.
     * @return The result map with id of created page
     */
    @Callable (rights = "Web_Rights_Page_Create", rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> createPage (String parentId, String title, String longTitle)
    {
        Map<String, Object> result = new HashMap<>();
        
        SitemapElement parent = _resolver.resolveById(parentId);
        
        assert parent instanceof ModifiableSitemapElement;
        
        try
        {
            ModifiablePage page = createPage((ModifiableSitemapElement) parent, null, title, longTitle);
            result.put("id", page.getId());
            result.put("parentId", parent.getId());
            result.put("lang", page.getSitemapName());
            result.put("title", page.getTitle());
        }
        catch (IllegalArgumentException e)
        {
            result.put("invalid-name", title);
        }
        return result;
    }

    /**
     * Create a new page blank page.
     * 
     * In the case where {@code name} is {@code null}, the value of title will be used.
     * In all case, the name (or title) will be used to derive the page name (and therefore
     * path by filtering it with {@link NameHelper#filterName(String)} and appending an integer
     * if a page with the same name already exist.
     * 
     * @param parent the sitemap element where the new page is created
     * @param name the name to use as path for the page. (if null, the title will be used)
     * @param title the title of the page
     * @param longTitle the long title of the page
     * @return The result map with id of the created page
     * @throws IllegalArgumentException If the provided name (or title) can not be used in URI
     */
    public ModifiablePage createPage(ModifiableSitemapElement parent, String name, String title, String longTitle) throws IllegalArgumentException
    {
        Site site = parent.getSite();
        
        String pageName = PageDAO.findFreePageNameByTitle(parent, name != null ? name : title);
        
        ModifiablePage page = parent.createChild(pageName, "ametys:defaultPage");
        
        page.setTitle(title);
        page.setType(PageType.NODE);
        page.setSiteName(site.getName());
        page.setSitemapName(page.getSitemap().getName());
        
        if (!StringUtils.isBlank(longTitle))
        {
            page.setLongTitle(longTitle);
        }
        
        site.saveChanges();
        
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PAGE, page);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_ADDED, _currentUserProvider.getUser(), eventParams));
        
        return page;
    }

    /**
     * Copy a page
     * @param id The id of page to copy
     * @param target The id of parent target page
     * @param keepReferences true to keep references
     * @return the result map
     * @throws RepositoryException if an error occurred during copy
     */
    @Callable (rights = "Web_Rights_Page_Create", rightContext = PageRightAssignmentContext.ID, paramIndex = 1)
    public Map<String, String> copyPage (String id, String target, boolean keepReferences) throws RepositoryException
    {
        Map<String, String> result = new HashMap<>();
        
        Page page = _resolver.resolveById(id);
        
        if (!(page instanceof CopiableAmetysObject))
        {
            throw new IllegalArgumentException("The page '" + page.getId() + "' is not a copiable ametys object, it can not be copied");
        }
        
        if (!(page instanceof JCRAmetysObject))
        {
            throw new IllegalArgumentException("The page '" + page.getId() + "' is not a JCR ametys object, it can not be copied");
        }
        
        SitemapElement parent = _resolver.resolveById(target);
        
        if (parent instanceof ModifiableSitemapElement modifiableParent)
        {
            ModifiablePage cPage = null;
            
            String initialTitle;
            if (page instanceof DefaultPage defaultPage)
            {
                initialTitle = defaultPage.getInitialTitle();
            }
            else
            {
                initialTitle = page.getTitle();
            }
            
            String newPageName = PageDAO.findFreePageNameByTitle(parent, initialTitle);
            
            if (!keepReferences)
            {
                // Restrict the copy to the page and its current children to avoid infinitive loop
                List<String> pagesToCopy = new ArrayList<>();
                pagesToCopy.add(page.getId());
                pagesToCopy.addAll(_getChildrenPageIds(page));
                
                // Copy and duplicate contents
                cPage = (ModifiablePage) ((CopiableAmetysObject) page).copyTo(modifiableParent, newPageName, pagesToCopy);
                _copySiteComponent.updateReferencesAfterCopy(page, cPage);
                
                // Creates the first version on all copied contents
                _updateContentsAfterCopy(page, cPage);
            }
            else
            {
                // Copy without duplicating contents (keep references)
                
                if (!page.getSitemapName().equals(modifiableParent.getSitemapName()))
                {
                    throw new IllegalArgumentException("The page '" + page.getId() + "' from sitemap '" + page.getSitemapName() + "' cannot be copied to a different sitemap '" + parent.getSitemapName() + "' while keeping references to contents");
                }
                
                
                String pagePath = ((SimpleAmetysObject) parent).getNode().getPath() + "/" + newPageName;
                Node node = ((JCRAmetysObject) page).getNode();
                node.getSession().getWorkspace().copy(node.getPath(), pagePath);
                
                cPage = modifiableParent.getChild(newPageName);
            }
            
            cPage.setTitle(PageDAO.findFreeTitle(modifiableParent, initialTitle));
            if (cPage instanceof DefaultPage defaultPage)
            {
                defaultPage.setInitialTitle(initialTitle);
            }
            
            ((ModifiableTraversableAmetysObject) parent).saveChanges();
            result.put("id", cPage.getId());
            
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, cPage);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_ADDED, _currentUserProvider.getUser(), eventParams));
        }
       
        return result;
    }

    /**
     * find a free name under a given parent node
     * @param parent The parent
     * @param initialTitle The title of the page
     * @return The free name
     */
    public static String findFreePageNameByTitle(TraversableAmetysObject parent, String initialTitle)
    {
        return findFreePageNameByTitle(parent, initialTitle, null);
    }
    
    /**
     * find a free name under a given parent node
     * @param parent The parent
     * @param initialTitle The title of the page
     * @param currentName The current name of the node, that can thus be authorized
     * @return The free name
     */
    public static String findFreePageNameByTitle(TraversableAmetysObject parent, String initialTitle, String currentName)
    {
        String originalPageName = NameHelper.filterName(initialTitle);
        
        return findFreePageName(parent, originalPageName, currentName);
    }

    /**
     * find a free name under a given parent node
     * @param parent The parent
     * @param originalPageName The name of the page
     * @return The free name
     */
    public static String findFreePageName(TraversableAmetysObject parent, String originalPageName)
    {
        return findFreePageName(parent, originalPageName, null);
    }
    
    /**
     * find a free name under a given parent node
     * @param parent The parent
     * @param originalPageName The name of the page
     * @param currentName The current name of the node, that can thus be authorized
     * @return The free name
     */
    public static String findFreePageName(TraversableAmetysObject parent, String originalPageName, String currentName)
    {
        int index = 2;
        
        String pageName = originalPageName;
        while (parent.hasChild(pageName) && !pageName.equals(currentName))
        {
            // Find unused name on new parent node
            pageName = originalPageName + "-" + index++;
        }
        return pageName;
    }
    
    /**
     * find a free title under a given parent node
     * @param parent The parent
     * @param initialTitle The title of the page
     * @return The free title
     */
    public static String findFreeTitle(SitemapElement parent, String initialTitle)
    {
        List<String> existingTitles = parent.getChildrenPages().stream().map(Page::getTitle).toList();
        
        int index = 2;
        
        String title = initialTitle;
        while (existingTitles.contains(title))
        {
            title = initialTitle + " (" + index++ + ")";
        }
        
        return title;
    }
    
    /**
     * Copy a page under another page
     * @param targetId the page to copy in
     * @param sourceId the page to copy
     * @param keepReferences true to keep references for contents, or false to duplicate contents
     * @return The id of created page is a result map.
     * @throws RepositoryException if an error occurs
     */
    @Callable (rights = "Web_Rights_Page_Create", rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    @Deprecated
    public Map<String, String> pastePage(String targetId, String sourceId, boolean keepReferences) throws RepositoryException
    {
        return copyPage(sourceId, targetId, keepReferences);
    }
    
    /**
     * Move a page
     * @param id The page id
     * @param parentId The id of parent destination
     * @param index The position in parent child nodes where page will be inserted. -1 means as the last child.
     * @return the result map
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> movePage (String id, String parentId, int index)
    {
        Map<String, Object> result = new HashMap<>();
        
        String oldPathInSitemap = null;
        String newPathInSitemap = null;
     
        Page page = _resolver.resolveById(id);
        SitemapElement srcParent = page.getParent();
        oldPathInSitemap = page.getPathInSitemap();
        Sitemap sitemap = page.getSitemap();
        
        // check rights of deletion on old parent page
        if (!srcParent.getId().equals(parentId) && !_canDelete(page))
        {
            throw new IllegalStateException("You do not have the rights to delete the page '/" + page.getSitemapName() + "/" + oldPathInSitemap + "'");
        }
        
        if (!(page instanceof MoveablePage))
        {
            throw new IllegalArgumentException("The page '/" + page.getSitemapName() + "/" + oldPathInSitemap + "' is not a moveable page");
        }
        
        if (srcParent.getId().equals(parentId) && index != -1)
        {
            try
            {
                // in case of reorder, check right of creation on current parent page
                if (!_canCreate(srcParent))
                {
                    throw new IllegalStateException("You do not have to reorder a page under '/" + srcParent.getSitemapName() + "/" + srcParent.getPathInSitemap() + "'");
                }
                
                Page brother = srcParent.getChildPageAt(index);
                ((MoveablePage) page).orderBefore(brother);
            }
            catch (UnknownAmetysObjectException e)
            {
                // Move the last child position
                ((MoveablePage) page).orderBefore(null);
            }
            
            // Path is not modified
            newPathInSitemap = oldPathInSitemap;
        }
        else
        {
            SitemapElement newParentPage = _resolver.resolveById(parentId);
            
            if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
            {
                throw new IllegalStateException("You cannot move page '/" + lockablePage.getSitemapName() + "/" + lockablePage.getPathInSitemap() + "' because it is locked");
            }

            // check right of creation on new parent page
            if (!_canCreate(newParentPage))
            {
                throw new IllegalStateException("You do not have the rights to create a page under '/" + newParentPage.getSitemapName() + "/" + newParentPage.getPathInSitemap() + "'");
            }

            ((MoveablePage) page).moveTo(newParentPage, true);
            if (index != -1)
            {
                Page brother = newParentPage.getChildPageAt(index);
                
                ((MoveablePage) page).orderBefore(brother);
            }
            
            // Path is modified
            newPathInSitemap = page.getPathInSitemap();
        }
        
        if (sitemap.needsSave())
        {
            sitemap.saveChanges();
        }

        // Notify observers that the page has been moved
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_SITEMAP, sitemap);
        eventParams.put(ObservationConstants.ARGS_PAGE, page);
        eventParams.put("page.old.path", oldPathInSitemap);
        eventParams.put("page.old.parent", srcParent);
        eventParams.put(ObservationConstants.ARGS_PAGE_PATH, newPathInSitemap);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_MOVED, _currentUserProvider.getUser(), eventParams));
        
        result.put("id", page.getId());
        result.put("parentId", page.getParent().getId());
        
        return result;
    }
    
    private boolean _canCreate(SitemapElement parentPage)
    {
        UserIdentity user = _currentUserProvider.getUser();
        if (_rightManager.hasRight(user, "Web_Rights_Page_Create", parentPage) == RightResult.RIGHT_ALLOW)
        {
            return true;
        }
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("The user '" + user + "' tried to create page under '/" + parentPage.getSitemapName() + "/" + parentPage.getPathInSitemap() + "' without sufficient rights");
        }
        
        return false;
    }
    
    private boolean _canDelete(Page page)
    {
        UserIdentity user = _currentUserProvider.getUser();
        SitemapElement parent = page.getParent();
        if (_rightManager.hasRight(user, "Web_Rights_Page_Delete", parent) == RightResult.RIGHT_ALLOW)
        {
            return true;
        }
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("The user '" + user + "' tried to move page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "' without sufficient rights");
        }
        
        return false;
    }
    
    /**
     * Set pages as redirection
     * @param pageIds the id of pages to modify
     * @param url the url of redirection
     * @param urlType the type of redirection
     * @return the id of pages which succeeded or failed.
     */
    @Callable (rights =  Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> setLink (List<String> pageIds, String url, String urlType)
    {
        List<String> allRightIds = new ArrayList<>();
        List<Map<String, Object>> noRightPages = new ArrayList<>();
        List<Map<String, Object>> errorPages = new ArrayList<>();
        List<Map<String, Object>> noModifiablePages = new ArrayList<>();
        List<Map<String, Object>> lockedPages = new ArrayList<>();
        
        if (StringUtils.isEmpty(url))
        {
            throw new IllegalArgumentException("Can not set page as a redirection with an empty url");
        }
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            
            try
            {
                if (_rightManager.currentUserHasRight("Web_Rights_Page_LinkPage", page) != RightResult.RIGHT_ALLOW)
                {
                    noRightPages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else if (!(page instanceof ModifiablePage))
                {
                    noModifiablePages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
                {
                    lockedPages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else
                {
                    ModifiablePage mPage = (ModifiablePage) page;
                    
                    if (page.getType().equals(PageType.CONTAINER))
                    {
                        // Remove zones
                        for (ModifiableZone zone : mPage.getZones())
                        {
                            zone.remove();
                        }
                    }
                    
                    if (pageId.equals(url))
                    {
                        throw new IllegalArgumentException("A page can not redirect to itself");
                    }
                    
                    mPage.setType(PageType.LINK);
                    mPage.setURL(LinkType.valueOf(urlType), url);
                    mPage.getSitemap().saveChanges();
                    
                    allRightIds.add(pageId);
                    
                    Map<String, Object> eventParams = new HashMap<>();
                    eventParams.put(ObservationConstants.ARGS_PAGE, page);
                    _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
                }
            }
            catch (Exception e)
            {
                getLogger().error("Cannot set the page '" + pageId + "' as link [" + url + ", " + urlType.toString() + "]", e);
                errorPages.add(Map.of("id", pageId, "title", page.getTitle()));
            }
        }

        return Map.of("allright-pages", allRightIds, "noright-pages", noRightPages, "error-pages", errorPages, "nomodifiable-pages", noModifiablePages, "locked-pages", lockedPages);
    }
    
    /**
     * Get available template for specified page
     * @param pageId The page's id
     * @return the list of available template as JSON
     */
    private List<Map<String, Object>> _getAvailableTemplates (String pageId)
    {
        List<Map<String, Object>> templates = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        Set<String> availableTemplateIds = _templatesHandler.getAvailablesTemplates(page);
        for (String templateName : availableTemplateIds)
        {
            String skinId = page.getSite().getSkinId();
            Skin skin = _skinsManager.getSkin(skinId);
            
            SkinTemplate template = skin.getTemplate(templateName);
            
            Map<String, Object> template2json = new HashMap<>();
            template2json.put("id", template.getId());
            template2json.put("label", template.getLabel());
            template2json.put("description", template.getDescription());
            template2json.put("iconSmall", template.getSmallImage());
            template2json.put("iconMedium", template.getMediumImage());
            template2json.put("iconLarge", template.getLargeImage());
            template2json.put("zone", template.getDefaultZoneId());
            
            templates.add(template2json);
        }
        
        return templates;
    }
    
    /**
     * Get available content types for specified page
     * @param pageId The page's id
     * @param zoneName the name of the zone
     * @return the list of available content types
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public List<Map<String, Object>> getAvailableContentTypes (String pageId, String zoneName)
    {
        List<Map<String, Object>> contenttypes = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        Set<String> contentTypeIds = _cTypeHandler.getAvailableContentTypes(page, zoneName);
        for (String contentTypeId : contentTypeIds)
        {
            ContentType cType = _contentTypeExtensionPoint.getExtension(contentTypeId);
            
            if (cType != null && _hasRight(cType, page))
            {
                Map<String, Object> ctype2json = new HashMap<>();
                ctype2json.put("id", cType.getId());
                ctype2json.put("label", cType.getLabel());
                ctype2json.put("description", cType.getDescription());
                ctype2json.put("iconGlyph", cType.getIconGlyph());
                ctype2json.put("iconDecorator", cType.getIconDecorator());
                ctype2json.put("iconSmall", cType.getSmallIcon());
                ctype2json.put("iconMedium", cType.getMediumIcon());
                ctype2json.put("iconLarge", cType.getLargeIcon());
                ctype2json.put("defaultTitle", cType.getDefaultTitle());
                ctype2json.put("viewNames", cType.getViewNames(true));
                ctype2json.put("category", cType.getCategory().isI18n() ? cType.getCategory().getKey() : cType.getCategory().getLabel());
                ctype2json.put("categoryLabel", cType.getCategory());
                
                contenttypes.add(ctype2json);
            }
        }
        
        return contenttypes;
    }
    
    /**
     * Get available content types for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param zoneName the name of the zone
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @param template The template of page to create
     * @return the list of available services
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public List<Map<String, Object>> getAvailableContentTypesForCreation(String pageId, String zoneName, String parentId, String pageTitle, String template)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available services for a page
            return getAvailableContentTypes(pageId, zoneName);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available services for a not yet existing page
            SitemapElement parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, template);
            
            List<Map<String, Object>> availableContentTypes = getAvailableContentTypes(page.getId(), zoneName);
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableContentTypes;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    private boolean _hasRight(ContentType contentType, Page page)
    {
        String right = contentType.getRight();
        
        if (right == null)
        {
            return true;
        }
        else
        {
            UserIdentity user = _currentUserProvider.getUser();
            return _rightManager.hasRight(user, right, page) == RightResult.RIGHT_ALLOW;
        }
    }
    
    /**
     * Get available services for specified page
     * @param pageId The page's id
     * @param zoneName the name of the zone
     * @return the list of available services
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public List<Map<String, Object>> getAvailableServices (String pageId, String zoneName)
    {
        List<Map<String, Object>> services = new ArrayList<>();
        
        SitemapElement sitemapElement = _resolver.resolveById(pageId);
        
        Set<String> serviceIds = _serviceHandler.getAvailableServices(sitemapElement, zoneName);
        for (String serviceId : serviceIds)
        {
            Service service = _serviceExtensionPoint.getExtension(serviceId);
            if (service != null && _hasRight(service, sitemapElement))
            {
                Map<String, Object> serviceMap = new HashMap<>();
                serviceMap.put("id", service.getId());
                serviceMap.put("label", service.getLabel());
                serviceMap.put("description", service.getDescription());
                serviceMap.put("iconGlyph", service.getIconGlyph());
                serviceMap.put("iconDecorator", service.getIconDecorator());
                serviceMap.put("iconSmall", service.getSmallIcon());
                serviceMap.put("iconMedium", service.getMediumIcon());
                serviceMap.put("iconLarge", service.getLargeIcon());
                serviceMap.put("parametersAction", service.getParametersScript().getScriptClassname());
                serviceMap.put("category", service.getCategory().isI18n() ? service.getCategory().getKey() : service.getCategory().getLabel());
                serviceMap.put("categoryLabel", service.getCategory());
                
                services.add(serviceMap);
            }
        }
        
        return services;
    }
    
    /**
     * Get available services for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param zoneName the name of the zone
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @param template The template of page to create
     * @return the list of available services
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public List<Map<String, Object>> getAvailableServicesForCreation(String pageId, String zoneName, String parentId, String pageTitle, String template)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available services for a page
            return getAvailableServices(pageId, zoneName);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available services for a not yet existing page
            SitemapElement parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, template);
            
            List<Map<String, Object>> availableServices = getAvailableServices(page.getId(), zoneName);
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableServices;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    private Page _createPage (SitemapElement parent, String pageTitle, String template)
    {
        Site site = parent.getSite();
        
        String pageName = PageDAO.findFreePageNameByTitle(parent, pageTitle);
        
        ModifiablePage page = ((ModifiableTraversableAmetysObject) parent).createChild(pageName, "ametys:defaultPage");
        
        page.setTitle(pageTitle);
        page.setType(PageType.NODE);
        page.setSiteName(site.getName());
        page.setSitemapName(page.getSitemap().getName());

        if (template != null)
        {
            String skinId = page.getSite().getSkinId();
            SkinTemplate tpl = _skinsManager.getSkin(skinId).getTemplate(template);
            if (tpl == null)
            {
                throw new IllegalStateException("Template '" + template + "' does not exist on skin '" + skinId + "'");
            }
            
            // Set temporary the template to get available services
            page.setType(PageType.CONTAINER);
            page.setTemplate(template);
        }
        
        return page;
    }
    
    private boolean _hasRight(Service service, SitemapElement sitemapElement)
    {
        String right = service.getRight();
        
        if (right == null)
        {
            return true;
        }
        else
        {
            UserIdentity user = _currentUserProvider.getUser();
            return _rightManager.hasRight(user, right, sitemapElement) == RightResult.RIGHT_ALLOW;
        }
    }
    
    /**
     * Get available content types for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @return the list of available services
     */
    @Callable (rights = "Web_Rights_Page_Create", rightContext = PageRightAssignmentContext.ID, paramIndex = 1)
    public List<Map<String, Object>> getAvailableTemplatesForCreation (String pageId, String parentId, String pageTitle)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available template for a page
            return _getAvailableTemplates(pageId);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available template for a not yet existing page
            SitemapElement parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, null);
            
            List<Map<String, Object>> availableTemplates = _getAvailableTemplates(page.getId());
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableTemplates;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    /**
     * Get service info
     * @param pageId Optional, the page id of the service. To get some basic info about the page.
     * @param serviceId The id of the service
     * @return a Map containing some info about the service (label, url..)
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> getServiceInfo(String pageId, String serviceId)
    {
        Map<String, Object> info = new HashMap<>();
        
        if (StringUtils.isNotEmpty(pageId))
        {
            SitemapElement sitemapElement = _resolver.resolveById(pageId);
            info.put("page-id", sitemapElement.getId());
            info.put("page-title", sitemapElement.getTitle());
        }

        Service service = _serviceExtensionPoint.getExtension(serviceId);
        info.put("id", service.getId());
        info.put("label", service.getLabel());
        info.put("url", service.getURL());
        info.put("smallIcon", service.getSmallIcon());
        info.put("iconGlyph", service.getIconGlyph());
        info.put("iconDecorator", service.getIconDecorator());
        return info;
    }
    
    /**
     * Rename a page
     * @param pageId The id of page to rename
     * @param title The page's  title
     * @param longTitle The page's long title.
     * @param updatePath true to update page's path
     * @param createAlias true to create a alias
     * @return the result map
     */
    @Callable (rights = "Web_Rights_Page_Rename", rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> renamePage (String pageId, String title, String longTitle, boolean updatePath, boolean createAlias)
    {
        Map<String, Object> result = new HashMap<>();
        
        Page page = _resolver.resolveById(pageId);
        
        if (!(page instanceof ModifiablePage))
        {
            throw new IllegalArgumentException("Can not rename a non-modifiable page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
        {
            throw new IllegalArgumentException("Can not rename a locked page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        ModifiablePage mPage = (ModifiablePage) page;
        mPage.setTitle(title);
        mPage.setLongTitle(longTitle);

        if (updatePath)
        {
            String oldPathInSitemap = page.getPathInSitemap();
            String oldPath = "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + ".html";
            String oldPathForChild = "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "/**.html";

            String pageName = "";
            try
            {
                pageName = PageDAO.findFreePageNameByTitle(mPage.getParent(), title, page.getName());
            }
            catch (IllegalArgumentException e)
            {
                result.put("invalid-name", title);
                return result;
            }
            
            if (!page.getName().equals(pageName))
            {
                mPage.rename(pageName);
                
                if (createAlias)
                {
                    ModifiableTraversableAmetysObject rootNode = AliasHelper.getRootNode(page.getSite());
                    
                    DefaultAlias alias = rootNode.createChild(AliasHelper.getAliasNextUniqueName(rootNode), "ametys:alias");
                    alias.setUrl(oldPath);
                    alias.setTarget(page.getId());
                    alias.setType(TargetType.PAGE);
                    alias.setCreationDate(new Date());

                    // Alias for child pages
                    alias = rootNode.createChild(AliasHelper.getAliasNextUniqueName(rootNode), "ametys:alias");
                    alias.setUrl(oldPathForChild);
                    alias.setTarget("/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "/{1}.html");
                    alias.setType(TargetType.URL);
                    alias.setCreationDate(new Date());

                    rootNode.saveChanges();
                }
                
                // Notify observers that the page has been renamed
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                eventParams.put("path.old.path", oldPathInSitemap);
                eventParams.put(ObservationConstants.ARGS_PAGE_PATH, page.getPathInSitemap());
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_RENAMED, _currentUserProvider.getUser(), eventParams));
                
            }
            else
            {
                // Notify observers that the page's title has been modified
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
            }
                
        }
        else
        {
            // Notify observers that the page's title has been modified
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, page);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
        }
        
        Sitemap sitemap = page.getSitemap();
        if (sitemap.needsSave())
        {
            sitemap.saveChanges();
        }
        
        result.put("id", page.getId());
        result.put("path", page.getPath());
        result.put("title", page.getTitle());
        
        return result;
    }
    
    /**
     * Unlock or lock page
     * @param pageId the id of the page to unlock or lock
     * @param mode the mode ('lock' or 'unlock')
     * @return the result JSON map
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> unlockOrLock(String pageId, String mode)
    {
        Map<String, Object> result = new HashMap<>();
        
        UserIdentity currentUser = _currentUserProvider.getUser();
        LockablePage lockablePage = (LockablePage) _resolver.resolveById(pageId);
        boolean canChangeLockStatus = _rightManager.hasRight(currentUser, "Web_Rights_Page_Lock", "/cms") == RightResult.RIGHT_ALLOW  && _rightManager.currentUserHasReadAccess(lockablePage);
        
        boolean unlock = "unlock".equals(mode);
        
        if (!canChangeLockStatus)
        {
            getLogger().warn("The user '" + currentUser + "' tried to unlock or lock page '" + pageId + "' but does not have the right");
            result.put("error", unlock ? "still-locked-page" : "fail-locked-page");
        }
        
        if (unlock && !lockablePage.isLocked())
        {
            getLogger().warn("The page '" + pageId + "' is not locked anymore.");
        }
        else if (!unlock && lockablePage.isLocked())
        {
            getLogger().warn("The page '" + pageId + "' is already locked.");
            result.put("error", "already-locked-page");
        }
        else
        {
            try
            {
                if (unlock)
                {
                    lockablePage.unlock();
                    if (getLogger().isDebugEnabled())
                    {
                        getLogger().debug("The user has unlocked page '" + pageId + "'");
                    }
                }
                else
                {
                    lockablePage.lock();
                }
                
                lockablePage.saveChanges();
                
            }
            catch (AmetysRepositoryException e)
            {
                getLogger().error("Unable to lock or unlock page '" + pageId + "'", e);
                result.put("error", unlock ? "fail-unlocked-page" : "fail-locked-page");
            }
        }
        
        result.put("pageId", pageId);
        result.put("pageTitle", lockablePage.getTitle());
        result.put("mode", mode);
        return result;
    }
    
    /**
     * Delete a page and its sub-pages.
     * The contents that belong only to the deleted page will be deleted if 'deleteBelongingContents' is set to true.
     * The newly created contents are deleted whatever the value if 'deleteBelongingContents'.
     * @param pageId the id of page to delete
     * @param deleteBelongingContents true to delete the contents that belong to the page and its sub-pages only
     * @return The id of deleted pages
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> deletePage(String pageId, boolean deleteBelongingContents)
    {
        ModifiablePage page = _resolver.resolveById(pageId);
        
        // Check rights on parent
        if (!_canDelete(page))
        {
            throw new IllegalStateException("You do not have the rights to delete the page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
        {
            throw new IllegalStateException("Can not delete the locked page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        return deletePage(page, deleteBelongingContents);
    }
    
    /**
     * Delete a page and its sub-pages.
     * The contents that belong only to the deleted page will be deleted if 'deleteBelongingContents' is set to true.
     * The newly created contents are deleted whatever the value if 'deleteBelongingContents'.
     * @param page the page to delete
     * @param deleteBelongingContents true to delete the contents that belong to the page and its sub-pages only
     * @return The id of deleted pages
     */
    public Map<String, Object> deletePage(ModifiablePage page, boolean deleteBelongingContents)
    {
        Map<String, Object> result = new HashMap<>();
        
        PageHierarchy pageHierarchy = _getPageContents(page, true);
        List<String> contentsToDelete = _getDeleteablePageContentIds(pageHierarchy, !deleteBelongingContents);
        
        Sitemap sitemap = page.getSitemap();
        SitemapElement parent = page.getParent();
        String pagePathInSitemap = page.getPathInSitemap();
        
        List<String> childPagesIds = _getChildrenPageIds(page);
        
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PAGE_ID, page.getId());
        eventParams.put(ObservationConstants.ARGS_PAGE_PARENT, parent);
        eventParams.put(ObservationConstants.ARGS_PAGE_PATH, pagePathInSitemap);
        eventParams.put(ObservationConstants.ARGS_SITEMAP, sitemap);
        eventParams.put(ObservationConstants.ARGS_PAGE_CONTENTS, getPageContents(page));
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_DELETING, _currentUserProvider.getUser(), eventParams));
        
        // FIXME API test if this is not modifiable
        page.getParent();
        
        if (page instanceof TrashableAmetysObject trashableAO)
        {
            _trashElementDAO.trash(trashableAO, false, pageHierarchy.contents().stream().map(Content::getId).toArray(String[]::new));
            
            result.put("trashed", true);
        }
        else
        {
            page.remove();
            ((ModifiableAmetysObject) parent).saveChanges();
        }
        
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_DELETED, _currentUserProvider.getUser(), eventParams));
        
        result.put("id", page.getId());
        result.put("childPages", childPagesIds);
        result.putAll(_contentDAO.trashContents(contentsToDelete, true));
        
        for (String contentId : contentsToDelete)
        {
            TrashElement trashElement = _trashElementDAO.find(contentId);
            if (trashElement != null)
            {
                trashElement.setHidden(true);
                trashElement.saveChanges();
                
                // Notify observers
                eventParams = new HashMap<>();
                eventParams.put(org.ametys.cms.ObservationConstants.ARGS_TRASH_ELEMENT_ID, trashElement.getId());
                eventParams.put(org.ametys.cms.ObservationConstants.ARGS_AMETYS_OBJECT_ID, contentId);
                _observationManager.notify(new Event(org.ametys.cms.ObservationConstants.EVENT_TRASH_UPDATED, _currentUserProvider.getUser(), eventParams));
            }
        }
        
        return result;
    }
    
    /**
     * Set pages as blank page
     * @param pageIds the id of pages to modify
     * @return the id of pages which succeeded or failed.
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> setBlank (List<String> pageIds)
    {
        List<String> allRightIds = new ArrayList<>();
        List<Map<String, Object>> noRightPages = new ArrayList<>();
        List<Map<String, Object>> errorPages = new ArrayList<>();
        List<Map<String, Object>> noModifiablePages = new ArrayList<>();
        List<Map<String, Object>> lockedPages = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            
            try
            {
                if (_rightManager.currentUserHasRight("Web_Rights_Page_BlankPage", page) != RightResult.RIGHT_ALLOW)
                {
                    noRightPages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else if (!(page instanceof ModifiablePage))
                {
                    noModifiablePages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
                {
                    lockedPages.add(Map.of("id", pageId, "title", page.getTitle()));
                }
                else
                {
                    ModifiablePage mPage = (ModifiablePage) page;
                    
                    if (page.getType().equals(PageType.CONTAINER))
                    {
                        // Remove zones
                        for (ModifiableZone zone : mPage.getZones())
                        {
                            zone.remove();
                        }
                    }
                    
                    mPage.setType(PageType.NODE);
                    mPage.getSitemap().saveChanges();
                    
                    allRightIds.add(pageId);
                    
                    Map<String, Object> eventParams = new HashMap<>();
                    eventParams.put(ObservationConstants.ARGS_PAGE, page);
                    _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
                }
            }
            catch (Exception e)
            {
                getLogger().error("Cannot set the page '" + pageId + "' as blank page", e);
                errorPages.add(Map.of("id", pageId, "title", page.getTitle()));
            }
        }

        return Map.of("allright-pages", allRightIds, "noright-pages", noRightPages, "error-pages", errorPages, "nomodifiable-pages", noModifiablePages, "locked-pages", lockedPages);
    }
    
    /**
     * Set a template to pages
     * @param pageIds the id of pages to update
     * @param templateName The template name
     * @return the id of pages which succeeded
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> setTemplate (List<String> pageIds, String templateName)
    {
        return setTemplate(pageIds, templateName, true);
    }
    
    /**
     * Set a template to pages
     * @param pageIds the id of pages to update
     * @param templateName The template name
     * @param checkAvailableTemplate true if you want to check available template
     * @return the id of pages which succeeded
     */
    public Map<String, Object> setTemplate (List<String> pageIds, String templateName, boolean checkAvailableTemplate)
    {
        List<String> allRightIds = new ArrayList<>();
        List<Map<String, Object>> noRightPages = new ArrayList<>();
        List<Map<String, Object>> errorPages = new ArrayList<>();
        List<Map<String, Object>> noModifiablePages = new ArrayList<>();
        
        String defaultZoneName = null;
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            
            if (_rightManager.currentUserHasRight("Web_Rights_Page_Templates", page) != RightResult.RIGHT_ALLOW)
            {
                noRightPages.add(Map.of("id", pageId, "title", page.getTitle()));
            }
            else if (!(page instanceof ModifiablePage))
            {
                noModifiablePages.add(Map.of("id", pageId, "title", page.getTitle()));
            }
            else if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
            {
                throw new IllegalStateException("You cannot set template on page '/" + lockablePage.getSitemapName() + "/" + lockablePage.getPathInSitemap() + "' because it's locked");
            }
            else
            {
                ModifiablePage mPage = (ModifiablePage) page;
                
                if (defaultZoneName == null)
                {
                    String skinId = page.getSite().getSkinId();
                    SkinTemplate tpl = _skinsManager.getSkin(skinId).getTemplate(templateName);
                    if (tpl == null)
                    {
                        throw new IllegalStateException("Template '" + templateName + "' does not exist on skin '" + skinId + "'");
                    }
                    
                    defaultZoneName = tpl.getDefaultZoneId();
                }
                
                if (checkAvailableTemplate && !_templatesHandler.getAvailablesTemplates(mPage).contains(templateName))
                {
                    throw new IllegalStateException("Template '" + templateName + "' is not available for page '" + pageId + "'");
                }
                
                if (page.getType().equals(PageType.CONTAINER))
                {
                    _removeOldZones (mPage, templateName);
                }
                
                mPage.setTemplate(templateName);
                mPage.setType(PageType.CONTAINER);
                mPage.getSitemap().saveChanges();
                
                allRightIds.add(pageId);
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
            }
            
        }
        
        Map<String, Object> results = new HashMap<>();
        results.put("allright-pages", allRightIds);
        results.put("noright-pages", noRightPages);
        results.put("error-pages", errorPages);
        results.put("nomodifiable-pages", noModifiablePages);
        
        if (defaultZoneName != null)
        {
            results.put("zonename", defaultZoneName);
        }
        return results;
    }
    
    /**
     * Get the script class name to execute to add or update this service
     * @param serviceId the service id
     * @return the script class name. Can be empty
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public String getServiceParametersAction (String serviceId)
    {
        try
        {
            Service service = _serviceExtensionPoint.getExtension(serviceId);
            return service.getParametersScript().getScriptClassname();
        }
        catch (IllegalArgumentException e)
        {
            throw new IllegalArgumentException("Service with id '" + serviceId + "' does not exist", e);
        }
    }
    
    private void _removeOldZones (ModifiablePage page, String templateName)
    {
        String skinId = page.getSite().getSkinId();
        
        SkinTemplate oldTemplate = _skinsManager.getSkin(skinId).getTemplate(templateName);
        
        Map<String, SkinTemplateZone> templateZones = oldTemplate.getZones();
        
        for (ModifiableZone zone : page.getZones())
        {
            if (!templateZones.containsKey(zone.getName()))
            {
                zone.remove();
            }
        }
    }
    
    /**
     * Get the tags from the pages
     * @param pageIds The ids of the pages
     * @return the tags of the pages
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Set<String> getTags (List<String> pageIds)
    {
        Set<String> tags = new HashSet<>();
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            if (_rightManager.currentUserHasReadAccess(page))
            {
                tags.addAll(page.getTags());
            }
        }
        
        return tags;
    }
    
    /**
     * Tag a list of pages
     * @param pageIds The ids of pages to tag
     * @param tagNames The tags
     * @param mode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @param contextualParameters Contextual parameters. Must contain the site name
     * @return the result
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> tag (List<String> pageIds, List<String> tagNames, String mode, Map<String, Object> contextualParameters)
    {
        return tag(pageIds, tagNames, TagMode.valueOf(mode), contextualParameters, false);
    }
    
    /**
     * Tag a list of pages
     * @param pageIds The ids of pages to tag
     * @param tagNames The tags
     * @param mode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @param contextualParameters Contextual parameters. Must contain the site name
     * @param ignoreRights <code>true</code> to ignore rights on tag
     * @return the result
     */
    public Map<String, Object> tag (List<String> pageIds, List<String> tagNames, TagMode mode, Map<String, Object> contextualParameters, boolean ignoreRights)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("nomodifiable-pages", new ArrayList<>());
        result.put("invalid-tags", new ArrayList<>());
        result.put("allright-pages", new ArrayList<>());
        result.put("noright-pages", new ArrayList<>());
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);

            Map<String, Object> page2json = new HashMap<>();
            page2json.put("id", page.getId());
            page2json.put("title", page.getTitle());
            
            if (!ignoreRights && !_hasTagRights(page, tagNames, mode, contextualParameters))
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> noRightPages = (List<Map<String, Object>>) result.get("noright-pages");
                noRightPages.add(page2json);
            }
            else
            {
                if (page instanceof ModifiablePage mPage)
                {
                    @SuppressWarnings("unchecked")
                    List<String> invalidTags = (List<String>) result.get("invalid-tags");
                    invalidTags.addAll(tag(mPage, tagNames, mode));
                    
                    page2json.put("tags", page.getTags());
                    @SuppressWarnings("unchecked")
                    List<Map<String, Object>> allRightPages = (List<Map<String, Object>>) result.get("allright-pages");
                    allRightPages.add(page2json);
                }
                else
                {
                    @SuppressWarnings("unchecked")
                    List<Map<String, Object>> nomodifiablePages = (List<Map<String, Object>>) result.get("nomodifiable-pages");
                    nomodifiablePages.add(page2json);
                }
            }
        }
        
        return result;
    }
    
    private boolean _hasTagRights(Page page, List<String> tagNames, TagMode mode, Map<String, Object> contextualParameters)
    {
        List<CMSTag> tags = tagNames.stream()
            .map(t -> _tagProvider.getTag(t, contextualParameters))
            .filter(Objects::nonNull)
            .toList();
        
        // In case of replace, only check the right on tag that are modified, ie added or removed tags
        if (TagMode.REPLACE.equals(mode))
        {
            List<CMSTag> existingTags = page.getTags().stream()
                    .map(t -> _tagProvider.getTag(t, contextualParameters))
                    .filter(Objects::nonNull)
                    .toList();
            
            tags = new ArrayList<>(CollectionUtils.disjunction(tags, existingTags));
        }
        
        boolean hasPublicTagRight = _rightManager.currentUserHasRight("Web_Rights_Page_Tag", page) == RightResult.RIGHT_ALLOW;
        boolean hasPrivateTagRight = _rightManager.currentUserHasRight("Web_Rights_Page_Private_Tag", page) == RightResult.RIGHT_ALLOW;
        
        // Test if the current user has the right to tag public tag on page only if there are at least one public tag
        boolean hasRight = TagHelper.filterTags(tags, TagVisibility.PUBLIC, "PAGE").isEmpty() || hasPublicTagRight || hasPrivateTagRight;
        
        // Test if the current user has the right to tag private tag on page only if there are at least one private tag
        return hasRight && (TagHelper.filterTags(tags, TagVisibility.PRIVATE, "PAGE").isEmpty() || hasPrivateTagRight);
    }

    /**
     * Tag a page
     * @param page The page to tag
     * @param tagNames The tags
     * @param tagMode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @return the list of invalid tags that were not set
     */
    public List<String> tag(ModifiablePage page, List<String> tagNames, TagMode tagMode)
    {
        List<String> invalidTags = new ArrayList<>();
        
        Set<String> oldTags = page.getTags();
        if (TagMode.REPLACE.equals(tagMode))
        {
            // First delete old tags
            for (String tagName : oldTags)
            {
                page.untag(tagName);
            }
        }
        
        // Then set new tags
        for (String tagName : tagNames)
        {
            if (_isTagValid(page, tagName))
            {
                if (TagMode.REMOVE.equals(tagMode))
                {
                    page.untag(tagName);
                }
                else if (TagMode.REPLACE.equals(tagMode) || !oldTags.contains(tagName))
                {
                    page.tag(tagName);
                }
            }
            else
            {
                invalidTags.add(tagName);
            }
        }
        
        page.saveChanges();
        
        if (!oldTags.equals(page.getTags()))
        {
            // Notify observers that the page has been tagged
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, page);
            eventParams.put(ObservationConstants.ARGS_PAGE_TAGS, page.getTags());
            eventParams.put(ObservationConstants.ARGS_PAGE_OLD_TAGS, oldTags);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
        }
        
        return invalidTags;
    }
    
    /**
     * Tag a list of contents with the given tags
     * @param pageIds The ids of pages to tag
     * @param contentIds The ids of contents to tag
     * @param tagNames The tags
     * @param contextualParameters The contextual parameters
     * @return the result map
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> tag (List<String> pageIds, List<String> contentIds, List<String> tagNames, Map<String, Object> contextualParameters)
    {
        return tag(pageIds, contentIds, tagNames, TagMode.REPLACE.toString(), contextualParameters);
    }
    
    /**
     * Tag a list of contents and/org pages
     * @param pageIds The ids of pages to tag
     * @param contentIds The ids of contents to tag
     * @param tagNames The tags
     * @param mode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @param contextualParameters The contextual parameters
     * @return the result
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> tag (List<String> pageIds, List<String> contentIds, List<String> tagNames, String mode, Map<String, Object> contextualParameters)
    {
        TagMode tagMode = TagMode.valueOf(mode);
        
        // Tag pages
        Map<String, Object> result = tag(pageIds, tagNames, tagMode, contextualParameters, false);
        
        // Tag contents
        result.putAll(_contentDAO.tag(contentIds, tagNames, tagMode, contextualParameters, false));
        
        // Invalid tags are ignored
        result.remove("invalid-tags");
        return result;
    }
    
    /**
     * Test if a tag is valid for a specific page
     * @param page The page
     * @param tagName The tag name
     * @return True if the tag is valid
     */
    public boolean _isTagValid (Page page, String tagName)
    {
        Map<String, Object> params = new HashMap<>();
        params.put("siteName", page.getSiteName());
        CMSTag tag = _tagProvider.getTag(tagName, params);
        
        return tag != null && tag.getTarget().getName().equals("PAGE");
    }
    
    /**
     * Returns the ids of the pages matching the tag
     * @param sitename The site id
     * @param lang The language code
     * @param tag The tag id
     * @return Array of pages ids
     */
    public List<String> findPagedIdsByTag(String sitename, String lang, String tag)
    {
        return _getMemoryPageTagCache().get(PageTagCacheKey.of(sitename, lang, tag), __ -> _computePagesIds(sitename, lang, tag))
                    .stream()
                    .filter(_resolver::hasAmetysObjectForId) // Cache remember for tag in default, we have to check if page exists in current workspace
                    .collect(Collectors.toList());
    }
    
    private List<String> _computePagesIds(String sitename, String lang, String tag)
    {
        
        Session defaultSession = null;
        try
        {
            List<String> pagesIds = new ArrayList<>();
            
            // Force default workspace to execute query
            defaultSession = _repository.login(RepositoryConstants.DEFAULT_WORKSPACE);
            
            String xpath = PageQueryHelper.getPageXPathQuery(sitename, lang, null, new TagExpression(Operator.EQ, tag), null);
            AmetysObjectIterable<Page> pages = _ametysObjectResolver.query(xpath, defaultSession);
            Iterator<Page> it = pages.iterator();
    
            while (it.hasNext())
            {
                pagesIds.add(it.next().getId());
            }
            
            return pagesIds;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
        finally
        {
            if (defaultSession != null)
            {
                defaultSession.logout();
            }
        }
    }

    private Cache<PageTagCacheKey, List<String>> _getMemoryPageTagCache()
    {
        return _cacheManager.get(MEMORY_PAGESTAGCACHE);
    }
    
    /**
     * Set the visible of pages
     * @param pageIds The id of pages
     * @param visible <code>true</code> to set pages as visible, <code>false</code> otherwise
     * @return The result map
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> setVisibility (List<String> pageIds, boolean visible)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("nomodifiable-pages", new ArrayList<>());
        result.put("noright-pages", new ArrayList<>());
        result.put("allright-pages", new ArrayList<>());
        result.put("locked-pages", new ArrayList<>());
        
        for (String id : pageIds)
        {
            Page page = _resolver.resolveById(id);
            
            Map<String, Object> page2json = new HashMap<>();
            page2json.put("id", page.getId());
            page2json.put("title", page.getTitle());
            
            if (_rightManager.currentUserHasRight("Web_Right_Page_Visibility", page) != RightResult.RIGHT_ALLOW)
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> norightPages = (List<Map<String, Object>>) result.get("noright-pages");
                norightPages.add(page2json);
            }
            else if (page instanceof LockablePage lockablePage && lockablePage.isLocked())
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> lockedPages = (List<Map<String, Object>>) result.get("nomodifiable-pages");
                lockedPages.add(page2json);
            }
            else if (page instanceof ModifiablePage mPage)
            {
                mPage.setVisible(visible);
                mPage.saveChanges();
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                eventParams.put(ObservationConstants.ARGS_PAGE_ID, page.getId());
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
                
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allRightPages = (List<Map<String, Object>>) result.get("allright-pages");
                allRightPages.add(page2json);
            }
            else
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> nomodifiablePages = (List<Map<String, Object>>) result.get("nomodifiable-pages");
                nomodifiablePages.add(page2json);
            }
        }
        
        return result;
    }
    
    /**
     * Get the contents of a {@link Page} and its subpages which can be deleted.
     * A content is deleteable if user has right, the content is not locked and not referenced by other pages.
     * @param id The id of page
     * @return The list of deletable contents
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> getDeleteablePageContents (String id)
    {
        Map<String, Object> results = new HashMap<>();
        
        results.put("deleteable-contents", new ArrayList<>());
        results.put("referenced-contents", new ArrayList<>());
        results.put("unauthorized-contents", new ArrayList<>());
        results.put("locked-contents", new ArrayList<>());
        
        Page page = _resolver.resolveById(id);
        PageHierarchy pageHierarchy = _getPageContents(page, true);
        
        for (Content content : pageHierarchy.contents())
        {
            Map<String, Object> contentParams = new HashMap<>();
            contentParams.put("id", content.getId());
            contentParams.put("title", content.getTitle(LocaleUtils.toLocale(page.getSitemapName())));
            contentParams.put("name", content.getName());
            
            if (_isReferenced(content, pageHierarchy.pages()))
            {
                // Content is referenced by at least another page
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> referencedContents = (List<Map<String, Object>>) results.get("referenced-contents");
                referencedContents.add(contentParams);
            }
            else if (!_contentDAO.canDelete(content))
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> unauthorizedContents = (List<Map<String, Object>>) results.get("unauthorized-contents");
                unauthorizedContents.add(contentParams);
            }
            else if (_isLocked(content))
            {
                // If the content is locked by other
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> lockedContents = (List<Map<String, Object>>) results.get("locked-contents");
                lockedContents.add(contentParams);
            }
            else
            {
                Map<String, Object> content2json = new HashMap<>();
                content2json.put("id", content.getId());
                content2json.put("name", content.getName());
                content2json.put("title", content.getTitle(LocaleUtils.toLocale(page.getSitemapName())));
                content2json.put("isNew", _isNew(content));
                content2json.put("isShared", content instanceof SharedContent);
                content2json.put("hasShared", _sharedContentManager.hasSharedContents(content));
                
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allrightContents = (List<Map<String, Object>>) results.get("deleteable-contents");
                allrightContents.add(content2json);
            }
        }
        
        return results;
    }
    
    /**
     * Get the contents that belong to the {@link Page} and its sub-pages and that can be deleted.
     * A content is deleteable if user has right, the content is not locked and it's not referenced by other pages.
     * If 'onlyNewlyCreatedContents' is set to 'true', only newly created contents will be returned
     * @param pageHierarchy Object containing the page and its sub pages, and all referencing contents in these pages
     * @param onlyNewlyCreatedContents true to return only the newly created contents
     * @return The ids of deleteable contents
     */
    private List<String> _getDeleteablePageContentIds (PageHierarchy pageHierarchy, boolean onlyNewlyCreatedContents)
    {
        return pageHierarchy.contents()
                .stream()
                .filter(_contentDAO::canDelete)
                .filter(Predicate.not(this::_isLocked))
                .filter(c -> !_isReferenced(c, pageHierarchy.pages()))
                .filter(c -> !onlyNewlyCreatedContents || _isNew(c))
                .map(Content::getId)
                .toList();
    }
    
    /**
     * Returns the page's attachments root node
     * @param id the page's id
     * @return The attachments' root node informations
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> getAttachmentsRootNode (String id)
    {
        Map<String, Object> result = new HashMap<>();
        
        Page page = _resolver.resolveById(id);
        
        result.put("title", page.getTitle());
        result.put("pageId", page.getId());
        
        if (_rightManager.currentUserHasRight("Web_Rights_Page_Attachments", page) != RightResult.RIGHT_ALLOW
            && _rightManager.currentUserHasRight("Web_Rights_Page_AttachmentHandle", page) != RightResult.RIGHT_ALLOW)
        {
            return result;
        }
        
        TraversableAmetysObject attachments = page.getRootAttachments();
        
        if (attachments != null)
        {
            result.put("id", attachments.getId());
            if (attachments instanceof ModifiableAmetysObject)
            {
                result.put("isModifiable", true);
            }
            if (attachments instanceof ModifiableResourceCollection)
            {
                result.put("canCreateChild", true);
            }
            
            boolean hasChildNodes = false;
            boolean hasResources = false;

            for (AmetysObject child : attachments.getChildren())
            {
                if (child instanceof Resource)
                {
                    hasResources = true;
                }
                else if (child instanceof ExplorerNode)
                {
                    hasChildNodes = true;
                }
            }

            if (hasChildNodes)
            {
                result.put("hasChildNodes", true);
            }

            if (hasResources)
            {
                result.put("hasResources", true);
            }
            
            return result;
        }
        
        throw new IllegalArgumentException("Page with id '" + id + "' does not support attachments.");
    }
    /**
     * Returns the page's parents ids
     * @param id the page's id
     * @return The attachments' root node informations
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> getPageParents (String id)
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> pages = new ArrayList<>();
        Page page = _resolver.resolveById(id);
        pages.add(_page2Json(page));
        while (page.getParent() != null && page.getParent() instanceof Page)
        {
            page = page.getParent();
            pages.add(_page2Json(page));
        }
        result.put("parents", pages);
        return result;
    }
    
    /**
     * Get the contents of a page and its child pages
     * @param sitemapElement The page
     * @return The list of contents
     */
    public Set<Content> getPageContents (SitemapElement sitemapElement)
    {
        return _getPageContents(sitemapElement, false).contents();
    }
    
    /**
     * Get the contents of a page and its child pages
     * @param sitemapElement The page
     * @param ignoreContentsOfNonRemovablePage true to ignore contents of non-removable pages (virtual pages)
     * @return The page hierarchy with all pages, sub pages and referencing contents
     */
    private PageHierarchy _getPageContents (SitemapElement sitemapElement, boolean ignoreContentsOfNonRemovablePage)
    {
        Set<Content> contents = new HashSet<>();
        
        if ((!ignoreContentsOfNonRemovablePage || sitemapElement instanceof RemovableAmetysObject)
                && sitemapElement.getTemplate() != null)
        {
            for (Zone zone : sitemapElement.getZones())
            {
                try (AmetysObjectIterable< ? extends ZoneItem> zoneItems = zone.getZoneItems())
                {
                    for (ZoneItem zoneItem : zoneItems)
                    {
                        if (zoneItem.getType() == ZoneItem.ZoneType.CONTENT)
                        {
                            contents.add(zoneItem.getContent());
                        }
                    }
                }
            }
        }
        
        Set<Page> pages = new HashSet<>();
        if (sitemapElement instanceof Page page)
        {
            pages.add(page);
        }
        
        AmetysObjectIterable< ? extends Page> childrenPages = sitemapElement.getChildrenPages();
        for (Page childPage : childrenPages)
        {
            PageHierarchy pageHierarchy = _getPageContents(childPage, ignoreContentsOfNonRemovablePage);
            pages.addAll(pageHierarchy.pages());
            contents.addAll(pageHierarchy.contents());
        }
        
        return new PageHierarchy(pages, contents);
    }
    
    /**
     * Get the user rights on sitemap element (page or sitemap)
     * @param pagesCt The sitemap element
     * @return The user's rights
     */
    protected Set<String> getUserRights (SitemapElement pagesCt)
    {
        UserIdentity user = _currentUserProvider.getUser();
        
        Set<String> userRights = _rightManager.getUserRights(user, pagesCt);
        
        userRights = new HashSet<>(userRights);
        // Do some specific stuff here, because the right 'Web_Rights_Page_Delete' is a right to delete child pages and not the page itself.
        // So the right should be checked on parent context.
        if (pagesCt instanceof Page)
        {
            SitemapElement parent = pagesCt.getParent();
            boolean canDelete = _rightManager.hasRight(user, "Web_Rights_Page_Delete", parent) == RightResult.RIGHT_ALLOW;
            if (!canDelete)
            {
                // No right on parent page, so remove the right if exists.
                userRights.remove("Web_Rights_Page_Delete");
            }
        }
        else
        {
            // There is no right of deletion on the sitemap
            userRights.remove("Web_Rights_Page_Delete");
        }
        
        // include the read access in the right list for convenience
        // use the reader profile Id even if its not an actual right id
        // nobody should ever defined a right with id "READER"
        if (_rightManager.hasReadAccess(user, pagesCt))
        {
            userRights.add(RightManager.READER_PROFILE_ID);
        }
        
        return userRights;
    }
    
    private boolean _isReferenced (Content content, Set<Page> pages)
    {
        if (content instanceof WebContent webContent)
        {
            // If only one page referencing the content is not inside the selected page hierarchy, it is a referenced content
            return webContent.getReferencingPages().stream().anyMatch(Predicate.not(pages::contains));
        }
        
        return false;
    }
    
    private boolean _isLocked (Content content)
    {
        if (content instanceof LockableAmetysObject lockableContent)
        {
            if (lockableContent.isLocked())
            {
                boolean canUnlockAll = _rightManager.hasRight(_currentUserProvider.getUser(), "CMS_Rights_UnlockAll", "/cms") == RightResult.RIGHT_ALLOW;
                if (!LockHelper.isLockOwner(lockableContent, _currentUserProvider.getUser()) && !canUnlockAll)
                {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    private boolean _isNew (Content content)
    {
        boolean isNew = false;
        if (content instanceof WorkflowAwareContent waContent)
        {
            long workflowId = waContent.getWorkflowId();
            
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
            isNew = workflow.getHistorySteps(workflowId).isEmpty();
        }
        return isNew;
    }

    private Map<String, Object> _page2Json (Page page)
    {
        Map<String, Object> page2json = new HashMap<>();
        page2json.put("id", page.getId());
        page2json.put("title", page.getTitle());
        page2json.put("siteName", page.getSiteName());
        page2json.put("path", page.getPathInSitemap());
        return page2json;
    }
    
    private Map<String, Object> _publication2Json (Page page)
    {
        Map<String, Object> pub2json = new HashMap<>();
        
        if (page.hasValue(DefaultPage.METADATA_PUBLICATION_START_DATE, ModelItemTypeConstants.DATETIME_TYPE_ID))
        {
            Object startDateAsJSON = page.dataToJSON(DefaultPage.METADATA_PUBLICATION_START_DATE);
            pub2json.put("startDate", startDateAsJSON);
        }
        
        if (page.hasValue(DefaultPage.METADATA_PUBLICATION_END_DATE, ModelItemTypeConstants.DATETIME_TYPE_ID))
        {
            Object endDateAsJSON = page.dataToJSON(DefaultPage.METADATA_PUBLICATION_END_DATE);
            pub2json.put("endDate", endDateAsJSON);
        }
        
        return pub2json;
        
    }
    
    private void _updateContentsAfterCopy(Page initialPage, Page createdPage) throws AmetysRepositoryException
    {
        for (Zone zone : createdPage.getZones())
        {
            Zone initialZone = initialPage.getZone(zone.getName());
            try (AmetysObjectIterable< ? extends ZoneItem> zoneItems = zone.getZoneItems(); AmetysObjectIterable< ? extends ZoneItem> initialZoneItems = initialZone.getZoneItems())
            {
                AmetysObjectIterator<? extends ZoneItem> iterator = zoneItems.iterator();
                AmetysObjectIterator< ? extends ZoneItem> initialIterator = initialZoneItems.iterator();
                if (iterator.getSize() != initialIterator.getSize())
                {
                    throw new IllegalStateException("An error occured during the copy of " + initialPage.getName() + " (" + initialPage.getId() + "). The resulting page have a different number of zoneItems.");
                }
                while (iterator.hasNext())
                {
                    ZoneItem zoneItem = iterator.next();
                    ZoneItem initialZoneItem = initialIterator.next();
                    if (zoneItem.getType().equals(ZoneType.CONTENT))
                    {
                        Content content = zoneItem.getContent();
                        WebContent initialContent = initialZoneItem.getContent();
                        
                        // Updaters
                        Set<String> ids = _copyUpdaterEP.getExtensionsIds();
                        for (String id : ids)
                        {
                            _copyUpdaterEP.getExtension(id).updateContent(initialPage.getSite(), createdPage.getSite(), initialContent, content);
                        }
                        
                        // Convert content language if necessary
                        if (content instanceof ModifiableContent modifiableContent && content.getLanguage() != null && content.getLanguage() != createdPage.getSitemapName())
                        {
                            modifiableContent.setLanguage(createdPage.getSitemapName());
                            modifiableContent.saveChanges();
                        }
                        
                        // Create the first version
                        if (content instanceof VersionableAmetysObject versionableContent)
                        {
                            versionableContent.checkpoint();
                        }
                    }
                }
            }
        }
        
        // Browse child pages
        for (Page childPage : createdPage.getChildrenPages())
        {
            Page initialChildPage = initialPage.getChild(childPage.getName());
            _updateContentsAfterCopy (initialChildPage, childPage);
        }
    }
    
    private List<String> _getChildrenPageIds (Page page)
    {
        List<String> childIds = new ArrayList<>();
        
        for (Page childPage : page.getChildrenPages())
        {
            childIds.add(childPage.getId());
            childIds.addAll(_getChildrenPageIds(childPage));
        }
        
        return childIds;
    }

    /**
     * Check each parent and return true if one of them is invisible
     * @param page page to check
     * @return true if at least one parent is invisible
     */
    private boolean _isParentInvisible (Page page)
    {
        AmetysObject parent = page.getParent();
        while (parent != null && parent instanceof Page parentPage)
        {
            if (!parentPage.isVisible())
            {
                return true;
            }
            parent = parent.getParent();
        }
        return false;
    }

    /* start of a group of methods for _isPreviewable */
    /**
     * Determine if this page is previewable
     * @param page The page to look at
     * @return true if the page can be previewed
     */
    private boolean _isPreviewable(Page page)
    {
        // Check for infinitive loop redirection
        ArrayList<String> pagesSequence = new ArrayList<>();
        pagesSequence.add(page.getId());
        if (_isInfiniteRedirection (page, pagesSequence))
        {
            getLogger().error("An infinite loop redirection was detected for page '" + page.getPathInSitemap() + "'");
            return false;
        }

        if (page.getType() == PageType.LINK && LinkType.PAGE.equals(page.getURLType()))
        {
            return _isPageExist(page.getURL()) && _isPreviewable((Page) _resolver.resolveById(page.getURL()));
        }

        if (page.getType() != PageType.NODE)
        {
            return true;
        }
        else
        {
            try (AmetysObjectIterable< ? extends Page> childrenPages = page.getChildrenPages())
            {
                for (Page subPage : childrenPages)
                {
                    if (_isPreviewable(subPage))
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean _isPageExist (String id)
    {
        try
        {
            _resolver.resolveById(id);
            return true;
        }
        catch (UnknownAmetysObjectException e)
        {
            return false;
        }
    }

    private boolean _isInfiniteRedirection (Page page, List<String> pagesSequence)
    {
        Page redirectPage = _getPageRedirection (page);
        if (redirectPage == null)
        {
            return false;
        }

        if (pagesSequence.contains(redirectPage.getId()))
        {
            return true;
        }

        pagesSequence.add(redirectPage.getId());
        return _isInfiniteRedirection (redirectPage, pagesSequence);
    }

    private Page _getPageRedirection (Page page)
    {
        if (PageType.LINK.equals(page.getType()) && LinkType.PAGE.equals(page.getURLType()))
        {
            try
            {
                String pageId = page.getURL();
                return _resolver.resolveById(pageId);
            }
            catch (AmetysRepositoryException e)
            {
                return null;
            }
        }
        else if (PageType.NODE.equals(page.getType()))
        {
            AmetysObjectIterable<? extends Page> childPages = page.getChildrenPages();
            Iterator<? extends Page> it = childPages.iterator();
            if (it.hasNext())
            {
                return it.next();
            }
        }

        return null;
    }
    /* end of a group of methods for _isPreviewable */
    
    private static final class PageTagCacheKey extends AbstractCacheKey
    {
        private PageTagCacheKey(String sitename, String lang, String tag)
        {
            super(sitename, lang, tag);
        }
        
        private PageTagCacheKey(String sitename, String lang)
        {
            super(sitename, lang);
        }

        static PageTagCacheKey of(String sitename, String lang)
        {
            return new PageTagCacheKey(sitename, lang, null);
        }

        static PageTagCacheKey of(String sitename, String lang, String tag)
        {
            return new PageTagCacheKey(sitename, lang, tag);
        }
    }
    
    private record PageHierarchy(Set<Page> pages, Set<Content> contents) { /* empty */ }
}