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

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

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

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
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.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.content.archive.ArchiveConstants;
import org.ametys.cms.content.referencetable.HierarchicalReferenceTablesHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.data.ContentDataHelper;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.lock.LockContentManager;
import org.ametys.cms.repository.ReactionableObject.ReactionType;
import org.ametys.cms.rights.ContentRightAssignmentContext;
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.cms.workflow.AbstractContentWorkflowComponent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
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.core.user.UserManager;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.explorer.ExplorerNode;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.explorer.resources.ResourceCollection;
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.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.holder.ModifiableModelLessDataHolder;
import org.ametys.plugins.repository.lock.LockAwareAmetysObject;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.plugins.repository.tag.TaggableAmetysObject;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.plugins.repository.version.ModifiableDataAwareVersionableAmetysObject;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.component.CheckRightsCondition;
import org.ametys.plugins.workflow.store.AbstractJackrabbitWorkflowStore;
import org.ametys.plugins.workflow.store.AmetysObjectWorkflowStore;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.authentication.AccessDeniedException;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.type.DataContext;

import com.opensymphony.workflow.WorkflowException;
import com.opensymphony.workflow.spi.Step;

/**
 * DAO for manipulating contents
 *
 */
public class ContentDAO extends AbstractLogEnabled implements Serviceable, Component, Contextualizable
{
    /** Avalon Role */
    public static final String ROLE = ContentDAO.class.getName();

    /** Deletion status : deleted */
    protected static final String _CONTENT_DELETION_STATUS_DELETED = "deleted";

    /** Deletion status : undeleted */
    protected static final String _CONTENT_DELETION_STATUS_UNDELETED = "undeleted";

    /** Deletion status : referenced */
    protected static final String _CONTENT_DELETION_STATUS_REFERENCED = "referenced";

    /** Deletion status : unauthorized */
    protected static final String _CONTENT_DELETION_STATUS_UNAUTHORIZED = "unauthorized";

    /** Deletion status : locked */
    protected static final String _CONTENT_DELETION_STATUS_LOCKED = "locked";
    
    /** Ametys resolver */
    protected AmetysObjectResolver _resolver;
    /** Ametys observation manger */
    protected ObservationManager _observationManager;
    /** Component to get current user */
    protected CurrentUserProvider _currentUserProvider;
    /** Component to get tags */
    protected TagProviderExtensionPoint _tagProvider;

    /** Workflow component */
    protected WorkflowProvider _workflowProvider;
    /** Workflow helper component */
    protected ContentWorkflowHelper _contentWorkflowHelper;
    /** Component to manager lock */
    protected LockContentManager _lockManager;
    /** Content-type extension point */
    protected ContentTypeExtensionPoint _contentTypeEP;
    /** Content helper */
    protected ContentHelper _contentHelper;
    /** Content types helper */
    protected ContentTypesHelper _cTypesHelper;
    /** Rights manager */
    protected RightManager _rightManager;
    /** Cocoon context */
    protected Context _context;
    /** The user manager */
    protected UserManager _usersManager;
    /** Helper for users */
    protected UserHelper _userHelper;
    /** The helper component for hierarchical simple contents */
    protected HierarchicalReferenceTablesHelper _hierarchicalSimpleContentsHelper;
    /** The modifiable content helper */
    protected ModifiableContentHelper _modifiableContentHelper;
    /** The trash helper */
    protected TrashElementDAO _trashElementDAO;
    
    /** The mode for tag edition */
    public enum TagMode
    {
        /** Value will replace existing one */
        REPLACE,
        /** Value will be added to existing one */
        INSERT,
        /** Value will be removed from existing one */
        REMOVE
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) smanager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _usersManager = (UserManager) smanager.lookup(UserManager.ROLE);
        _userHelper = (UserHelper) smanager.lookup(UserHelper.ROLE);
        _tagProvider = (TagProviderExtensionPoint) smanager.lookup(TagProviderExtensionPoint.ROLE);
        _workflowProvider = (WorkflowProvider) smanager.lookup(WorkflowProvider.ROLE);
        _rightManager = (RightManager) smanager.lookup(RightManager.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) smanager.lookup(ContentTypeExtensionPoint.ROLE);
        _lockManager = (LockContentManager) smanager.lookup(LockContentManager.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) smanager.lookup(ContentWorkflowHelper.ROLE);
        _cTypesHelper = (ContentTypesHelper) smanager.lookup(ContentTypesHelper.ROLE);
        _contentHelper = (ContentHelper) smanager.lookup(ContentHelper.ROLE);
        _modifiableContentHelper = (ModifiableContentHelper) smanager.lookup(ModifiableContentHelper.ROLE);
        _hierarchicalSimpleContentsHelper = (HierarchicalReferenceTablesHelper) smanager.lookup(HierarchicalReferenceTablesHelper.ROLE);
        _trashElementDAO = (TrashElementDAO) smanager.lookup(org.ametys.plugins.repository.trash.TrashElementDAO.ROLE);
    }

    /**
     * Trash contents if possible or delete it and force the deletion of invert relations.
     * @param contentsId The ids of contents to delete
     * @return the deleted and undeleted contents
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> forceTrashContents(List<String> contentsId)
    {
        return forceTrashContentsObj(
            contentsId.stream()
                .map(_resolver::<Content>resolveById)
                .collect(Collectors.toList()),
            getRightToDelete()
        );
    }
    
    /**
     * Delete contents and force the deletion of invert relations.
     * @param contentsId The ids of contents to delete
     * @return the deleted and undeleted contents
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> forceDeleteContents(List<String> contentsId)
    {
        return forceDeleteContentsObj(
            contentsId.stream()
                .map(_resolver::<Content>resolveById)
                .collect(Collectors.toList()),
            getRightToDelete()
        );
    }

    /**
     * Trash contents if possible or delete it and force the deletion of invert relations.
     * @param contents The contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> forceTrashContentsObj(List<Content> contents, String deleteRightId)
    {
        return _forceDeleteContentsObj(contents, deleteRightId, false);
    }

    /**
     * Delete contents and force the deletion of invert relations.
     * @param contents The contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> forceDeleteContentsObj(Iterable<Content> contents, String deleteRightId)
    {
        return _forceDeleteContentsObj(contents, deleteRightId, true);
    }
    
    private Map<String, Object> _forceDeleteContentsObj(Iterable<Content> contents, String deleteRightId, boolean onlyDeletion)
    {
        Map<String, Object> results = _initializeResultsMap();
        
        for (Content content : contents)
        {
            Map<String, Object> contentParams = _transformContentToParams(content);
            
            String contentDeletionStatus = _getContentDeletionStatus(content, deleteRightId);
            
            // The content is referenced, remove referencies
            // Then remove referencies if you can
            // Then check that the content is not referenced any more (should not happen)
            if (contentDeletionStatus != null && contentDeletionStatus.equals(_CONTENT_DELETION_STATUS_REFERENCED) && _removeReferences(content) && !_isContentReferenced(content))
            {
                contentDeletionStatus = null;
            }
            
            // The content has no constraints
            if (contentDeletionStatus == null)
            {
                contentDeletionStatus = _reallyDeleteContent(content, onlyDeletion);
            }
            
            String key = contentDeletionStatus + "-contents";
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> statusedContents = (List<Map<String, Object>>) results.get(key);
            statusedContents.add(contentParams);
        }
        
        return results;
    }
    
    /**
     * Get the invert action id (used for forced deletion).
     * @return The invert action id
     */
    protected int _getInvertActionId()
    {
        return EditContentFunction.INVERT_EDIT_ACTION_ID;
    }
    
    /**
     * Get the right to delete a content.
     * @return The right ID to delete a content
     */
    protected String getRightToDelete()
    {
        return "CMS_Rights_DeleteContent";
    }
    
    /**
     * Remove all the references to the given content.
     * @param content The content
     * @return <code>true</code> if references have been all removed successfully
     */
    protected boolean _removeReferences(Content content)
    {
        int actionId = _getInvertActionId();
        
        // Group references by referencer
        Map<Content, Set<String>> referencesByContent = new HashMap<>();
        for (Pair<String, Content> referencingPair : _contentHelper.getReferencingContents(content))
        {
            Set<String> references = referencesByContent.computeIfAbsent(referencingPair.getValue(), __ -> new HashSet<>());
            references.add(referencingPair.getKey());
        }
        
        // Control that each referencer has the invert action available
        for (Content referencingContent : referencesByContent.keySet())
        {
            if (referencingContent instanceof WorkflowAwareContent
                    && !_contentWorkflowHelper.isAvailableAction((WorkflowAwareContent) referencingContent, actionId))
            {
                getLogger().warn("The action " + actionId + " is not available for the referencing content " + referencingContent.getId() + ". Impossible to delete the content " + content.getId() + ".");
                return false;
            }
        }
        
        // Get the references
        for (Content referencingContent : referencesByContent.keySet())
        {
            // Break the references
            for (String referencingPath : referencesByContent.get(referencingContent))
            {
                if (referencingContent instanceof ModifiableContent)
                {
                    if (referencingContent.isMultiple(referencingPath))
                    {
                        String[] values = ContentDataHelper.getContentIdsStreamFromMultipleContentData(referencingContent, referencingPath)
                            .filter(id -> !id.equals(content.getId()))
                            .toArray(String[]::new);
                        ((ModifiableContent) referencingContent).setValue(referencingPath, values);
                    }
                    else
                    {
                        ((ModifiableContent) referencingContent).removeValue(referencingPath);
                    }
                }
            }
            
            // edit
            Map<String, Object> contextParameters = new HashMap<>();
            contextParameters.put("quit", true);
            
            Map<String, Object> inputs = new HashMap<>();
            inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, contextParameters);
            inputs.put(CheckRightsCondition.FORCE, true);
            
            if (referencingContent instanceof WorkflowAwareContent)
            {
                try
                {
                    _contentWorkflowHelper.doAction((WorkflowAwareContent) referencingContent, actionId, inputs);
                }
                catch (WorkflowException e)
                {
                    getLogger().error("An error occured while trying to update the workflow of the referencer " + referencingContent.toString(), e);
                }
            }
        }
        
        return true;
    }
    
    /**
     * Trash contents if possible or delete it
     * @param contentsId The ids of contents to delete
     * @return the deleted and undeleted contents
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> trashContents(List<String> contentsId)
    {
        return trashContents(contentsId, false);
    }
    
    /**
     * Trash contents if possible or delete it
     * @param contentsId The ids of contents to delete
     * @param ignoreRights true to ignore user rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> trashContents(List<String> contentsId, boolean ignoreRights)
    {
        return trashContents(contentsId, ignoreRights ? null : getRightToDelete());
    }
    
    /**
     * Trash contents if possible or delete it
     * @param contentsId The ids of contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> trashContents(List<String> contentsId, String deleteRightId)
    {
        return _deleteContents(contentsId, deleteRightId, false);
    }
    
    /**
     * Delete contents
     * @param contentsId The ids of contents to delete
     * @return the deleted and undeleted contents
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> deleteContents(List<String> contentsId)
    {
        return deleteContents(contentsId, false);
    }
    
    /**
     * Delete contents
     * @param contentsId The ids of contents to delete
     * @param ignoreRights true to ignore user rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContents(List<String> contentsId, boolean ignoreRights)
    {
        return deleteContents(contentsId, ignoreRights ? null : getRightToDelete());
    }
    
    /**
     * Delete contents
     * @param contentsId The ids of contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContents(List<String> contentsId, String deleteRightId)
    {
        return _deleteContents(contentsId, deleteRightId, true);
    }
    
    
    private Map<String, Object> _deleteContents(List<String> contentsId, String deleteRightId, boolean onlyDeletion)
    {
        Map<String, Object> results = _initializeResultsMap();
        
        for (String contentId : contentsId)
        {
            Content content = _resolver.resolveById(contentId);
            Map<String, Object> contentParams = _transformContentToParams(content);
            
            String contentDeletionStatus = _getContentDeletionStatus(content, deleteRightId);
            
            // The content has no constraints
            if (contentDeletionStatus == null)
            {
                contentDeletionStatus = _reallyDeleteContent(content, onlyDeletion);
            }
            
            String key = contentDeletionStatus + "-contents";
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> statusedContents = (List<Map<String, Object>>) results.get(key);
            statusedContents.add(contentParams);
        }
        
        return results;
    }
    
    /**
     * Initialize the result map.
     * @return The empty result map.
     */
    protected Map<String, Object> _initializeResultsMap()
    {
        Map<String, Object> results = new HashMap<>();

        results.put(_CONTENT_DELETION_STATUS_DELETED + "-contents", new ArrayList<>());
        results.put(_CONTENT_DELETION_STATUS_UNDELETED + "-contents", new ArrayList<>());
        results.put(_CONTENT_DELETION_STATUS_REFERENCED + "-contents", new ArrayList<>());
        results.put(_CONTENT_DELETION_STATUS_UNAUTHORIZED + "-contents", new ArrayList<>());
        results.put(_CONTENT_DELETION_STATUS_LOCKED + "-contents", new ArrayList<>());
        
        return results;
    }
    
    /**
     * Delete the content and notify observers.
     * @param content The content to delete
     * @param onlyDeletion <code>true</code> to really delete the content, otherwise the content will be trashed if trashable
     * @return The deletion status "deleted" or "undeleted" if an exception occurs
     */
    protected String _reallyDeleteContent(Content content, boolean onlyDeletion)
    {
        try
        {
            // All checks have been done, the content can be deleted
            Map<String, Object> eventParams = _getEventParametersForDeletion(content);
            
            _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETING, _currentUserProvider.getUser(), eventParams));
            
            RemovableAmetysObject removableContent = (RemovableAmetysObject) content;
            ModifiableAmetysObject parent = removableContent.getParent();
            
            // Remove the content.
            if (!onlyDeletion && content instanceof TrashableAmetysObject trashableAO)
            {
                _trashElementDAO.trash(trashableAO);
            }
            else
            {
                removableContent.remove();
            }
            
            parent.saveChanges();
            
            _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETED, _currentUserProvider.getUser(), eventParams));
            
            return _CONTENT_DELETION_STATUS_DELETED;
        }
        catch (AmetysRepositoryException e)
        {
            getLogger().error("Unable to delete content '" + content.getId() + "'", e);
            
            return _CONTENT_DELETION_STATUS_UNDELETED;
        }
    }
    
    /**
     * Transform the content to a {@link Map} with id, title and name.
     * @param content The content to transform
     * @return A {@link Map} with essentials informations of the content
     */
    protected Map<String, Object> _transformContentToParams(Content content)
    {
        String contentName = content.getName();
        String contentTitle = Objects.toString(_contentHelper.getTitle(content), contentName);
        
        Map<String, Object> contentParams = new HashMap<>();
        contentParams.put("id", content.getId());
        contentParams.put("title", contentTitle);
        contentParams.put("name", contentName);
        
        return contentParams;
    }
    
    /**
     * Get the deletion status of the content :
     *  - unauthorized: The content can't be deleted because of rights
     *  - locked: The content is locked
     *  - referenced: The content has ingoing references
     * @param content The content
     * @param deleteRightId The right ID
     * @return <code>null</code> if content deletion can be done or the status if there is something wrong for deletion
     */
    protected String _getContentDeletionStatus(Content content, String deleteRightId)
    {
        if (!(content instanceof RemovableAmetysObject))
        {
            throw new IllegalArgumentException("The content [" + content.getId() + "] is not a RemovableAmetysObject, it can't be deleted.");
        }
        
        if (deleteRightId != null && !canDelete(content, deleteRightId))
        {
            // User has no sufficient right
            return _CONTENT_DELETION_STATUS_UNAUTHORIZED;
        }
        
        if (content instanceof LockableAmetysObject)
        {
            // If the content is locked, try to unlock it.
            LockableAmetysObject lockableContent = (LockableAmetysObject) content;
            if (lockableContent.isLocked())
            {
                boolean canUnlockAll = _rightManager.hasRight(_currentUserProvider.getUser(), "CMS_Rights_UnlockAll", "/cms") == RightResult.RIGHT_ALLOW;
                if (LockHelper.isLockOwner(lockableContent, _currentUserProvider.getUser()) || canUnlockAll)
                {
                    lockableContent.unlock();
                }
                else
                {
                    return _CONTENT_DELETION_STATUS_LOCKED;
                }
            }
        }

        if (_isContentReferenced(content))
        {
            // Indicate that the content is referenced.
            return _CONTENT_DELETION_STATUS_REFERENCED;
        }
        
        return null;
    }
    
    /**
     * Test if content is still referenced before removing it
     * @param content The content to remove
     * @return true if content is still referenced
     */
    protected boolean _isContentReferenced (Content content)
    {
        return content.hasReferencingContents();
    }
    
    /**
     * Get parameters for content deleted {@link Event}
     * @param content the removed content
     * @return the event's parameters
     */
    protected Map<String, Object> _getEventParametersForDeletion (Content content)
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_NAME, content.getName());
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        return eventParams;
    }
    
    /**
     * Get the contents properties
     * @param contentIds The ids of contents
     * @param workspaceName The workspace name. Can be null to get contents in current workspace.
     * @return The contents' properties
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getContentsProperties (List<String> contentIds, String workspaceName)
    {
        // Assume that no read access is checked (required for bus message target)
        Map<String, Object> result = new HashMap<>();
        
        List<Map<String, Object>> contents = new ArrayList<>();
        List<String> contentsNotFound = new ArrayList<>();
        
        Request request = ContextHelper.getRequest(_context);
        String currentWorkspace = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        try
        {
            if (StringUtils.isNotEmpty(workspaceName))
            {
                RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            }
            
            for (String contentId : contentIds)
            {
                try
                {
                    Content content = _resolver.resolveById(contentId);
                    contents.add(getContentProperties(content));
                }
                catch (UnknownAmetysObjectException e)
                {
                    contentsNotFound.add(contentId);
                }
            }
            
            result.put("contents", contents);
            result.put("contentsNotFound", contentsNotFound);
        }
        finally
        {
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWorkspace);
        }
        
        return result;
    }
    
    /**
     * Get the content properties
     * @param contentId The id of content
     * @param workspaceName The workspace name. Can be null to get content in current workspace.
     * @return The content's properties
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getContentProperties (String contentId, String workspaceName)
    {
        // Assume that no read access is checked (required for bus message target)
        
        Request request = ContextHelper.getRequest(_context);
        String currentWorkspace = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        try
        {
            if (StringUtils.isNotEmpty(workspaceName))
            {
                RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            }
            
            Content content = _resolver.resolveById(contentId);
            return getContentProperties(content);
        }
        finally
        {
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWorkspace);
        }
    }
    
    /**
     * Get the content properties
     * @param content The content
     * @return The content properties
     */
    public Map<String, Object> getContentProperties (Content content)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("id", content.getId());
        infos.put("name", content.getName());
        infos.put("title", _contentHelper.getTitle(content));
        
        if (ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID.equals(content.getType(Content.ATTRIBUTE_TITLE).getId()))
        {
            infos.put("titleVariants", _contentHelper.getTitleVariants(content));
        }
        infos.put("path", content.getPath());
        infos.put("types", content.getTypes());
        infos.put("mixins", content.getMixinTypes());
        String lang = content.getLanguage();
        if (lang != null)
        {
            infos.put("lang", lang);
        }
        infos.put("creator", _userHelper.user2json(content.getCreator()));
        infos.put("lastContributor", _userHelper.user2json(content.getLastContributor()));
        infos.put("creationDate", DateUtils.zonedDateTimeToString(content.getCreationDate()));
        infos.put("lastModified", DateUtils.zonedDateTimeToString(content.getLastModified()));
        infos.put("isSimple", _contentHelper.isSimple(content));
        infos.put("isReferenceTable", _contentHelper.isReferenceTable(content));
        infos.put("parent", _hierarchicalSimpleContentsHelper.getParent(content));
        
        if (content instanceof WorkflowAwareContent)
        {
            WorkflowAwareContent waContent = (WorkflowAwareContent) content;
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
            
            infos.put("workflowName", workflow.getWorkflowName(waContent.getWorkflowId()));
            
            List<Integer> workflowSteps = new ArrayList<>();
            
            List<Step> currentSteps = workflow.getCurrentSteps(waContent.getWorkflowId());
            for (Step step : currentSteps)
            {
                workflowSteps.add(step.getStepId());
            }
            infos.put("workflowSteps", workflowSteps);
            
            int[] availableActions = _contentWorkflowHelper.getAvailableActions(waContent);
            infos.put("availableActions", availableActions);
        }
        
        if (content instanceof ModifiableContent)
        {
            infos.put("isModifiable", true);
        }
        
        if (content instanceof LockAwareAmetysObject)
        {
            LockAwareAmetysObject lockableContent = (LockAwareAmetysObject) content;
            if (lockableContent.isLocked())
            {
                infos.put("locked", true);
                infos.put("lockOwner", _userHelper.user2json(lockableContent.getLockOwner()));
                infos.put("canUnlock", _lockManager.canUnlock(lockableContent));
            }
        }
        
        infos.put("rights", getUserRights(content));
        
        Map<String, Object> additionalData = new HashMap<>();
        
        String[] contenttypes = content.getTypes();
        for (String cTypeId : contenttypes)
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType != null)
            {
                additionalData.putAll(cType.getAdditionalData(content));
            }
        }
        
        if (!additionalData.isEmpty())
        {
            infos.put("additionalData", additionalData);
        }

        infos.put("isTaggable", content instanceof TaggableAmetysObject);
        
        if (content instanceof ModifiableDataAwareVersionableAmetysObject)
        {
            ModifiableModelLessDataHolder unversionedDataHolder = ((ModifiableDataAwareVersionableAmetysObject) content).getUnversionedDataHolder();
            if (unversionedDataHolder.hasValue(ArchiveConstants.META_ARCHIVE_SCHEDULED_DATE))
            {
                ZonedDateTime scheduledDate = unversionedDataHolder.getValue(ArchiveConstants.META_ARCHIVE_SCHEDULED_DATE);
                infos.put("scheduledArchivingDate", DateUtils.zonedDateTimeToString(scheduledDate));
            }
        }
        
        if (content instanceof ReportableObject)
        {
            infos.put("reportsCount", ((ReportableObject) content).getReportsCount());
        }

        return infos;
    }
    
    /**
     * Get the content's properties for description
     * @param contentId The id of content
     * @param workspaceName The workspace name. Can be null to get content in current workspace.
     * @return The content's properties for description
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = ContentRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> getContentDescription (String contentId, String workspaceName)
    {
        Request request = ContextHelper.getRequest(_context);
        String currentWorkspace = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        try
        {
            if (StringUtils.isNotEmpty(workspaceName))
            {
                RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            }
            
            Content content = _resolver.resolveById(contentId);
            return getContentDescription(content);
        }
        finally
        {
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWorkspace);
        }
    }
    
    /**
     *Get the content's properties for description
     * @param content The content
     * @return The content's properties for description
     */
    public Map<String, Object> getContentDescription (Content content)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("id", content.getId());
        infos.put("name", content.getName());
        infos.put("title", _contentHelper.getTitle(content));
        infos.put("types", content.getTypes());
        infos.put("mixins", content.getMixinTypes());
        infos.put("lang", content.getLanguage());
        infos.put("creator", _userHelper.user2json(content.getCreator()));
        infos.put("lastContributor", _userHelper.user2json(content.getLastContributor()));
        infos.put("lastModified", DateUtils.zonedDateTimeToString(content.getLastModified()));
        infos.put("iconGlyph", _cTypesHelper.getIconGlyph(content));
        infos.put("iconDecorator", _cTypesHelper.getIconDecorator(content));
        infos.put("smallIcon", _cTypesHelper.getSmallIcon(content));
        infos.put("mediumIcon", _cTypesHelper.getMediumIcon(content));
        infos.put("largeIcon", _cTypesHelper.getLargeIcon(content));
        
        return infos;
    }
    
    /**
     * Get the views of a content plus a view of all the content's data
     * @param contentId the content's id
     * @param includeInternal Set to true to include internal views.
     * @return the views
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = ContentRightAssignmentContext.ID, paramIndex = 0)
    public List<Map<String, Object>> getContentViewsAndAllData(String contentId, boolean includeInternal)
    {
        List<Map<String, Object>> views = getContentViews(contentId, includeInternal);
        views.add(_getAllDataView());
        return views;
    }

    private Map<String, Object> _getAllDataView()
    {
        Map<String, Object> viewInfos = new HashMap<>();
        viewInfos.put("name", ContentTypesHelper.ALL_DATA);
        viewInfos.put("label", new I18nizableText("plugin.cms", "PLUGINS_CMS_VIEW_ALL_DATA"));
        viewInfos.put("description", new I18nizableText("plugin.cms", "PLUGINS_CMS_VIEW_ALL_DATA_DESC"));
        return viewInfos;
    }
    
    /**
     * Get the views of a content
     * @param contentId the content's id
     * @param includeInternal Set to true to include internal views.
     * @return the views
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = ContentRightAssignmentContext.ID, paramIndex = 0)
    public List<Map<String, Object>> getContentViews(String contentId, boolean includeInternal)
    {
        List<Map<String, Object>> views = new ArrayList<>();
        
        Content content = _resolver.resolveById(contentId);
        String contentTypeId = _cTypesHelper.getContentTypeIdForRendering(content);
        
        ContentType cType = _contentTypeEP.getExtension(contentTypeId);
        
        Set<String> viewNames = cType.getViewNames(includeInternal);
        for (String viewName : viewNames)
        {
            View view = cType.getView(viewName);
            
            Map<String, Object> viewInfos = new HashMap<>();
            viewInfos.put("name", viewName);
            viewInfos.put("label", view.getLabel());
            viewInfos.put("description", view.getDescription());
            views.add(viewInfos);
        }
        
        return views;
    }
    
    /**
     * Get the user rights on content
     * @param content The content
     * @return The user's rights
     */
    protected Set<String> getUserRights (Content content)
    {
        UserIdentity user = _currentUserProvider.getUser();
        Set<String> userRights = _rightManager.getUserRights(user, content);
        
        // 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, content))
        {
            userRights = new HashSet<>(userRights);
            userRights.add(RightManager.READER_PROFILE_ID);
            return userRights;
        }
        return userRights;
    }
    
    /**
     * Get the tags of contents
     * @param contentIds The content's ids
     * @return the tags
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Set<String> getTags (List<String> contentIds)
    {
        Set<String> tags = new HashSet<>();
        
        for (String contentId : contentIds)
        {
            Content content = _resolver.resolveById(contentId);
            if (_rightManager.currentUserHasReadAccess(content))
            {
                tags.addAll(content.getTags());
            }
        }
        
        return tags;
    }
    
    /**
     * Tag a list of contents with the given tags
     * @param contentIds The ids of contents to tag
     * @param tagNames The tags
     * @param contextualParameters The contextual parameters
     * @return the result
     */
    @Callable(rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> tag (List<String> contentIds, List<String> tagNames, Map<String, Object> contextualParameters)
    {
        return tag(contentIds, tagNames, TagMode.REPLACE, contextualParameters, false);
    }
    
    /**
     * Tag a list of contents
     * @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> contentIds, List<String> tagNames, String mode, Map<String, Object> contextualParameters)
    {
        return tag(contentIds, tagNames, TagMode.valueOf(mode), contextualParameters, false);
    }
    
    /**
     * Tag a list of contents
     * @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
     * @param ignoreRights <code>true</code> to ignore the rights on tag
     * @return the result
     */
    public Map<String, Object> tag (List<String> contentIds, List<String> tagNames, TagMode mode, Map<String, Object> contextualParameters, boolean ignoreRights)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("notaggable-contents", new ArrayList<>());
        result.put("invalid-tags", new ArrayList<>());
        result.put("allright-contents", new ArrayList<>());
        result.put("locked-contents", new ArrayList<>());
        result.put("noright-contents", new ArrayList<>());
        
        for (String contentId : contentIds)
        {
            Content content = _resolver.resolveById(contentId);
            
            Map<String, Object> content2json = new HashMap<>();
            content2json.put("id", content.getId());
            content2json.put("title", _contentHelper.getTitle(content));

            if (!ignoreRights && !_hasTagRights(content, tagNames, mode, contextualParameters))
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> noRightContents = (List<Map<String, Object>>) result.get("noright-contents");
                noRightContents.add(content2json);
            }
            else if (content instanceof TaggableAmetysObject)
            {
                TaggableAmetysObject mContent = (TaggableAmetysObject) content;
                
                boolean wasLocked = false;
                
                if (content instanceof LockableAmetysObject)
                {
                    LockableAmetysObject lockableContent = (LockableAmetysObject) content;
                    UserIdentity user = _currentUserProvider.getUser();
                    if (lockableContent.isLocked() && !LockHelper.isLockOwner(lockableContent, user))
                    {
                        @SuppressWarnings("unchecked")
                        List<Map<String, Object>> lockedContents = (List<Map<String, Object>>) result.get("locked-contents");
                        content2json.put("lockOwner", lockableContent.getLockOwner());
                        lockedContents.add(content2json);
                        
                        // Stop process
                        continue;
                    }
                    
                    if (lockableContent.isLocked())
                    {
                        wasLocked = true;
                        lockableContent.unlock();
                    }
                }
                
                Set<String> oldTags = mContent.getTags();
                _removeAllTagsInReplaceMode(mContent, mode, oldTags);
                
                // Then set new tags
                for (String tagName : tagNames)
                {
                    if (_isTagValid(tagName, contextualParameters))
                    {
                        if (TagMode.REMOVE.equals(mode))
                        {
                            mContent.untag(tagName);
                        }
                        else if (TagMode.REPLACE.equals(mode) || !oldTags.contains(tagName))
                        {
                            mContent.tag(tagName);
                        }
                        
                    }
                    else
                    {
                        @SuppressWarnings("unchecked")
                        List<String> invalidTags = (List<String>) result.get("invalid-tags");
                        invalidTags.add(tagName);
                    }
                }
                
                ((ModifiableAmetysObject) content).saveChanges();
                
                if (wasLocked)
                {
                    // Relock content if it was locked before tagging
                    ((LockableAmetysObject) content).lock();
                }
                
                content2json.put("tags", content.getTags());
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allRightPages = (List<Map<String, Object>>) result.get("allright-contents");
                allRightPages.add(content2json);
                
                if (!oldTags.equals(content.getTags()))
                {
                    // Notify observers that the content has been tagged
                    Map<String, Object> eventParams = new HashMap<>();
                    eventParams.put(org.ametys.cms.ObservationConstants.ARGS_CONTENT, content);
                    eventParams.put(org.ametys.cms.ObservationConstants.ARGS_CONTENT_ID, content.getId());
                    eventParams.put("content.tags", content.getTags());
                    eventParams.put("content.old.tags", oldTags);
                    _observationManager.notify(new Event(org.ametys.cms.ObservationConstants.EVENT_CONTENT_TAGGED, _currentUserProvider.getUser(), eventParams));
                }
            }
            else
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> notaggableContents = (List<Map<String, Object>>) result.get("notaggable-contents");
                notaggableContents.add(content2json);
            }
        }
        
        return result;
    }

    private boolean _hasTagRights(Content content, 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 = content.getTags().stream()
                    .map(t -> _tagProvider.getTag(t, contextualParameters))
                    .filter(Objects::nonNull)
                    .toList();
            
            tags = new ArrayList<>(CollectionUtils.disjunction(tags, existingTags));
        }
        
        boolean hasPublicTagRight = _rightManager.currentUserHasRight("CMS_Rights_Content_Tag", content) == RightResult.RIGHT_ALLOW;
        boolean hasPrivateTagRight = _rightManager.currentUserHasRight("CMS_Rights_Content_Private_Tag", content) == RightResult.RIGHT_ALLOW;
        
        // Test if the current user has the right to tag public tag on content only if there are at least one public tag
        boolean hasRight = TagHelper.filterTags(tags, TagVisibility.PUBLIC, "CONTENT").isEmpty() || hasPublicTagRight || hasPrivateTagRight;
        
        // Test if the current user has the right to tag private tag on content only if there are at least one private tag
        return hasRight && (TagHelper.filterTags(tags, TagVisibility.PRIVATE, "CONTENT").isEmpty() || hasPrivateTagRight);
    }

    /**
     * Remove all tags from the given content if tagMode is equals to REPLACE.
     * @param mContent The content
     * @param tagMode The tag
     * @param oldTags Tags to remove
     */
    protected void _removeAllTagsInReplaceMode(TaggableAmetysObject mContent, TagMode tagMode, Set<String> oldTags)
    {
        if (TagMode.REPLACE.equals(tagMode))
        {
            // First delete old tags
            for (String tagName : oldTags)
            {
                mContent.untag(tagName);
            }
        }
    }
    
    /**
     * Is the tag a content tag
     * @param tagName The tag name
     * @param contextualParameters The contextual parameters
     * @return true if the tag is a valid content tag
     */
    protected boolean _isTagValid (String tagName, Map<String, Object> contextualParameters)
    {
        CMSTag tag = _tagProvider.getTag(tagName, contextualParameters);
        return tag != null && tag.getTarget().getName().equals("CONTENT");
    }
    
    /**
     * Copy a content.
     * @param originalContent the original content.
     * @param parent the object in which to create a content.
     * @param name the content name.
     * @param initWorkflowActionId The initial workflow action id
     * @param context The context of the data to copy
     * @return the copied content.
     * @throws AmetysRepositoryException If an error occured
     */
    public ModifiableContent copy(DefaultContent originalContent, ModifiableTraversableAmetysObject parent, String name, int initWorkflowActionId, DataContext context) throws AmetysRepositoryException
    {
        return copy(originalContent, parent, name, null, initWorkflowActionId, context);
    }
    
    /**
     * Copy a content.
     * @param originalContent the original content.
     * @param parent the object in which to create a content.
     * @param name the content name.
     * @param lang the content language. If null, the content language will be the same of the original content
     * @param initWorkflowActionId The initial workflow action id
     * @param context The context of the data to copy
     * @return the copied content.
     * @throws AmetysRepositoryException If an error occured
     */
    public ModifiableContent copy(DefaultContent originalContent, ModifiableTraversableAmetysObject parent, String name, String lang, int initWorkflowActionId, DataContext context) throws AmetysRepositoryException
    {
        return copy(originalContent, parent, name, lang, initWorkflowActionId, true, true, false, false, context);
    }
    
    /**
     * Copy a content.
     * @param originalContent the original content.
     * @param parent the object in which to create a content.
     * @param name the content name.
     * @param lang the content language. If null, the content language will be the same of the original content
     * @param initWorkflowActionId The initial workflow action id
     * @param notifyObservers Set to false to do not fire observer events
     * @param checkpoint true to check the content in if it is versionable
     * @param waitAsyncObservers true to wait for asynchronous observers to complete
     * @param copyACL true to copy ACL of source content
     * @param context The context of the data to copy
     * @return the copied content.
     * @throws AmetysRepositoryException If an error occured
     */
    public ModifiableContent copy(DefaultContent originalContent, ModifiableTraversableAmetysObject parent, String name, String lang, int initWorkflowActionId, boolean notifyObservers, boolean checkpoint, boolean waitAsyncObservers, boolean copyACL, DataContext context) throws AmetysRepositoryException
    {
        try
        {
            String originalName = name == null ? originalContent.getName() : name;
            String contentName = originalName;
            int index = 2;
            while (parent.hasChild(contentName))
            {
                contentName = originalName + "-" + (index++);
            }
            
            String originalContentType = originalContent.getNode().getPrimaryNodeType().getName();
            
            ModifiableContent content = parent.createChild(contentName, originalContentType);
            
            String targetLanguage = lang == null ? originalContent.getLanguage() : lang;
            if (targetLanguage != null)
            {
                content.setLanguage(targetLanguage);
            }
            
            content.setTypes(originalContent.getTypes());
            
            _modifiableContentHelper.copyTitle(originalContent, content);
            
            if (originalContent instanceof WorkflowAwareContent)
            {
                WorkflowAwareContent waOriginalContent = (WorkflowAwareContent) originalContent;
                AmetysObjectWorkflow originalContentWorkflow = _workflowProvider.getAmetysObjectWorkflow(waOriginalContent);
                String workflowName = originalContentWorkflow.getWorkflowName(waOriginalContent.getWorkflowId());
                
                // Initialize new content workflow
                WorkflowAwareContent waContent = (WorkflowAwareContent) content;
                AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
                
                HashMap<String, Object> inputs = new HashMap<>();
                // Provide the content key
                inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<>());
                inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, waContent);
                
                long workflowId = workflow.initialize(workflowName, initWorkflowActionId, inputs);
                
                // Remove workflow id if exists before updating it
                WorkflowAwareContentHelper.removeWorkflowId(waContent);
                waContent.setWorkflowId(workflowId);
                
                // Set the current step ID property
                Step currentStep = (Step) workflow.getCurrentSteps(workflowId).iterator().next();
                waContent.setCurrentStepId(currentStep.getStepId());
                
                Node workflowEntryNode = null;
                Node node = waContent.getNode();
                Session session = node.getSession();
                
                
                try
                {
                    AbstractJackrabbitWorkflowStore workflowStore = (AbstractJackrabbitWorkflowStore) workflow.getConfiguration().getWorkflowStore();
                    
                    if (workflowStore instanceof AmetysObjectWorkflowStore)
                    {
                        AmetysObjectWorkflowStore ametysObjectWorkflowStore = (AmetysObjectWorkflowStore) workflowStore;
                        ametysObjectWorkflowStore.bindAmetysObject(waContent);
                    }
                    
                    workflowEntryNode = workflowStore.getEntryNode(session, workflowId);
                    workflowEntryNode.setProperty("ametys-internal:initialActionId", initWorkflowActionId);
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException("Unable to link the workflow to the content", e);
                }
            }
            
            // Copy attributes
            originalContent.copyTo(content, context);
            
            // Copy attachments
            _copyAttachments(originalContent, content);
            
            if (copyACL)
            {
                _copyACL(originalContent, content);
            }
            
            UserIdentity currentUser = _currentUserProvider.getUser();
            if (currentUser != null)
            {
                content.setCreator(currentUser);
                content.setLastContributor(currentUser);
                content.setLastModified(ZonedDateTime.now());
                content.setCreationDate(ZonedDateTime.now());
            }
            
            parent.saveChanges();
            
            // Create a new version
            if (checkpoint && content instanceof VersionableAmetysObject versionableContent)
            {
                versionableContent.checkpoint();
            }

            if (notifyObservers)
            {
                notifyContentCopied(content, waitAsyncObservers);
            }
            
            return content;
        }
        catch (WorkflowException e)
        {
            throw new AmetysRepositoryException(e);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    /**
     * Copy the attachments of a content
     * @param srcContent The source content
     * @param targetContent The target content
     */
    protected void _copyAttachments(Content srcContent, Content targetContent)
    {
        ResourceCollection srcRootAttachments = srcContent.getRootAttachments();
        if (srcRootAttachments == null)
        {
            // There are no attachments to copy
            return;
        }
        
        ResourceCollection targetRootAttachments = targetContent.getRootAttachments();
        if (targetRootAttachments == null)
        {
            // The target is an (unmodifiable) old version and the attachments root is missing
            return;
        }
        
        AmetysObjectIterable<AmetysObject> children = srcRootAttachments.getChildren();
        for (AmetysObject child : children)
        {
            if (child instanceof CopiableAmetysObject)
            {
                try
                {
                    ((CopiableAmetysObject) child).copyTo((ModifiableTraversableAmetysObject) targetRootAttachments, child.getName());
                }
                catch (AmetysRepositoryException e)
                {
                    getLogger().error("Failed to copy attachments at path " + child.getPath() + " from content " + srcContent + " to content " + targetContent, e);
                }
            }
        }
    }
        
    /**
     * Copy the ACL of a content
     * @param srcContent The source content
     * @param targetContent The target content
     */
    protected void _copyACL(Content srcContent, Content targetContent)
    {
        if (srcContent instanceof DefaultContent && targetContent instanceof DefaultContent)
        {
            Node srcNode = ((DefaultContent) srcContent).getNode();
            Node targetNode = ((DefaultContent) targetContent).getNode();
            
            try
            {
                String aclNodeName = "ametys-internal:acl";
                if (srcNode.hasNode(aclNodeName))
                {
                    Node aclNode = srcNode.getNode(aclNodeName);
                    aclNode.getSession().getWorkspace().copy(aclNode.getPath(), targetNode.getPath() + "/" + aclNodeName);
                }
            }
            catch (RepositoryException e)
            {
                getLogger().error("Failed to copy ACL from content " + srcContent + " to content " + targetContent, e);
            }
        }
    }
    
    /**
     * Notify observers that the content has been created
     * @param content The content added
     * @param waitAsyncObservers true to wait for asynchonous observers to finish
     * @throws WorkflowException If an error occurred
     */
    public void notifyContentCopied(Content content, boolean waitAsyncObservers) throws WorkflowException
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());

        List<Future> futures = _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_ADDED, _currentUserProvider.getUser(), eventParams));
        futures.addAll(_observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_WORKFLOW_CHANGED, _currentUserProvider.getUser(), eventParams)));
        
        if (waitAsyncObservers)
        {
            // Wait for asynchonous observers to finish
            for (Future future : futures)
            {
                try
                {
                    future.get();
                }
                catch (ExecutionException | InterruptedException e)
                {
                    getLogger().error(String.format("Error while waiting for async observer to complete"));
                }
            }
        }
    }
    
    /**
     * Returns the content's attachments root node
     * @param id the content'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<>();
        
        Content content = _resolver.resolveById(id);
        
        result.put("title", _contentHelper.getTitle(content));
        result.put("contentId", content.getId());
        
        if (_rightManager.currentUserHasRight("CMS_Rights_Content_Attachments", content) != RightResult.RIGHT_ALLOW)
        {
            return result;
        }
        
        TraversableAmetysObject attachments = content.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("Content with id '" + id + "' does not support attachments.");
    }
    
    /**
     * Determines if the current user has right to delete the content
     * @param content The content
     * @return true if current user is authorized to delete the content
     */
    public boolean canDelete(Content content)
    {
        return canDelete(content, getRightToDelete());
    }
    
    /**
     * Determines if the current user has right to delete the content
     * @param content The content
     * @param deleteRightId The right's id to check for deletion
     * @return true if current user is authorized to delete the content
     */
    public boolean canDelete(Content content, String deleteRightId)
    {
        UserIdentity user = _currentUserProvider.getUser();
        if (_rightManager.hasRight(user, deleteRightId, content) == RightResult.RIGHT_ALLOW)
        {
            return true;
        }
        
        return false;
    }
    
    /**
     * Add or remove a reaction on a content
     * @param contentId The content id
     * @param reactionName the reaction name (ex: LIKE)
     * @param remove true to remove the reaction, false to add reaction
     * @return the result with the current actors of this reaction
     */
    @Callable (rights = Callable.CHECKED_BY_IMPLEMENTATION)
    public Map<String, Object> react(String contentId, String reactionName, boolean remove)
    {
        Map<String, Object> result = new HashMap<>();
        
        Content content = _resolver.resolveById(contentId);
        
        if (_rightManager.currentUserHasReadAccess(content))
        {
            ReactionType reactionType = ReactionType.valueOf(reactionName);
            UserIdentity actor = _currentUserProvider.getUser();
            
            boolean updated = remove ? unreact(content, actor, reactionType) : react(content, actor, reactionType);
            result.put("updated", updated);
            result.put("contentId", contentId);
            result.put("actors", _userHelper.userIdentities2json(((ReactionableObject) content).getReactionUsers(reactionType)));
        }
        else
        {
            result.put("unauthorized", true);
            result.put("updated", false);
        }

        return result;
    }
    
    /**
     * Get the list of users who react to content
     * @param contentId The content id
     * @param reactionName the reaction name (ex: LIKE)
     * @return the list of users
     */
    @Callable (rights = Callable.READ_ACCESS, rightContext = ContentRightAssignmentContext.ID, paramIndex = 0)
    public List<Map<String, Object>> getReactionUsers(String contentId, String reactionName)
    {
        Content content = _resolver.resolveById(contentId);
        if (content instanceof ReactionableObject reactionableContent)
        {
            ReactionType reactionType = ReactionType.valueOf(reactionName);
            List<UserIdentity> reactionUsers = reactionableContent.getReactionUsers(reactionType);
            
            return reactionUsers.stream().map(_userHelper::user2json).toList();
        }
        
        return List.of();
    }
    
    /**
     * Add a reaction on a {@link Content}.
     * @param content the content
     * @param userIdentity the issuer of reaction
     * @param reactionType the reaction type
     * @return true if a change was made
     */
    public boolean react(Content content, UserIdentity userIdentity, ReactionType reactionType)
    {
        return _addOrRemoveReaction(content, userIdentity, reactionType, false);
    }
    
    /**
     * Remove reaction if exists on a {@link Content}.
     * @param content the content
     * @param userIdentity the issuer of reaction
     * @param reactionType the reaction type
     * @return <code>true</code> if a change was made
     */
    public boolean unreact(Content content, UserIdentity userIdentity, ReactionType reactionType)
    {
        return _addOrRemoveReaction(content, userIdentity, reactionType, true);
    }
    
    /**
     * Add or remove reaction if exists on the given content.
     * @param content the content
     * @param userIdentity the issuer of reaction
     * @param reactionType the reaction type
     * @param remove <code>true</code> if it's to remove the reaction
     * @return <code>true</code> if a change was made
     */
    protected boolean _addOrRemoveReaction(Content content, UserIdentity userIdentity, ReactionType reactionType, boolean remove)
    {
        if (content instanceof ReactionableObject)
        {
            boolean hasChanges = false;
            
            List<UserIdentity> reactionIssuers = ((ReactionableObject) content).getReactionUsers(reactionType);
            if (!remove && !reactionIssuers.contains(userIdentity))
            {
                ((ReactionableObject) content).addReaction(userIdentity, reactionType);
                hasChanges = true;
            }
            else if (remove && reactionIssuers.contains(userIdentity))
            {
                ((ReactionableObject) content).removeReaction(userIdentity, reactionType);
                hasChanges = true;
            }
            
            if (hasChanges)
            {
                ((DefaultContent) content).saveChanges();
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, content);
                eventParams.put(ObservationConstants.ARGS_REACTION_TYPE, reactionType);
                eventParams.put(ObservationConstants.ARGS_REACTION_ISSUER, userIdentity);
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_REACTION_CHANGED, userIdentity, eventParams));
                
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Add a report on a content
     * @param content The content
     * @throws IllegalArgumentException if the content is not a {@link ReportableObject}
     * @throws AccessDeniedException if the current user has not read access on the given content
     */
    public void report(Content content) throws IllegalArgumentException, AccessDeniedException
    {
        if (_rightManager.currentUserHasReadAccess(content))
        {
            if (content instanceof ReportableObject)
            {
                ((ReportableObject) content).addReport();
                ((DefaultContent) content).saveChanges();
            }
            else
            {
                throw new IllegalArgumentException("Unable to report the content '" + content.getId() + "'. Current user is not authorized to see this content.");
            }
        }
        else
        {
            throw new AccessDeniedException("Unable to report the content '" + content.getId() + "'. Current user is not authorized to see this content.");
        }
    }

    /**
     * Trash contents if possible or delete it and force the deletion of invert relations, then log the result.
     * @param contents The contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @param logger The logger
     * @return the number of deleted contents
     */
    public int forceTrashContentsWithLog(List<Content> contents, String deleteRightId, Logger logger)
    {
        return _logResult(forceTrashContentsObj(contents, deleteRightId), logger);
    }
    
    /**
     * Delete contents and force the deletion of invert relations, then log the result.
     * @param contents The contents to delete
     * @param deleteRightId The deletion right's id to check. Can be null to ignore rights
     * @param logger The logger
     * @return the number of deleted contents
     */
    public int forceDeleteContentsWithLog(List<Content> contents, String deleteRightId, Logger logger)
    {
        return _logResult(forceDeleteContentsObj(contents, deleteRightId), logger);
    }

    @SuppressWarnings("unchecked")
    private int _logResult(Map<String, Object> result, Logger logger)
    {
        List<Map<String, Object>> referencedContents = (List<Map<String, Object>>) result.get(_CONTENT_DELETION_STATUS_REFERENCED + "-contents");
        if (referencedContents.size() > 0)
        {
            logger.info("The following contents cannot be deleted because they are referenced: {}", referencedContents.stream().map(m -> m.get("id")).collect(Collectors.toList()));
        }
        
        List<Map<String, Object>> lockedContents = (List<Map<String, Object>>) result.get(_CONTENT_DELETION_STATUS_LOCKED + "-contents");
        if (lockedContents.size() > 0)
        {
            logger.info("The following contents cannot be deleted because they are locked: {}", lockedContents.stream().map(m -> m.get("id")).collect(Collectors.toList()));
        }
        
        List<Map<String, Object>> unauthorizedContents = (List<Map<String, Object>>) result.get(_CONTENT_DELETION_STATUS_UNAUTHORIZED + "-contents");
        if (unauthorizedContents.size() > 0)
        {
            logger.info("The following contents cannot be deleted because they are no authorization: {}", unauthorizedContents.stream().map(m -> m.get("id")).collect(Collectors.toList()));
        }
        
        List<Map<String, Object>> undeletedContents = (List<Map<String, Object>>) result.get(_CONTENT_DELETION_STATUS_UNDELETED + "-contents");
        if (undeletedContents.size() > 0)
        {
            logger.info("{} contents were not deleted. See previous logs for more information.", undeletedContents.size());
        }

        List<Map<String, Object>> deletedContents = (List<Map<String, Object>>) result.get(_CONTENT_DELETION_STATUS_DELETED + "-contents");
        return deletedContents.size();
    }
}