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

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;

import javax.jcr.ItemExistsException;
import javax.jcr.ItemNotFoundException;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Value;

import org.apache.commons.lang.StringUtils;

import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.explorer.resources.jcr.JCRResourcesCollectionFactory;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.RepositoryIntegrityViolationException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.jcr.JCRTraversableAmetysObject;
import org.ametys.plugins.repository.jcr.NodeHelper;
import org.ametys.plugins.repository.jcr.SimpleAmetysObject;
import org.ametys.plugins.repository.tag.TaggableAmetysObjectHelper;
import org.ametys.plugins.repository.trash.TrashElement;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.plugins.repository.trash.UnknownParentException;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.NotUniqueTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.exception.UnknownTypeException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.web.parameters.view.ViewParametersManager;
import org.ametys.web.repository.page.LockablePage;
import org.ametys.web.repository.page.ModifiableZone;
import org.ametys.web.repository.page.MoveablePage;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PageDAO;
import org.ametys.web.repository.page.SitemapElement;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;

/**
 * {@link Page} implementation stored into a JCR node using
 * <code>ametys:defaultPage</code> node type.
 * 
 * @param <F> the actual type of factory.
 */
public class DefaultPage<F extends DefaultPageFactory> extends AbstractSitemapElement<F> implements LockablePage, CopiableAmetysObject, MoveablePage, TrashableAmetysObject
{
    /** Constant for template metadata. */
    public static final String METADATA_TEMPLATE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":template";

    /** Constant for title metadata. */
    public static final String METADATA_TITLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":title";

    /** Constant for the initial title metadata. */
    public static final String METADATA_INITIAL_TITLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":title-initial";

    /** Constant for long title metadata. */
    public static final String METADATA_LONG_TITLE = "long-title";

    /** Constant for title metadata. */
    public static final String METADATA_TYPE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":type";

    /** Constant for title metadata. */
    public static final String METADATA_URL = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":url";

    /** Constant for title metadata. */
    public static final String METADATA_URLTYPE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":url-type";

    /** Constant for referers metadata. */
    public static final String METADATA_REFERERS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":referers";
    
    /** Constant for the visible attribute. */
    public static final String METADATA_VISIBLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":visible";
    
    /** Constant for the locked attribute. */
    public static final String METADATA_LOCKED = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":locked";

    /** Constant for robots metadata. */
    public static final String METADATA_ROBOTS_DISALLOW = "robots-disallow";
    
    /** Constant for the attachment node name. */
    public static final String ATTACHMENTS_NODE_NAME = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":attachments";
    
    /** Constants for sitemap Metadata* */
    public static final String METADATA_SITEMAP = "sitemap";

    /** Constant for publication start date metadata. */
    public static final String METADATA_PUBLICATION_START_DATE = "publicationStartDate";
    
    /** Constant for publication end date metadata. */
    public static final String METADATA_PUBLICATION_END_DATE = "publicationEndDate";
    
    /**
     * Creates a {@link DefaultPage}.
     * 
     * @param node the node backing this {@link AmetysObject}.
     * @param parentPath the parent path in the Ametys hierarchy.
     * @param factory the {@link DefaultPageFactory} which creates the
     *            AmetysObject.
     */
    public DefaultPage(Node node, String parentPath, F factory)
    {
        super(node, parentPath, factory);
    }
    
    @Override
    public String getTemplate() throws AmetysRepositoryException
    {
        if (getType() != PageType.CONTAINER)
        {
            return null;
        }
        
        try
        {
            Node node = getNode();
            
            if (node.hasProperty(METADATA_TEMPLATE))
            {
                return node.getProperty(METADATA_TEMPLATE).getString();
            }
            else
            {
                return null;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get template property", e);
        }
    }

    @Override
    public void setTemplate(String template) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TEMPLATE, template);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set template property", e);
        }
    }

    @Override
    public Set<String> getTags() throws AmetysRepositoryException
    {
        return TaggableAmetysObjectHelper.getTags(this);
    }
    
    @Override
    public void tag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.tag(this, tag);
    }

    @Override
    public void untag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.untag(this, tag);
    }

    @Override
    public String getTitle() throws AmetysRepositoryException
    {
        try
        {
            return getNode().getProperty(METADATA_TITLE).getString();
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get title property", e);
        }
    }
    
    @Override
    public void setTitle(String title) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TITLE, title);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set title property", e);
        }
        setInitialTitle(title);
    }

    /**
     * Get the title that was set by the user (and not set by a copy adding a number after)
     * @return The initial title
     * @throws AmetysRepositoryException if an error occurs
     */
    public String getInitialTitle()  throws AmetysRepositoryException
    {
        try
        {
            if (getNode().hasProperty(METADATA_INITIAL_TITLE))
            {
                return getNode().getProperty(METADATA_INITIAL_TITLE).getString();
            }
            else
            {
                return getTitle();
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get initial title property", e);
        }
    }
    
    /**
     * Set the title that was set by the user (and not set by a copy adding a number after)
     * @param initialTitle The initial title to set
     * @throws AmetysRepositoryException if an error occurs
     */
    public void setInitialTitle(String initialTitle) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_INITIAL_TITLE, initialTitle);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set initial title property", e);
        }
    }

    @Override
    public String getLongTitle() throws AmetysRepositoryException
    {
        String longTitle = getValue(METADATA_LONG_TITLE);
        if (StringUtils.isNotBlank(longTitle))
        {
            return longTitle;
        }
        else
        {
            return this.getTitle();
        }
    }

    @Override
    public void setLongTitle(String title) throws AmetysRepositoryException
    {
        String newTitle = StringUtils.trimToNull(title);
        setValue(METADATA_LONG_TITLE, newTitle, ModelItemTypeConstants.STRING_TYPE_ID);
    }

    @Override
    public Sitemap getSitemap() throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            do
            {
                node = node.getParent();
            }
            while (!node.getPrimaryNodeType().getName().equals(Sitemap.NODE_TYPE));

            return _getFactory().resolveAmetysObject(node);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get sitemap", e);
        }
    }
    
    @Override
    public int getDepth() throws AmetysRepositoryException
    {
        try
        {
            int depth = 1;
            Node node = getNode().getParent();
            while (!node.getPrimaryNodeType().getName().equals(Sitemap.NODE_TYPE))
            {
                depth++;
                node = node.getParent();
            }

            return depth;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get depth", e);
        }
    }

    @Override
    public Site getSite() throws AmetysRepositoryException
    {
        return getSitemap().getSite();
    }
    
    @Override
    public String getSiteName()
    {
        return getValue(METADATA_SITE);
    }
    
    @Override
    public void setSiteName(String siteName)
    {
        setValue(METADATA_SITE, siteName);
    }
    
    @Override
    public String getSitemapName() throws AmetysRepositoryException
    {
        return getValue(METADATA_SITEMAP);
    }
    
    @Override
    public void setSitemapName(String sitemapName) throws AmetysRepositoryException
    {
        setValue(METADATA_SITEMAP, sitemapName);
    }

    @Override
    public String getPathInSitemap() throws AmetysRepositoryException
    {
        String nodePath = getPath();
        String sitemapPath = getSitemap().getPath();
        return nodePath.substring(sitemapPath.length() + 1);
    }

    @Override
    public PageType getType() throws AmetysRepositoryException
    {
        try
        {
            return PageType.valueOf(getNode().getProperty(METADATA_TYPE).getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get type property", e);
        }
    }

    @Override
    public void setType(PageType type) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TYPE, type.name());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set type property", e);
        }
    }

    @Override
    public String getURL() throws AmetysRepositoryException
    {
        try
        {
            return getNode().getProperty(METADATA_URL).getString();
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get url property", e);
        }
    }
    
    @Override
    public LinkType getURLType() throws AmetysRepositoryException
    {
        try
        {
            return LinkType.valueOf(getNode().getProperty(METADATA_URLTYPE).getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get url type property", e);
        }
    }

    @Override
    public void setURL(LinkType type, String url) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_URLTYPE, type.toString());
            getNode().setProperty(METADATA_URL, url);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set url property", e);
        }
    }

    @Override
    public ResourceCollection getRootAttachments() throws AmetysRepositoryException
    {
        ResourceCollection attachments;
        if (hasChild(ATTACHMENTS_NODE_NAME))
        {
            attachments = getChild(ATTACHMENTS_NODE_NAME);
        }
        else
        {
            attachments = createChild(ATTACHMENTS_NODE_NAME, JCRResourcesCollectionFactory.RESOURCESCOLLECTION_NODETYPE);
            
            try
            {
                getNode().getSession().save();
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException("Unable to save session", e);
            }
        }
        
        return attachments;
    }
    
    @Override
    public Set<String> getReferers() throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            if (!node.hasProperty(METADATA_REFERERS))
            {
                return Collections.emptySet();
            }

            Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
            Set<String> ids = new HashSet<>(values.length);

            for (Value value : values)
            {
                ids.add(value.getString());
            }

            return ids;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get referers property", e);
        }
    }

    @Override
    public void addReferer(String ametysObjectId) throws AmetysRepositoryException
    {
        try
        {
            Set<String> ids = null;
            Node node = getNode();

            if (!node.hasProperty(METADATA_REFERERS))
            {
                ids = Collections.singleton(ametysObjectId);
            }
            else
            {
                Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
                ids = new HashSet<>(values.length + 1);

                for (Value value : values)
                {
                    ids.add(value.getString());
                }

                ids.add(ametysObjectId);
            }

            node.setProperty(METADATA_REFERERS, ids.toArray(new String[ids.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to add an id into referers property", e);
        }
    }

    @Override
    public void removeReferer(String ametysObjectId) throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            if (node.hasProperty(METADATA_REFERERS))
            {
                Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
                Set<String> ids = new HashSet<>(values.length + 1);

                for (Value value : values)
                {
                    ids.add(value.getString());
                }

                ids.remove(ametysObjectId);
                node.setProperty(METADATA_REFERERS, ids.toArray(new String[ids.size()]));
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to remove an id from referers property", e);
        }
    }
    
    @Override
    public DefaultPage copyTo(ModifiableTraversableAmetysObject parent, String name, List<String> restrictTo) throws AmetysRepositoryException
    {
        try
        {
            String pageName = PageDAO.findFreePageName(parent, name != null ? name : getName());
            
            DefaultPage cPage = parent.createChild(pageName, "ametys:defaultPage");
            cPage.setType(getType());
            cPage.setTitle(getTitle());
            cPage.setInitialTitle(getInitialTitle());
            
            if (PageType.CONTAINER.equals(getType()))
            {
                cPage.setTemplate(getTemplate());
            }
            else if (PageType.LINK.equals(getType()))
            {
                cPage.setURL(getURLType(), getURL());
            }
            
            // Copy metadata
            copyTo(cPage);
            
            // Copy view parameters
            getTemplateParametersHolder().copyTo(cPage.getTemplateParametersHolder());
            
            // Copy zones
            for (ModifiableZone zone : getZones())
            {
                if (zone instanceof CopiableAmetysObject)
                {
                    ((CopiableAmetysObject) zone).copyTo(cPage, null);
                }
            }
            
            // Copy tags
            Set<String> tags = getTags();
            for (String tag : tags)
            {
                cPage.tag(tag);
            }
            
            // Update sitemap name
            if (parent instanceof SitemapElement)
            {
                cPage.setSitemapName(((SitemapElement) parent).getSitemapName());
            }
            
            parent.saveChanges();
            
            // Copy attachments
            ResourceCollection rootAttachments = getRootAttachments();
            if (rootAttachments instanceof SimpleAmetysObject)
            {
                Node resourcesNode = ((SimpleAmetysObject) rootAttachments).getNode();
                getNode().getSession().getWorkspace().copy(resourcesNode.getPath(), cPage.getNode().getPath() + "/" + resourcesNode.getName());
            }
            
            // Copy sub-pages
            AmetysObjectIterable< ? extends Page> childrenPages = getChildrenPages();
            for (Page page : childrenPages)
            {
                // Avoid infinite loop : do not copy the page itself
                if (page instanceof CopiableAmetysObject && restrictTo.contains(page.getId()))
                {
                    ((CopiableAmetysObject) page).copyTo(cPage, null, restrictTo);
                }
            }
            
            return cPage;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    @Override
    public DefaultPage copyTo(ModifiableTraversableAmetysObject parent, String name) throws AmetysRepositoryException
    {
        return copyTo (parent, name, new ArrayList<>());
    }
    
    public void copyTo(ModifiableDataHolder dataHolder) throws UndefinedItemPathException, BadItemTypeException, UnknownTypeException, NotUniqueTypeException
    {
        for (String name : getDataNames())
        {
            if (!_getExcludedDataFromCopy().contains(name))
            {
                DataHolderHelper.copyTo(getDataHolder(), dataHolder, name, DataContext.newInstance());
            }
        }
    }
    
    /**
     * Get the set of data name to exclude from the copy
     * @return the set of data name to exclude from the copy
     */
    protected Set<String> _getExcludedDataFromCopy()
    {
        return Set.of(
            ViewParametersManager.VIEW_PARAMETERS_COMPOSITE_NAME,
            METADATA_PUBLICATION_START_DATE,
            METADATA_PUBLICATION_END_DATE
        );
    }
    
    @Override
    public void moveTo(AmetysObject newParent, boolean renameIfExist) throws AmetysRepositoryException, RepositoryIntegrityViolationException
    {
        Node node = getNode();

        try
        {
            if (getParent().equals(newParent))
            {
                // Just order current node to the end
                node.getParent().orderBefore(node.getName(), null);
            }
            else
            {
                if (!canMoveTo(newParent))
                {
                    throw new AmetysRepositoryException("DefaultPage " + toString() + " can only be moved to a CompositePages and ");
                }
                SitemapElement newParentPage = (SitemapElement) newParent;
                
                String sitemapNodePath = getSitemap().getNode().getPath();
                String newPath = sitemapNodePath + (newParentPage instanceof Sitemap ? "" : '/' + newParentPage.getPathInSitemap());

                String name = node.getName();
                
                if (renameIfExist)
                {
                    // Find unused name on new parent node
                    int index = 1;
                    while (node.getSession().getRootNode().hasNode(newPath.substring(1) + "/" + name))
                    {
                        name = name + "-" + index++;
                    }
                }

                try
                {
                    // Move node
                    node.getSession().move(node.getPath(), newPath + "/" + name);
                }
                catch (ItemExistsException e)
                {
                    throw new AmetysRepositoryException(String.format("A page already exists for in parent path '%s'", newPath), e);
                }
                
                // recompute name in case it has changed
                _invalidateName();

                // Invalidate parent path as the parent path has changed
                _invalidateParentPath();
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(String.format("Unable to move page '%s' to node '%s'", this, newParent.getId()), e);
        }
    }
    
    @Override
    public boolean canMoveTo(AmetysObject newParent) throws AmetysRepositoryException
    {
        return  newParent instanceof SitemapElement && ((SitemapElement) newParent).getSitemap().equals(getSitemap());
    }

    @Override
    public void orderBefore(AmetysObject siblingNode) throws AmetysRepositoryException
    {
        Node node = getNode();
        try
        {
            node.getParent().orderBefore(node.getName(), siblingNode != null ? siblingNode.getName() : null);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(String.format("Unable to order page '%s' before sibling '%s'", this, siblingNode != null ? siblingNode.getName() : ""), e);
        }
    }

    @Override
    public boolean isVisible() throws AmetysRepositoryException
    {
        try
        {
            if (getNode().hasProperty(METADATA_VISIBLE))
            {
                return getNode().getProperty(METADATA_VISIBLE).getBoolean();
            }
            else
            {
                return true;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get visible property", e);
        }
    }
    
    @Override
    public void setVisible(boolean isVisible) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_VISIBLE, isVisible);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set visible property", e);
        }
    }
    
    public Map<String, Object> dataToJSON(DataContext context) throws UnknownTypeException, NotUniqueTypeException
    {
        Map<String, Object> result = new HashMap<>();
        for (String dataName : getDataNames())
        {
            DataContext newContext = context.cloneContext().addSegmentToDataPath(dataName);
            result.put(dataName, dataToJSON(dataName, newContext));
        }
        
        return result;
    }
    
    public Object dataToJSON(String dataPath, DataContext context)
    {
        // Do not convert view parameters
        return !ViewParametersManager.VIEW_PARAMETERS_COMPOSITE_NAME.equals(dataPath)
                ? LockablePage.super.dataToJSON(dataPath, context)
                : null;
    }

    public boolean isLocked() throws AmetysRepositoryException
    {
        try
        {
            if (getNode().hasProperty(METADATA_LOCKED))
            {
                return getNode().getProperty(METADATA_LOCKED).getBoolean();
            }
            else
            {
                return false;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get locked property", e);
        }
    }

    public void lock() throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_LOCKED, true);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set locked property", e);
        }
    }

    public void unlock() throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_LOCKED, false);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set locked property", e);
        }
    }
    
    public TrashElement moveToTrash()
    {
        TrashElement trashElement = _getFactory()._getTrashElementDAO().createTrashElement(this, getTitle());
        
        // Clone the ametys object from the original session to trash session
        Node storedNode = NodeHelper.cloneNode(getNode(), trashElement.getNode());
        
        try
        {
            storedNode.setProperty("ametys-internal:path", getParentPath());
            // Update strong reference data to avoid NoSuchElementException
            DefaultPage<?> page = trashElement.getChild(storedNode.getName());
            page._updateContentReferences(this::_saveContentReference);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("failed to store the content path", e);
        }

        // Remove the node from the original session
        remove();
        
        return trashElement;
    }
    
    public DefaultPage restoreFromTrash() throws UnknownParentException
    {
        try
        {
            Property property = getNode().getProperty("ametys-internal:path");
            String parentPath = property.getValue().getString();
            property.remove();
            JCRTraversableAmetysObject parent;
            try
            {
                parent = _getFactory()._getResolver().resolveByPath(parentPath);
            }
            catch (UnknownAmetysObjectException e)
            {
                throw new UnknownParentException("No parent available at path " + parentPath, e);
            }
            
            // Get the node name, can be adjust if another content has already the same node name
            String nodeName = parent.hasChild(getName()) ? PageDAO.findFreePageNameByTitle(parent, getTitle()) : getName();
            // Clone the ametys object from the trash session to default session
            Node restoredNode = NodeHelper.cloneNode(getNode(), parent.getNode(), nodeName);
            
            // Update strong reference data to avoid NoSuchElementException
            DefaultPage<?> page = parent.getChild(restoredNode.getName());
            page._updateContentReferences(this::_restoreContentReference);
            
            // Remove the node from the trash session
            remove();
            
            return page;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("failed to retrieve the page path", e);
        }
    }
    
    private void _updateContentReferences(Consumer<DefaultZoneItem> updateConsumer)
    {
        // Get contents referencing into the pages
        getZones().stream()
            .map(Zone::getZoneItems)
            .flatMap(AmetysObjectIterable::stream)
            .filter(DefaultZoneItem.class::isInstance)
            .filter(zi -> zi.getType() == ZoneItem.ZoneType.CONTENT)
            .map(DefaultZoneItem.class::cast)
            .forEach(updateConsumer);
        
        // Explore children pages
        getChildrenPages().stream()
            .filter(DefaultPage.class::isInstance)
            .map(p -> (DefaultPage<?>) p)
            .forEach(p -> p._updateContentReferences(updateConsumer));
    }
    
    private void _saveContentReference(DefaultZoneItem zoneItem)
    {
        try
        {
            Node zoneItemNode = zoneItem.getNode();
            if (zoneItemNode.hasProperty(DefaultZoneItem.METADATA_CONTENT))
            {
                Property oldProperty = zoneItemNode.getProperty(DefaultZoneItem.METADATA_CONTENT);
                zoneItemNode.setProperty("ametys-internal:trash-content", oldProperty.getValue(), PropertyType.WEAKREFERENCE);
                oldProperty.remove();
            }
            else
            {
                // If the content property is not there, zone item is obsolete, remove it
                zoneItem.remove();
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }

    private void _restoreContentReference(DefaultZoneItem zoneItem)
    {
        try
        {
            Node zoneItemNode = zoneItem.getNode();
            Property oldProperty = zoneItemNode.getProperty("ametys-internal:trash-content");
            try
            {
                // Check if the node is in the target session
                oldProperty.getNode();
                
                // Update the reference
                zoneItemNode.setProperty(DefaultZoneItem.METADATA_CONTENT, oldProperty.getValue(), PropertyType.REFERENCE);
                oldProperty.remove();
            }
            catch (ItemNotFoundException e)
            {
                // The content is not in the target session, remove the zone item
                zoneItem.remove();
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
}