/*
 *  Copyright 2010 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.synchronization;

import java.io.IOException;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.jcr.ItemNotFoundException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.version.VersionHistory;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
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.collections.Predicate;
import org.apache.commons.collections.PredicateUtils;
import org.apache.commons.lang.StringUtils;

import org.ametys.cms.CmsConstants;
import org.ametys.cms.repository.CloneComponent;
import org.ametys.cms.repository.Content;
import org.ametys.cms.support.AmetysPredicateUtils;
import org.ametys.core.schedule.progression.ProgressionTrackerFactory;
import org.ametys.core.schedule.progression.SimpleProgressionTracker;
import org.ametys.core.util.AvalonLoggerAdapter;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.Page.LinkType;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.page.SitemapElement;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.page.jcr.DefaultPage;
import org.ametys.web.repository.sitemap.Sitemap;
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 jakarta.mail.MessagingException;

/**
 * Helper for common processing used while synchronizing.
 */
public class SynchronizeComponent extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** Avalon Role */
    public static final String ROLE = SynchronizeComponent.class.getName();
    
    private static SynchronizeComponent _instance;
    
    private CloneComponent _cloneComponent;
    private AmetysObjectResolver _resolver;
    private SkinsManager _skinsManager;
    private I18nUtils _i18nUtils;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _cloneComponent = (CloneComponent) smanager.lookup(CloneComponent.ROLE);
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _skinsManager = (SkinsManager) smanager.lookup(SkinsManager.ROLE);
        _i18nUtils = (I18nUtils) smanager.lookup(I18nUtils.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _instance = this;
    }
    
    /**
     * Get the unique instance
     * @return the unique instance
     */
    @Deprecated
    public static SynchronizeComponent getInstance()
    {
        return _instance;
    }
    
    /**
     * Returns true if the hierarchy of the given Page is valid, ie if all its ancestors are valid and synchronized in the live workspace.
     * @param page the source page.
     * @param liveSession the live Session.
     * @return the hierarchy validity status.
     * @throws RepositoryException if failed to check page hierarchy
     */
    public boolean isHierarchyValid(Page page, Session liveSession) throws RepositoryException
    {
        AmetysObject parent = page.getParent();
        if (parent instanceof Sitemap)
        {
            return true;
        }
        
        Page parentPage = (Page) parent;
        if (!(parentPage instanceof JCRAmetysObject))
        {
            return isPageValid(parentPage, _skinsManager.getSkin(page.getSite().getSkinId())) && isHierarchyValid(parentPage, liveSession);
        }
        else if (parentPage.getType() == PageType.NODE)
        {
            return isDateValid(parentPage) && isHierarchyValid(parentPage, liveSession);
        }
        else
        {
            return liveSession.itemExists(((JCRAmetysObject) parentPage).getNode().getPath());
        }
    }
    
    /**
     * Returns true if the given page should be synchronized in the live workspace.
     * @param page the page to test.
     * @param skin the skin of the page's site.
     * @return true if the page is valid
     */
    public boolean isPageValid(Page page, Skin skin)
    {
        if (!isDateValid(page))
        {
            return false;
        }
        
        switch (page.getType())
        {
            case LINK:
                return _isLinkPageValid(page);
            case NODE:
                return _isNodePageValid(page, skin);
            case CONTAINER:
                return _isContainerPageValid(page, skin);
            default:
                return false;
        }
    }
    
    /**
     * Returns true if the publication date of the given page are valid.
     * @param page the page to test.
     * @return true if the publication dates are valid
     */
    public boolean isDateValid (Page page)
    {
        ZonedDateTime startDate = page.getValue(DefaultPage.METADATA_PUBLICATION_START_DATE);
        ZonedDateTime endDate = page.getValue(DefaultPage.METADATA_PUBLICATION_END_DATE);
        
        if (startDate != null && startDate.isAfter(ZonedDateTime.now()))
        {
            return false;
        }
        
        if (endDate != null && endDate.isBefore(ZonedDateTime.now()))
        {
            return false;
        }
        
        return true;
    }
    
    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;
    }
    
    private boolean _isLinkPageValid(Page page)
    {
        if (LinkType.WEB.equals(page.getURLType()))
        {
            return true;
        }
        
        // Check for infinitive loop redirection
        List<String> pagesSequence = new ArrayList<>();
        pagesSequence.add(page.getId());
        if (_isInfiniteRedirection (page, pagesSequence))
        {
            getLogger().error("An infinite loop redirection was detected for page '" + page.getSiteName() + "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "' (" + page.getId() + ") in the sequence " + pagesSequence);
            _sendErrorMailForInfiniteRedirection (page);
            return false;
        }
        
        try
        {
            String pageId = page.getURL();
            Page linkedPage = _resolver.resolveById(pageId);
            
            Skin linkedPageSkin = _skinsManager.getSkin(linkedPage.getSite().getSkinId());
            return isPageValid(linkedPage, linkedPageSkin);
        }
        catch (UnknownAmetysObjectException e)
        {
            getLogger().error("Page '" + page.getSiteName() + "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "' (" + page.getId() + ") redirects to an unexisting page '" + page.getURL() + "'", e);
            return false;
        }
        catch (AmetysRepositoryException e)
        {
            getLogger().error("Unable to check page validity for page link '" + page.getId() + "'", e);
            return false;
        }
    }
    
    private boolean _isNodePageValid(Page page, Skin skin)
    {
        // Check for infinitive loop redirection
        List<String> pagesSequence = new ArrayList<>();
        pagesSequence.add(page.getId());
        if (_isInfiniteRedirection (page, pagesSequence))
        {
            getLogger().error("An infinite loop redirection was detected for page '" + page.getSiteName() + "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "' (" + page.getId() + ") in the sequence " + pagesSequence);
            _sendErrorMailForInfiniteRedirection (page);
            return false;
        }
        
        // a node page is valid if at least one of its child pages is valid
        AmetysObjectIterable<? extends Page> childPages = page.getChildrenPages();
        boolean hasOneConcreteChildPage = false;
        Iterator<? extends Page> it = childPages.iterator();
        
        while (!hasOneConcreteChildPage && it.hasNext())
        {
            Page childPage = it.next();
            if (isPageValid(childPage, skin))
            {
                hasOneConcreteChildPage = true;
            }
        }
        
        return hasOneConcreteChildPage;
    }
    
    private boolean _isContainerPageValid(Page page, Skin skin)
    {
        // a container page is valid if it has no zones or at least one zone is valid
        if (skin == null)
        {
            return false;
        }
        else
        {
            SkinTemplate template = skin.getTemplate(page.getTemplate());
            if (template == null)
            {
                return false;
            }
            
            Map<String, SkinTemplateZone> modelZones = template.getZones();
            Iterator<String> zoneNames = modelZones.keySet().iterator();
            
            boolean pageIsValid = modelZones.size() == 0;
            
            while (!pageIsValid && zoneNames.hasNext())
            {
                // a zone is valid if it is not empty and if at least one ZoneItem is valid
                String zoneName = zoneNames.next();
                
                if (page.hasZone(zoneName))
                {
                    Zone zone = page.getZone(zoneName);
                    AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems();
                    Iterator<? extends ZoneItem> it = zoneItems.iterator();
                    boolean zoneIsValid = false;
                    
                    while (!zoneIsValid && it.hasNext())
                    {
                        ZoneItem zoneItem = it.next();
                        zoneIsValid = _isZoneItemValid(zoneItem);
                    }
                    
                    pageIsValid = zoneIsValid;
                }
            }
            
            return pageIsValid;
        }
    }
    
    private boolean _isZoneItemValid(ZoneItem zoneItem)
    {
        switch (zoneItem.getType())
        {
            case SERVICE:
                // a service is always valid
                return true;
            case CONTENT:
                try
                {
                    // a content is valid if it has been validated at least once
                    Content content = zoneItem.getContent();
                    if (content instanceof VersionableAmetysObject)
                    {
                        return Arrays.asList(((VersionableAmetysObject) content).getAllLabels()).contains(CmsConstants.LIVE_LABEL);
                    }
                    else
                    {
                        return false;
                    }
                }
                catch (AmetysRepositoryException e)
                {
                    getLogger().error("Unable to get content property", e);
                    return false;
                }
            default:
                throw new IllegalArgumentException("A zoneItem must be either a service or a content.");
        }
    }

    /**
     * Adds a node to a parent node using a source node for name, type
     * and potential UUID.
     * @param srcNode the source node.
     * @param parentNode the parent node for the newly created node.
     * @param nodeName the node name to use.
     * @return the created node.
     * @throws RepositoryException if an error occurs.
     */
    public Node addNodeWithUUID(Node srcNode, Node parentNode, String nodeName) throws RepositoryException
    {
        Node node = null;
        
        if (AmetysPredicateUtils.isAllowedForLiveContent().evaluate(srcNode))
        {
            node = _cloneComponent.addNodeWithUUID(srcNode, parentNode, nodeName);
        }
        
        return node;
    }
    
    /**
     * Clones properties of a node
     * @param srcNode the source node.
     * @param clonedNode the cloned node.
     * @param propertyPredicate the property selector.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneProperties(Node srcNode, Node clonedNode, Predicate propertyPredicate) throws RepositoryException
    {
        cloneProperties(srcNode, clonedNode, propertyPredicate, ProgressionTrackerFactory.createSimpleProgressionTracker("Clone properties", new AvalonLoggerAdapter(getLogger())));
    }
    
    /**
     * Clones properties of a node
     * @param srcNode the source node.
     * @param clonedNode the cloned node.
     * @param propertyPredicate the property selector.
     * @param progressionTracker The progression tracker
     * @throws RepositoryException if an error occurs.
     */
    public void cloneProperties(Node srcNode, Node clonedNode, Predicate propertyPredicate, SimpleProgressionTracker progressionTracker) throws RepositoryException
    {
        if (srcNode == null || clonedNode == null)
        {
            return;
        }
        
        // Ignore protected properties + filter node/property for live
        final Predicate predicate = AmetysPredicateUtils.ignoreProtectedProperties(propertyPredicate);
        
        // First remove existing matching properties from cloned Node
        PropertyIterator clonedProperties = clonedNode.getProperties();
        while (clonedProperties.hasNext())
        {
            Property property = clonedProperties.nextProperty();
            if (predicate.evaluate(property))
            {
                property.remove();
            }
        }
        
        long nbOfProperties = srcNode.getProperties().getSize();
        progressionTracker.setSize(nbOfProperties);
        
        // Then copy properties
        PropertyIterator itProperties = srcNode.getProperties();
        
        while (itProperties.hasNext())
        {
            Property property =  itProperties.nextProperty();
            
            
            if (predicate.evaluate(property))
            {
                boolean propertyHandled = false;
                /*
                if (property.getType() == PropertyType.REFERENCE)
                {
                    try
                    {
                        Node referencedNode = property.getNode();
                        if (property.getName().equals("ametys-internal:initial-content"))
                        {
                            // Do not clone the initial-content reference.
                            propertyHandled = true;
                        }
                        
                    }
                    catch (ItemNotFoundException e)
                    {
                        // the target node does not exist anymore, this could be due to workflow having been deleted
                        propertyHandled = true;
                    }
                }*/
                
                if (!propertyHandled)
                {
                    if (property.getDefinition().isMultiple())
                    {
                        clonedNode.setProperty(property.getName(), property.getValues(), property.getType());
                    }
                    else
                    {
                        clonedNode.setProperty(property.getName(), property.getValue(), property.getType());
                    }
                }
            }
            
            progressionTracker.increment();
        }
    }

    /**
     * Clones a node by preserving the source node UUID for a content.
     * @param srcNode the source node.
     * @param clonedNode the cloned node.
     * @param propertyPredicate the property selector.
     * @param nodePredicate the node selector.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneContentNodeAndPreserveUUID(Node srcNode, Node clonedNode, Predicate propertyPredicate, Predicate nodePredicate) throws RepositoryException
    {
        Predicate finalNodePredicate = PredicateUtils.andPredicate(AmetysPredicateUtils.isAllowedForLiveContent(), nodePredicate);
        Predicate finalPropertiesPredicate = PredicateUtils.andPredicate(AmetysPredicateUtils.isAllowedForLiveContent(), propertyPredicate);

        cloneNodeAndPreserveUUID(srcNode, clonedNode, finalPropertiesPredicate, finalNodePredicate);
    }
    
    /**
     * Clones properties of a content node
     * @param srcNode the source node.
     * @param clonedNode the cloned node.
     * @param propertyPredicate the property selector.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneContentProperties(Node srcNode, Node clonedNode, Predicate propertyPredicate) throws RepositoryException
    {
        Predicate finalPropertiesPredicate = PredicateUtils.andPredicate(AmetysPredicateUtils.isAllowedForLiveContent(), propertyPredicate);
        
        cloneProperties(srcNode, clonedNode, finalPropertiesPredicate);
    }
    
    /**
     * Clones a node by preserving the source node UUID.
     * @param srcNode the source node.
     * @param clonedNode the cloned node.
     * @param propertyPredicate the property selector.
     * @param nodePredicate the node selector.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneNodeAndPreserveUUID(Node srcNode, Node clonedNode, Predicate propertyPredicate, Predicate nodePredicate) throws RepositoryException
    {
        if (srcNode == null || clonedNode == null)
        {
            return;
        }
        
        // Clone properties
        cloneProperties(srcNode, clonedNode, propertyPredicate);
        
        // Remove all matching subNodes before cloning, for better handling of same name siblings
        NodeIterator subNodes = clonedNode.getNodes();
        while (subNodes.hasNext())
        {
            Node subNode = subNodes.nextNode();
            
            if (nodePredicate.evaluate(subNode))
            {
                subNode.remove();
            }
        }
        
        // Then copy sub nodes
        NodeIterator itNodes = srcNode.getNodes();
        while (itNodes.hasNext())
        {
            Node subNode = itNodes.nextNode();
            
            if (nodePredicate.evaluate(subNode))
            {
                Node clonedSubNode = addNodeWithUUID(subNode, clonedNode, subNode.getName());
                cloneNodeAndPreserveUUID(subNode, clonedSubNode, propertyPredicate, nodePredicate);
            }
        }
    }
    
    /**
     * Will copy the LIVE version of the content into the LIVE workspace. Works only with JCRAmetysObject.
     * This method DO NOT save the liveSession.
     * @param content The content to copy
     * @param liveSession The session for live
     * @throws RepositoryException If an error occurred
     */
    public void synchronizeContent(Content content, Session liveSession) throws RepositoryException
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Synchronizing content " + content.getId());
        }
        
        if (!(content instanceof JCRAmetysObject))
        {
            return;
        }
        
        Node node = ((JCRAmetysObject) content).getNode();
        VersionHistory versionHistory = node.getSession().getWorkspace().getVersionManager().getVersionHistory(node.getPath());
        if (Arrays.asList(versionHistory.getVersionLabels()).contains(CmsConstants.LIVE_LABEL))
        {
            Node validatedContentNode = versionHistory.getVersionByLabel(CmsConstants.LIVE_LABEL).getFrozenNode();
            
            Node clonedNode;
            try
            {
                // content already exists in the live workspace
                clonedNode = liveSession.getNodeByIdentifier(node.getIdentifier());
            }
            catch (ItemNotFoundException e)
            {
                // content does not exist in the live workspace
                
                // clone content itself
                Node clonedContentParentNode = cloneAncestorsAndPreserveUUID(node, liveSession);
                
                clonedNode = addNodeWithUUID(validatedContentNode, clonedContentParentNode, node.getName());
             
            }
            
            // First, let's remove all child node and all properties (versionned or not)
            // Second, clone all versionned node and properties
            cloneContentNodeAndPreserveUUID(validatedContentNode, clonedNode, PredicateUtils.truePredicate(), PredicateUtils.truePredicate());
            
            // Third, clone all unversionned node and properties (such as acl, tags or all unversionned metadata but except initial-content or workflow)
            cloneContentNodeAndPreserveUUID(node, clonedNode, AmetysPredicateUtils.isNonVersionned(node), AmetysPredicateUtils.isNonVersionned(node));
            
            // Clone validation metadata from the current version.
            cloneContentProperties(node, clonedNode, AmetysPredicateUtils.propertyNamesPredicate("ametys:lastValidationDate", "ametys:lastMajorValidationDate", "ametys:privacy")); // FIXME CMS-7630 privacy should be not versionned
        }
        else
        {
            try
            {
                // content already exists in the live workspace
                Node clonedNode = liveSession.getNodeByIdentifier(node.getIdentifier());
                clonedNode.remove();
            }
            catch (ItemNotFoundException e)
            {
                // Ok, the content was not in live
            }
        }
    }
    
    /**
     * Clones ancestors of a node by preserving the source node UUID.
     * @param srcNode the source node.
     * @param liveSession the session to the live workspace.
     * @return the parent node in the live workspace.
     * @throws RepositoryException if an error occurs.
     */
    public Node cloneAncestorsAndPreserveUUID(Node srcNode, Session liveSession) throws RepositoryException
    {
        if (srcNode.getName().length() == 0)
        {
            // We are on the root node which already exists
            return liveSession.getRootNode();
        }
        else
        {
            Node liveRootNode = liveSession.getRootNode();
            Node parentNode = srcNode.getParent();
            String parentNodePath = parentNode.getPath().substring(1);
            
            if (liveRootNode.hasNode(parentNodePath))
            {
                // Found existing parent
                return liveRootNode.getNode(parentNodePath);
                
            }
            else
            {
                Node clonedAncestorNode = cloneAncestorsAndPreserveUUID(parentNode, liveSession);
                
                Node clonedParentNode = null;
                
                if (clonedAncestorNode.hasNode(parentNode.getName()))
                {
                    // Possible with autocreated children
                    clonedParentNode = clonedAncestorNode.getNode(parentNode.getName());
                }
                else
                {
                    clonedParentNode = addNodeWithUUID(parentNode, clonedAncestorNode, parentNode.getName());
                    
                }
                
                // reorder node when possible
                if (parentNode.getParent().getPrimaryNodeType().hasOrderableChildNodes())
                {
                    orderNode(parentNode.getParent(), parentNode.getName(), clonedParentNode);
                }
                
                // update existing acl
                synchronizeACL(parentNode, liveSession);
                
                // Copy only properties
                cloneNodeAndPreserveUUID(parentNode, clonedParentNode, PredicateUtils.truePredicate(), PredicateUtils.falsePredicate());
                
                return clonedParentNode;
            }
        }
    }
    
    /**
     * Clones a page and its eligible child pages, recursively.
     * It is assumed that parent page already exist in the live workspace
     * @param page the page to clone.
     * @param skin the skin of the page's site.
     * @param liveSession the session to the live workspace.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneEligiblePage(Page page, Skin skin, Session liveSession) throws RepositoryException
    {
        cloneEligiblePage(page, skin, liveSession, null);
    }

    /**
     * Clones a page and its eligible child pages, recursively.
     * It is assumed that parent page already exist in the live workspace
     * @param page the page to clone.
     * @param skin the skin of the page's site.
     * @param liveSession the session to the live workspace.
     * @param progressionTracker The page progression tracker for sub pages. The size should already been set. Can be null.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneEligiblePage(Page page, Skin skin, Session liveSession, SimpleProgressionTracker progressionTracker) throws RepositoryException
    {
        if (!(page instanceof JCRAmetysObject))
        {
            return;
        }
        
        Node pageNode = ((JCRAmetysObject) page).getNode();
        String pagePathInJcr = pageNode.getPath().substring(1);
        Node rootNode = liveSession.getRootNode();
        
        boolean isNew = false;
        Node liveNode = null;
        
        if (!rootNode.hasNode(pagePathInJcr))
        {
            isNew = true;
            Node parentNode = pageNode.getParent();
            String parentPath = parentNode.getPath().substring(1);
            String pageName = pageNode.getName();
            
            // We assume that the parent Node exists.
            Node liveParentNode = rootNode.getNode(parentPath);
            liveNode = addNodeWithUUID(pageNode, liveParentNode, pageNode.getName());
            
            // reorder correctly
            orderNode(parentNode, pageName, liveNode);
        }
        else
        {
            liveNode = rootNode.getNode(pagePathInJcr);
        }
        
        // Clone all but child pages and zones
        Predicate childPredicate = PredicateUtils.andPredicate(PredicateUtils.notPredicate(AmetysPredicateUtils.nodeTypePredicate("ametys:page")),
                PredicateUtils.notPredicate(AmetysPredicateUtils.nodeTypePredicate("ametys:zones")));
        
        cloneNodeAndPreserveUUID(pageNode, liveNode, PredicateUtils.truePredicate(), childPredicate);
        
        // Clone zones, if relevant
        cloneZones(pageNode, page, liveNode);
        
        if (progressionTracker != null)
        {
            progressionTracker.increment();
        }
        
        // In case of a new page , there may be valid children pages
        if (isNew)
        {
            // Clone each child page
            cloneEligibleChildrenPages(page, skin, liveSession, progressionTracker);
        }
    }
    
    /**
     * Clones the child pages of a given page, recursively, if eligible
     * It is assumed that parent page already exist in the live workspace
     * @param page the page to clone.
     * @param skin the skin of the page's site.
     * @param liveSession the session to the live workspace.
     * @param progressionTracker The page progression tracker for sub pages. The size should already been set. Can be null.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneEligibleChildrenPages(SitemapElement page, Skin skin, Session liveSession, SimpleProgressionTracker progressionTracker) throws RepositoryException
    {
        // Clone each child page
        for (Page childPage : page.getChildrenPages())
        {
            if (childPage instanceof JCRAmetysObject)
            {
                if (isPageValid(childPage, skin))
                {
                    cloneEligiblePage(childPage, skin, liveSession, progressionTracker);
                }
                else if (progressionTracker != null)
                {
                    _increment(childPage, progressionTracker);
                }
            }
        }
    }
    
    private void _increment(Page page, SimpleProgressionTracker progressionTracker)
    {
        if (page instanceof JCRAmetysObject)
        {
            progressionTracker.increment();
            for (Page childPage : page.getChildrenPages())
            {
                _increment(childPage, progressionTracker);
            }
        }
    }
    
    /**
     * Reorder a node, mirroring the order in the default workspace.
     * @param parentNode the parent of the source Node in the default workspace.
     * @param nodeName the node name.
     * @param liveNode the node in the live workspace to be reordered.
     * @throws RepositoryException if an error occurs.
     */
    public void orderNode(Node parentNode, String nodeName, Node liveNode) throws RepositoryException
    {
        _cloneComponent.orderNode(parentNode, nodeName, liveNode);
    }
    
    /**
     * Clones the zones of a page.
     * @param pageNode the JCR Node of the page.
     * @param sitemapElement the page.
     * @param liveNode the node in the live workspace.
     * @throws RepositoryException if an error occurs.
     */
    public void cloneZones(Node pageNode, SitemapElement sitemapElement, Node liveNode) throws RepositoryException
    {
        if (pageNode.hasNode("ametys-internal:zones"))
        {
            if (liveNode.hasNode("ametys-internal:zones"))
            {
                liveNode.getNode("ametys-internal:zones").remove();
            }
            
            Node zonesNode = addNodeWithUUID(pageNode.getNode("ametys-internal:zones"), liveNode, "ametys-internal:zones");
            
            for (Zone zone : sitemapElement.getZones())
            {
                Node srcZoneNode = ((JCRAmetysObject) zone).getNode();
                Node zoneNode = addNodeWithUUID(srcZoneNode, zonesNode, zone.getName());
                
                // Clone properties and children except zone items
                cloneNodeAndPreserveUUID(srcZoneNode, zoneNode, PredicateUtils.truePredicate(), PredicateUtils.notPredicate(AmetysPredicateUtils.nodeTypePredicate("ametys:zoneItems")));
                
                // Clone zone items
                Node zoneItemsNode = zoneNode.getNode("ametys-internal:zoneItems");
                for (ZoneItem zoneItem : zone.getZoneItems())
                {
                    if (_isZoneItemValid(zoneItem))
                    {
                        Node srcNode = ((JCRAmetysObject) zoneItem).getNode();
                        Node zoneItemNode = addNodeWithUUID(srcNode, zoneItemsNode, "ametys:zoneItem");
                        cloneNodeAndPreserveUUID(srcNode, zoneItemNode, PredicateUtils.truePredicate(), PredicateUtils.truePredicate());
                    }
                }
            }
        }
    }
    
    /**
     * Invalidates the hierarchy of a page if needed
     * @param page the page.
     * @param skin the skin of the page's site.
     * @param liveSession the session to the live workspace.
     * @throws RepositoryException if an error occurs.
     */
    public void invalidateHierarchy(Page page, Skin skin, Session liveSession) throws RepositoryException
    {
        String jcrPath = ((JCRAmetysObject) page).getNode().getPath();
        if (liveSession.itemExists(jcrPath))
        {
            liveSession.getItem(jcrPath).remove();
        }

        AmetysObject parent = page.getParent();
        
        if (parent instanceof Page)
        {
            if (!isPageValid((Page) parent, skin))
            {
                invalidateHierarchy((Page) parent, skin, liveSession);
            }
        }
    }
    
    /**
     * Synchronizes a page with the live workspace. Also synchronizes hierarchy.
     * @param page the page.
     * @param skin the skin of the page's site.
     * @param liveSession the session to the live workspace.
     * @throws RepositoryException if an error occurs.
     */
    public void synchronizePage(Page page, Skin skin, Session liveSession) throws RepositoryException
    {
        if (isHierarchyValid(page, liveSession))
        {
            if (isPageValid(page, skin))
            {
                //FIXME clone ancestor pages, not only ancestor nodes
                cloneAncestorsAndPreserveUUID(((JCRAmetysObject) page).getNode(), liveSession);
                
                // clone page and valid children
                cloneEligiblePage(page, skin, liveSession);
            }
            else
            {
                // page is invalid, remove it from live if it was previously valid, then potentially invalidate hierarchy
                invalidateHierarchy(page, skin, liveSession);
            }
        }
    }
    
    private void _sendErrorMailForInfiniteRedirection (Page page)
    {
        String recipient = Config.getInstance().getValue("smtp.mail.sysadminto");
        try
        {
            List<String> i18nParams = new ArrayList<>();
            i18nParams.add(page.getSite().getTitle());
            
            I18nizableText i18nSubject = new I18nizableText("plugin.web", "PLUGINS_WEB_SYNCHRONIZE_INFINITE_REDIRECTION_MAIL_SUBJECT", i18nParams);
            String subject = _i18nUtils.translate(i18nSubject);
            
            i18nParams.add(page.getSitemapName() + "/" + page.getPathInSitemap());
            i18nParams.add(StringUtils.stripEnd(StringUtils.removeEndIgnoreCase(Config.getInstance().getValue("cms.url"), "index.html"), "/"));
            String body = _i18nUtils.translate(new I18nizableText("plugin.web", "PLUGINS_WEB_SYNCHRONIZE_INFINITE_REDIRECTION_MAIL_BODY", i18nParams));
            
            SendMailHelper.newMail()
                          .withSubject(subject)
                          .withTextBody(body)
                          .withRecipient(recipient)
                          .sendMail();
        }
        catch (MessagingException | IOException e)
        {
            if (getLogger().isWarnEnabled())
            {
                getLogger().warn("Could not send an alert e-mail to " + recipient, e);
            }
        }
    }
    
    /**
     * Synchronize a node ACL information with node in live session if available
     * This method does NOT save live session
     * @param node The trunk node in default workspace
     * @param liveSession The live session
     */
    public void synchronizeACL(Node node, Session liveSession)
    {
        try
        {
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Synchronizing ACL for node " + node.getIdentifier());
            }

            try
            {
                // content already exists in the live workspace
                Node clonedNode = liveSession.getNodeByIdentifier(node.getIdentifier());
                
                // Clone acl
                String aclNodeNode = "ametys-internal:acl";
                if (node.hasNode(aclNodeNode))
                {
                    Node aclNode = node.getNode(aclNodeNode);
                    
                    Node aclClonedNode;
                    if (clonedNode.hasNode(aclNodeNode))
                    {
                        aclClonedNode = clonedNode.getNode(aclNodeNode);
                    }
                    else
                    {
                        aclClonedNode = clonedNode.addNode(aclNodeNode, aclNode.getPrimaryNodeType().getName());
                    }

                    cloneNodeAndPreserveUUID(aclNode, aclClonedNode, PredicateUtils.truePredicate(), PredicateUtils.truePredicate());
                }
            }
            catch (ItemNotFoundException e)
            {
                // Nothing to synchronize: the content is not in live
            }
        }
        catch (RepositoryException e)
        {
            throw new RuntimeException("Can not copy ACL for node", e);
        }
    }

    /**
     * Synchronize a list of content to the targeted session
     * @param contents the set of contents
     * @param liveSession the target session
     * @param progressionTracker The progression tracker
     * @throws AmetysRepositoryException if an error occurred while synchronizing
     */
    public void synchronizeContents(AmetysObjectIterable<Content> contents, Session liveSession, SimpleProgressionTracker progressionTracker) throws AmetysRepositoryException
    {
        long nbContents = contents.getSize();
        
        progressionTracker.setSize(nbContents);
        for (Content content : contents)
        {
            try
            {
                synchronizeContent(content, liveSession);
                liveSession.save();
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException("Synchronization failed for content " + content.getId() + ". See below for more information.", e);
            }
            
            progressionTracker.increment();
        }
    }
}