/*
 *  Copyright 2013 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.content;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.Logger;
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.ProcessingException;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.xml.sax.ContentHandlerProxy;
import org.apache.excalibur.xml.sax.SAXParser;
import org.apache.xml.serializer.OutputPropertiesFactory;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import org.ametys.cms.content.CopyReport.CopyMode;
import org.ametys.cms.content.CopyReport.CopyState;
import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.content.references.OutgoingReferencesExtractor;
import org.ametys.cms.contenttype.AbstractMetadataSetElement;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataDefinitionReference;
import org.ametys.cms.contenttype.MetadataManager;
import org.ametys.cms.contenttype.MetadataSet;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.contenttype.RichTextUpdater;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.workflow.AbstractContentWorkflowComponent;
import org.ametys.cms.workflow.CreateContentFunction;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.cms.workflow.copy.CreateContentByCopyFunction;
import org.ametys.cms.workflow.copy.EditContentByCopyFunction;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.File;
import org.ametys.plugins.repository.metadata.Folder;
import org.ametys.plugins.repository.metadata.ModifiableBinaryMetadata;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.metadata.ModifiableFile;
import org.ametys.plugins.repository.metadata.ModifiableFolder;
import org.ametys.plugins.repository.metadata.ModifiableResource;
import org.ametys.plugins.repository.metadata.ModifiableRichText;
import org.ametys.plugins.repository.metadata.Resource;
import org.ametys.plugins.repository.metadata.RichText;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.component.CheckRightsCondition;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * <p>
 * This component is used to copy a content (either totally or partially).
 * </p><p>
 * In this whole file a Map named <em>copyMap</em> is regularly used. This map
 * provide the name of the metadata to copy as well as some optional parameters.
 * It has the following form (JSON) :
 * </p>
 * <pre>
 * {
 *   "$param1": value,
 *   "metadataA": null,
 *   "metadataB": {
 *     "subMetadataB1": null,
 *     "subMetadataB2": {
 *       "$param1": value,
 *       "$param2": value,
 *       "subSubMetadataB21": {...}
 *     },
 *     ...
 *   }
 * }
 * </pre>
 * <p>
 * Each metadata that should be copied must be present as a key in the map.
 * Composite metadata can contains child metadata but as seen on the example the
 * map must be well structured, it is not a flat map. Parameters in the map must
 * always start with the reserved character '$', in order to be differentiated
 * from metadata name.
 * </p><p>
 * There are two main entry points for this helper component:
 * </p>
 * <ul>
 * <li>copyContent and editContent are methods that run a dedicated workflow
 * function (createByCopy or editByCopy) that will later call the
 * copyMetadataMap function (see below).</li>
 * <li>copyMetadataMap is the method that is responsible for the recursive copy
 * of the metadata (by following the copyMap structure). During this process,
 * underlying content creation can be requested in which case the copyContent
 * method will be called.</li>
 * </ul>
 */
public class CopyContentMetadataComponent extends AbstractLogEnabled implements Serviceable, Component
{
    /** Avalon ROLE. */
    public static final String ROLE = CopyContentMetadataComponent.class.getName();
    
    /** Workflow provider. */
    protected WorkflowProvider _workflowProvider;
    
    /** Ametys object resolver available to subclasses. */
    protected AmetysObjectResolver _resolver;
    
    /** The Excalibur SAX parser */
    protected SAXParser _saxParser;
    
    /** Content type extension point. */
    protected ContentTypeExtensionPoint _contentTypeExtensionPoint;
    
    /** Helper for content types */
    protected ContentTypesHelper _contentTypesHelper;
    
    /** The outgoing references extractor */
    protected OutgoingReferencesExtractor _outgoingReferencesExtractor;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _saxParser = (SAXParser) manager.lookup(SAXParser.ROLE);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _outgoingReferencesExtractor = (OutgoingReferencesExtractor) manager.lookup(OutgoingReferencesExtractor.ROLE);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * The title of the new content will the one from the base content.
     * 
     * @param baseContentId The identifier of the base content
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     *            
     * @param initActionId The workflow action id to use to create the new content 
     * @param editActionId The workflow action id to use to edit the newly created content
     *  
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(String baseContentId, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, int initActionId, int editActionId)
    {
        return copyContent(baseContentId, null, copyMap, metadataSetName, metadataSetType, initActionId, editActionId);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContentId The identifier of the base content
     * @param title Desired title for the new content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param initActionId The init workflow action id for main content only
     * @param editActionId The workflow action for editing main content only
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(String baseContentId, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, int initActionId, int editActionId)
    {
        return copyContent(baseContentId, title, copyMap, metadataSetName, metadataSetType, null, initActionId, editActionId);
    }
    
    /**
     * Create a new content by copy of another. The type of created content can be different of the source content. 
     * The source and target contents must have a common content type ancestor.
     * @param baseContentId The id of content to copy
     * @param title The title of the new created content
     * @param copyMap The map of metadata to copy. Can be null to copy the whole metadata set.
     * @param metadataSetName The name of metadata set to copy
     * @param metadataSetType The type of metadata set to copy
     * @param targetContentType The type of content to create. If null the type(s) of created content will be those of base content.
     * @param initActionId The init workflow action id for main content only
     * @param editActionId The workflow action for editing main content only
     * @return The copy report
     */
    public CopyReport copyContent(String baseContentId, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, String targetContentType, int initActionId, int editActionId)
    {
        try
        {
            Content baseContent = _resolver.resolveById(baseContentId);
            return copyContent(baseContent, title, copyMap, metadataSetName, metadataSetType, targetContentType, initActionId, editActionId);
        }
        catch (AmetysRepositoryException e)
        {
            getLogger().error("An error has been encountered during the content copy, or the copy is not allowed (base content identifier : " + baseContentId + ").", e);
            
            boolean isSimple = true;
            
            CopyReport report = new CopyReport(baseContentId, isSimple, metadataSetName, metadataSetType, CopyMode.CREATION);
            report.notifyContentCopyError();
            
            return report;
        }
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, Map<String, Object> copyMap, String metadataSetName, String metadataSetType)
    {
        return copyContent(baseContent, copyMap, metadataSetName, metadataSetType, getDefaultInitActionId(), getDefaultActionIdForEditingContentReferences());
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param initActionId The init workflow action id for main content only
     * @param editRefActionId The workflow action for editing references
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, int initActionId, int editRefActionId)
    {
        return copyContent(baseContent, null, copyMap, metadataSetName, metadataSetType, initActionId, editRefActionId);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param title Desired title for the new content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param initActionId The init workflow action id for main content only
     * @param editRefActionId The workflow action for editing references
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, int initActionId, int editRefActionId)
    {
        return copyContent(baseContent, title, copyMap, metadataSetName, metadataSetName, null, initActionId, editRefActionId);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param title Desired title for the new content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param targetContentType The type of content to create. If null the type(s) of created content will be those of base content.
     * @param initActionId The init workflow action id for main content only
     * @param editRefActionId The workflow action for editing references
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, String targetContentType, int initActionId, int editRefActionId)
    {
        return copyContent(baseContent, title, copyMap, metadataSetName, metadataSetType, targetContentType, null, null, initActionId, editRefActionId);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param title Desired title for the new content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param parentContentId The target content ID.
     * @param parentMetadataPath the parent metadata path, if a sub-content is being created.
     * @param initActionId The init workflow action id for main content only
     * @param editActionId The workflow action for editing main content only
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, String parentContentId, String parentMetadataPath, int initActionId, int editActionId)
    {
        return copyContent(baseContent, title, copyMap, metadataSetName, metadataSetType, null, parentContentId, parentMetadataPath, initActionId, editActionId);
    }
    
    /**
     * Copy a content by creating a new content and copying the value of the
     * metadata of a source content into the new one.
     * 
     * @param baseContent The base content.
     * @param title Desired title for the new content.
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param targetContentType The type of content to create. If null the type(s) of created content will be those of base content.
     * @param parentContentId The target content ID.
     * @param parentMetadataPath the parent metadata path, if a sub-content is being created.
     * @param initActionId The init workflow action id for main content only
     * @param editRefActionId The workflow action for editing references
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport copyContent(Content baseContent, String title, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, String targetContentType, String parentContentId, String parentMetadataPath, int initActionId, int editRefActionId)
    {
        String baseContentId = baseContent.getId();
        String auxMetadataSetName = StringUtils.defaultIfEmpty(metadataSetName, "main");
        String auxMetadataSetType = StringUtils.defaultIfEmpty(metadataSetType, "edition");
        CopyReport report = new CopyReport(baseContentId, baseContent.getTitle(), true, auxMetadataSetName, auxMetadataSetType, CopyMode.CREATION);
        
        try
        {
            boolean simple = false;
            for (String cTypeId : baseContent.getTypes())
            {
                simple = simple || _contentTypeExtensionPoint.getExtension(cTypeId).isSimple();
            }
            
            report.setSimple(simple);
            
            Map<String, Object> internalCopyMap = copyMap;
            if (internalCopyMap == null || BooleanUtils.isTrue((Boolean) internalCopyMap.get("$forceBuild")))
            {
                internalCopyMap = _buildCopyMap(baseContent, auxMetadataSetName, auxMetadataSetType, targetContentType, internalCopyMap);
            }
            
            // Title metadata must never be copied in case of a content copy, the title is set during the content creation.
            internalCopyMap.remove("title");
            
            Map<String, Object> inputs = _getInputsForCopy(baseContent, title, internalCopyMap, targetContentType, parentContentId, parentMetadataPath, report);
            String workflowName = _getWorklowName(baseContent, inputs);
            
            // Create the content and copy metadata from the base content.
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow();
            workflow.initialize(workflowName, initActionId, inputs);
            
            // Manual call to the edit content function to edit the content
            // references stored by the copy report through the duplication process
            _runContentReferencesEdition(baseContent, workflow, editRefActionId, true, report);
            
            report.notifyContentCopySuccess();
        }
        catch (Exception e)
        {
            getLogger().error("An error has been encountered during the content copy, or the copy is not allowed (base content identifier : " + baseContentId + ").", e);
            
            report.notifyContentCopyError();
        }
        
        return report;
    }
    
    /**
     * Retrieve the inputs for the copy workflow function.
     * @param baseContent The content to copy
     * @param title The title to set
     * @param copyMap The map with properties to copy
     * @param targetContentType The type of content to create. If null the type(s) of created content will be those of base content.
     * @param parentContentId The parent content ID, when copying a sub-content.
     * @param parentMetadataPath The parent metadata path, when copying a sub-content.
     * @param copyReport The report of the copy
     * @return The map of inputs.
     */
    @SuppressWarnings("unchecked")
    protected Map<String, Object> _getInputsForCopy(Content baseContent, String title, Map<String, Object> copyMap, String targetContentType, String parentContentId, String parentMetadataPath, CopyReport copyReport)
    {
        Map<String, Object> inputs = new HashMap<>();
        
        // Add copy map inputs
        Map<String, Object> copyMapInputs = (Map<String, Object>) copyMap.get("$inputs");
        if (copyMapInputs != null)
        {
            inputs.putAll(copyMapInputs);
        }
        
        inputs.put(CreateContentByCopyFunction.BASE_CONTENT_KEY, baseContent);
        inputs.put(CreateContentByCopyFunction.COPY_MAP_KEY, copyMap);
        inputs.put(CreateContentByCopyFunction.COPY_REPORT_KEY, copyReport);
        
        if (StringUtils.isNotBlank(parentContentId) && StringUtils.isNotBlank(parentMetadataPath))
        {
            // Provide the parent content ID and metadata path to the CreateContentFunction (removing the leading slash).
            inputs.put(CreateContentFunction.PARENT_CONTENT_ID_KEY, parentContentId);
            inputs.put(CreateContentFunction.PARENT_CONTENT_METADATA_PATH_KEY, StringUtils.stripStart(parentMetadataPath, "/"));
        }
        
        if (StringUtils.isNoneBlank(title))
        {
            inputs.put(CreateContentFunction.CONTENT_TITLE_KEY, title);
        }

        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new HashMap<String, Object>());
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
        
        if (targetContentType != null)
        {
            inputs.put(CreateContentFunction.CONTENT_TYPES_KEY, new String[] {targetContentType});
        }
        
        return inputs;
    }
    
    /**
     * Retrieve the workflow name of a content.
     * @param content The content to consider
     * @param inputs The inputs that will be provided to the workflow function
     * @return The name of the workflow.
     * @throws IllegalArgumentException if the content is not workflow aware.
     */
    protected String _getWorklowName(Content content, Map<String, Object> inputs) throws IllegalArgumentException
    {
        String workflowName = null;
        
        if (content instanceof WorkflowAwareContent)
        {
            WorkflowAwareContent waContent = (WorkflowAwareContent) content;
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
            workflowName = workflow.getWorkflowName(waContent.getWorkflowId());
        }
        
        if (workflowName == null)
        {
            String errorMsg = "Unable to retrieve the workflow name for the content with identifier '" + content.getId() + "'.";
            
            getLogger().error(errorMsg);
            throw new IllegalArgumentException(errorMsg);
        }
        
        return workflowName;
    }
    
    /**
     * Build the copy map from given content and metadata set.
     * @param baseContent the content to copy
     * @param metadataSetName Name of the metadata set.
     * @param metadataSetType Type of the metadata set.
     * @return A map with properties to copy.
     */
    public Map<String, Object> buildCopyMap (Content baseContent, String metadataSetName, String metadataSetType)
    {
        return _buildCopyMap(baseContent, metadataSetName, metadataSetType, new HashMap<String, Object>());
    }
    
    /**
     * Build the copy map from a metadata set.
     * @param baseContent the content to copy
     * @param metadataSetName Name of the metadata set.
     * @param metadataSetType Type of the metadata set.
     * @param baseCopyMap The copy map being constructed
     * @return The copy map.
     */
    protected Map<String, Object> _buildCopyMap(Content baseContent, String metadataSetName, String metadataSetType, Map<String, Object> baseCopyMap)
    {
        return _buildCopyMap(baseContent, metadataSetName, metadataSetType, null, baseCopyMap);
    }
    
    /**
     * Build the copy map from a metadata set.
     * @param baseContent The content to be copied
     * @param metadataSetName Name of the metadata set to be copied.
     * @param metadataSetType Type of the metadata set to be copied (view or edition).
     * @param targetContentType The content type of content to create. Can be null.
     * @param baseCopyMap The copy map being constructed
     * @return The copy map.
     */
    protected Map<String, Object> _buildCopyMap(Content baseContent, String metadataSetName, String metadataSetType, String targetContentType, Map<String, Object> baseCopyMap)
    {
        MetadataSet metadataSet = null;
        if (targetContentType != null)
        {
            Set<String> types = new HashSet<>();
            Collections.addAll(types, baseContent.getTypes());
            types.add(targetContentType);
            String commonAncestor = _contentTypesHelper.getCommonAncestor(types);
            metadataSet = "view".equals(metadataSetType) ? _contentTypesHelper.getMetadataSetForView(metadataSetName, new String[] {commonAncestor}, new String[0]) : _contentTypesHelper.getMetadataSetForEdition(metadataSetName, new String[] {commonAncestor}, new String[0]);
        }
        else
        {
            metadataSet = "view".equals(metadataSetType) ? _contentTypesHelper.getMetadataSetForView(metadataSetName, baseContent.getTypes(), baseContent.getMixinTypes()) : _contentTypesHelper.getMetadataSetForEdition(metadataSetName, baseContent.getTypes(), baseContent.getMixinTypes());
        }
        
        return _buildCopyMap(metadataSet, baseCopyMap);
        
    }
    
    /**
     * Recursive auxiliary function used to build the copy map.
     * @param metadataSetElement The current metadata set element 
     * @param copyMap The copy map being constructed or null
     * @return The copy map corresponding to this metadata set element.
     */
    protected Map<String, Object> _buildCopyMap(AbstractMetadataSetElement metadataSetElement, Map<String, Object> copyMap)
    {
        Map<String, Object> map = copyMap;
        
        for (AbstractMetadataSetElement metadataElement : metadataSetElement.getElements())
        {
            if (metadataElement instanceof MetadataDefinitionReference)
            {
                MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) metadataElement;
                String name = metadataDefRef.getMetadataName();
                
                map = map != null ? map : new HashMap<>();
                map.put(name, _buildCopyMap(metadataDefRef, null));
            }
            else
            {
                map = map != null ? map : new HashMap<>();
                map.putAll(_buildCopyMap(metadataElement, map));
            }
        }
        
        return map;
    }
    
    /**
     * Edit a content by copying the value of the
     * metadata of a source content into a target content.
     * 
     * @param baseContentId The identifier of the base content
     * @param targetContentId The identifier of the target content
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport editContent(String baseContentId, String targetContentId, Map<String, Object> copyMap, String metadataSetName, String metadataSetType)
    {
        return editContent(baseContentId, targetContentId, copyMap, metadataSetName, metadataSetType, getDefaultActionIdForContentEdition(), getDefaultActionIdForEditingContentReferences());
    }
    
    /**
     * Edit a content by copying the value of the
     * metadata of a source content into a target content.
     * 
     * @param baseContentId The identifier of the base content
     * @param targetContentId The identifier of the target content
     * @param copyMap The map of properties as described in
     *            {@link CopyContentMetadataComponent}. Can be null in which
     *            case the map will be constructed from a metadataSet.
     * @param metadataSetName The name of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default name for possible inner copies (if not provided as a
     *            copyMap parameter).
     * @param metadataSetType The type of the metadata set to be used to
     *            construct to copyMap if not provided. This will also be the
     *            default type for possible inner copies.
     * @param actionId the edit workflow action id
     * @param editRefActionId the workflow action id for editing references
     * @return The copy report containing valuable information about the copy
     *         and the possible encountered errors.
     */
    public CopyReport editContent(String baseContentId, String targetContentId, Map<String, Object> copyMap, String metadataSetName, String metadataSetType, int actionId, int editRefActionId)
    {
        Content baseContent = null;
        CopyReport report = null;
        
        String auxMetadataSetName = StringUtils.defaultIfEmpty(metadataSetName, "main");
        String auxMetadataSetType = StringUtils.defaultIfEmpty(metadataSetType, "edition");
        
        try
        {
            baseContent = _resolver.resolveById(baseContentId);
            report = new CopyReport(baseContentId, baseContent.getTitle(), _isSimple(baseContent), auxMetadataSetName, auxMetadataSetType, CopyMode.EDITION);
            
            Map<String, Object> internalCopyMap = copyMap;
            if (internalCopyMap == null || BooleanUtils.isTrue((Boolean) internalCopyMap.get("$forceBuild")))
            {
                internalCopyMap = _buildCopyMap(baseContent, auxMetadataSetName, auxMetadataSetType, internalCopyMap);
            }
            
            WorkflowAwareContent targetContent = _retrieveTargetContent(targetContentId);
            Map<String, Object> inputs = _getInputsForEdition(baseContent, targetContent, internalCopyMap, report);
            
            // Edit the content by copying metadata from the base content.
            // This is done in a workflow function.
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(targetContent);
            workflow.doAction(targetContent.getWorkflowId(), actionId, inputs);
            
            // Manual call to the edit content function to edit the content
            // references stored by the copy report through the duplication process
            _runContentReferencesEdition(baseContent, workflow, editRefActionId, false, report);
            
            report.notifyContentCopySuccess();
        }
        catch (Exception e)
        {
            getLogger().error(
                    "An error has been encountered during the content edition, or the edition is not allowed (base content identifier : " + baseContentId
                            + ", target content identifier : " + targetContentId + ").", e);
            
            if (report != null)
            {
                report.notifyContentCopyError();
            }
            else
            {
                report = new CopyReport(baseContentId, _isSimple(baseContent), auxMetadataSetName, auxMetadataSetType, CopyMode.EDITION);
                report.notifyContentCopyError();
            }
        }
        
        return report;
    }
    
    private boolean _isSimple (Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            ContentType cType = _contentTypeExtensionPoint.getExtension(cTypeId);
            if (!cType.isSimple())
            {
                return false;
            }
        }
        return true;
    }
    /**
     * Retrieve the target content from its id.
     * Also ensure that it is a workflow aware content.
     * @param targetContentId The target content identifer.
     * @return the retrieved workflow aware content
     * @throws IllegalArgumentException if the content is not workflow aware.
     */
    protected WorkflowAwareContent _retrieveTargetContent(String targetContentId) throws IllegalArgumentException
    {
        Content content = _resolver.resolveById(targetContentId);
        
        if (!(content instanceof WorkflowAwareContent))
        {
            throw new IllegalArgumentException("Content with identifier '" + targetContentId + "' is not workflow aware.");
        }
        
        return (WorkflowAwareContent) content;
    }
    
    /**
     * Retrieve the inputs for the edition workflow function.
     * @param baseContent The content to copy
     * @param targetContent The target of the copy
     * @param copyMap The properties to copy
     * @param copyReport The report of the copy
     * @return The map of inputs.
     */
    protected Map<String, Object> _getInputsForEdition(Content baseContent, WorkflowAwareContent targetContent, Map<String, Object> copyMap, CopyReport copyReport)
    {
        Map<String, Object> inputs = new HashMap<>();
        
        // Add copy map inputs
        @SuppressWarnings("unchecked")
        Map<String, Object> copyMapInputs = (Map<String, Object>) copyMap.get("$inputs");
        if (copyMapInputs != null)
        {
            inputs.putAll(copyMapInputs);
        }
        
        inputs.put(EditContentByCopyFunction.BASE_CONTENT_KEY, baseContent);
        inputs.put(EditContentByCopyFunction.COPY_MAP_KEY, copyMap);
        inputs.put(EditContentByCopyFunction.COPY_REPORT_KEY, copyReport);
        
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, targetContent);
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new HashMap<String, Object>());
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
        
        return inputs;
    }

    
    /* *******************************
     *                               *
     *      Copy of the metadata     *
     *                               *
     * ******************************/
    
    /**
     * Copy the specified set of metadata from a base content to a target content by iterating over the copyMap.
     * 
     * @param baseContent The original content
     * @param targetContent The copy content
     * @param copyMap The properties to copy
     * @param copyReport The copy report being populated during the copy.
     */
    @SuppressWarnings("unchecked")
    public void copyMetadataMap(Content baseContent, ModifiableContent targetContent, Map<String, Object> copyMap, CopyReport copyReport)
    {
        copyReport.notifyContentCreation(targetContent.getId(), targetContent.getTitle(), _isSimple(baseContent));
        
        Map<String, Object> innerCopyMapInputs =  copyMap != null ? (Map<String, Object>) copyMap.get("$inputs") : null;
        _copyMetadataMap(baseContent, baseContent.getMetadataHolder(), targetContent.getMetadataHolder(), "", null, copyMap, innerCopyMapInputs, copyReport);
        
        copyReport.setTargetContentTitle(targetContent.getTitle());
        
        _updateRichTextMetadata(baseContent, targetContent, copyReport);
        _extractOutgoingReferences(targetContent);
    }
    
    /**
     * Copy the specified set of metadata from a base composite metadata to a target composite metadata by iterating over the copyMap.
     * @param baseContent The original content
     * @param baseMetaHolder The metadata holder of the baseContent
     * @param targetMetaHolder The metadata holder of the target content
     * @param metaPrefix The metadata prefix.
     * @param parentMetadataDefinition The parent metadata definition. Can be null
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties to copy for sub objects
     * @param copyReport The copy report being populated during the copy.
     */
    @SuppressWarnings("unchecked")
    protected void _copyMetadataMap(Content baseContent, CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metaPrefix, MetadataDefinition parentMetadataDefinition, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        if (copyMap == null)
        {
            return;
        }
        
        for (String metadataName : copyMap.keySet())
        {
            // Ignore key starting with the $ (denotes a parameter)
            if (StringUtils.startsWith(metadataName, "$"))
            {
                continue;
            }
            
            MetadataDefinition metadataDefinition = null;
            try
            {
                metadataDefinition = _getMetadataDefinition(baseContent, parentMetadataDefinition, metadataName);
                if (metadataDefinition != null)
                {
                    copyMetadata(baseContent, baseMetaHolder, targetMetaHolder, metadataDefinition, metaPrefix, (Map<String, Object>) copyMap.get(metadataName), innerCopyMapInputs, copyReport);
                }
            }
            catch (Exception e)
            {
                _reportMetadataException(baseMetaHolder, targetMetaHolder, metadataName, metadataDefinition, copyReport, e);
            }
        }
    }
    
    /**
     * Retrieves a {@link MetadataDefinition} through its
     * parent definition or the {@link ContentType} of the
     * current content if at the root level of the metadataset.
     * @param content The content
     * @param metadataDefinition The parent metadata definition. Can be null.
     * @param metadataName The metadata name
     * @return The retrieved metadata defintion or null if not found
     */
    protected MetadataDefinition _getMetadataDefinition(Content content, MetadataDefinition metadataDefinition, String metadataName)
    {
        if (metadataDefinition != null)
        {
            return metadataDefinition.getMetadataDefinition(metadataName);
        }
        else
        {
            return _contentTypesHelper.getMetadataDefinition(metadataName, content.getTypes(), content.getMixinTypes());
        }
    }
    
    /**
     * Add a metadata exception to the report.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to copy
     * @param metadataDefinition The associated definition
     * @param copyReport The report of the copy
     * @param e The raised exception.
     */
    protected void _reportMetadataException(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, MetadataDefinition metadataDefinition, CopyReport copyReport, Exception e)
    {
        String type = metadataDefinition != null ? metadataDefinition.getType().toString() : null;
        
        String errorMsg = "Copy of the metadata '" + metadataName + "' of type '" + (type != null ? type : "unknown type") + "' has failed.";
        getLogger().error(errorMsg, e);
        
        copyReport.notifyMetadataCopyError(metadataDefinition != null ? metadataDefinition.getLabel() : new I18nizableText(metadataName));
    }
    
    /**
     * Copy the specified metadata from a base composite metadata to a target composite metadata.
     * @param baseContent The original content
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataDefinition The associated definition
     * @param metaPrefix The metadata prefix.
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties to copy for sub objects
     * @param copyReport The report of the copy
     */
    public void copyMetadata(Content baseContent, CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDefinition, String metaPrefix, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        String metadataName = metadataDefinition.getName();
        String metadataPath = metaPrefix + "/" + metadataName;
        
        switch (metadataDefinition.getType())
        {
            case GEOCODE:
                copyGeocodeMetadata(baseMetaHolder, targetMetaHolder, metadataName);
                break;
            case USER:
                copyUserMetadata(baseMetaHolder, targetMetaHolder, metadataName);
                break;
            case REFERENCE:
                copyReferenceMetadata(baseMetaHolder, targetMetaHolder, metadataDefinition, metadataName);
                break;
            case BINARY:
                copyBinaryMetadata(baseMetaHolder, targetMetaHolder, metadataName);
                break;
            case FILE:
                copyFileMetadata(baseMetaHolder, targetMetaHolder, metadataDefinition, metadataName);
                break;
            case RICH_TEXT:
                copyRichTextMetadata(baseMetaHolder, targetMetaHolder, metadataDefinition, metadataName, copyReport);
                break;
            case CONTENT:
                copyContentReferenceMetadata(baseMetaHolder, targetMetaHolder, metadataDefinition, metadataPath, copyMap, innerCopyMapInputs, copyReport);
                break;
            case SUB_CONTENT:
                copySubContentMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataPath, copyMap, innerCopyMapInputs, copyReport);
                break;
            case COMPOSITE:
                copyCompositeMetadata(baseContent, baseMetaHolder, targetMetaHolder, metadataPath, metadataDefinition, copyMap, innerCopyMapInputs, copyReport);
                break;
            default:
                copyBasicMetadata(baseMetaHolder, targetMetaHolder, metadataDefinition, metadataName);
                break;
        }
    }
    
    /**
     * Copy a 'basic' metadata.
     * This is used to copy metadata of type :
     * {@link MetadataType#STRING}, {@link MetadataType#DATE}, {@link MetadataType#DATETIME},
     * {@link MetadataType#DOUBLE}, {@link MetadataType#LONG}, {@link MetadataType#BOOLEAN},
     * {@link MetadataType#USER}
     * 
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataDef The metadata definition 
     * @param metadataName The metadata name 
     */
    public void copyBasicMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDef, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            switch (metadataDef.getType())
            {
                case DATE:
                case DATETIME:
                    _setDateMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataDef.isMultiple());
                    break;
                case DOUBLE:
                    _setDoubleMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataDef.isMultiple());
                    break;
                case LONG:
                    _setLongMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataDef.isMultiple());
                    break;
                case BOOLEAN:
                    _setBooleanMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataDef.isMultiple());
                    break;
                case STRING:
                case USER:
                default:
                    _setStringMetadata(baseMetaHolder, targetMetaHolder, metadataName, metadataDef.isMultiple());
                    break;
            }
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Set a metadata of type string from a base composite metadata to a target composite metadata.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param isMultiple Is the metadata multiple
     */
    protected void _setStringMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, Boolean isMultiple)
    {
        if (isMultiple)
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getStringArray(metadataName));
        }
        else
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getString(metadataName));
        }
    }
    
    /**
     * Set a metadata of type date/datetime from a base composite metadata to a target composite metadata.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param isMultiple Is the metadata multiple
     */
    protected void _setDateMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, Boolean isMultiple)
    {
        if (isMultiple)
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getDateArray(metadataName));
        }
        else
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getDate(metadataName));
        }
    }
    
    /**
     * Set a metadata of type double from a base composite metadata to a target composite metadata.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param isMultiple Is the metadata multiple
     */
    protected void _setDoubleMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, Boolean isMultiple)
    {
        if (isMultiple)
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getDoubleArray(metadataName));
        }
        else
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getDouble(metadataName));
        }
    }
    
    /**
     * Set a metadata of type long from a base composite metadata to a target composite metadata.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param isMultiple Is the metadata multiple
     */
    protected void _setLongMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, Boolean isMultiple)
    {
        if (isMultiple)
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getLongArray(metadataName));
        }
        else
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getLong(metadataName));
        }
    }
    
    /**
     * Set a metadata of type boolean from a base composite metadata to a target composite metadata.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param isMultiple Is the metadata multiple
     */
    protected void _setBooleanMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, Boolean isMultiple)
    {
        if (isMultiple)
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getBooleanArray(metadataName));
        }
        else
        {
            targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getBoolean(metadataName));
        }
    }

    /**
     * Duplicate a metadata of type {@link MetadataType#GEOCODE}.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     */
    public void copyGeocodeMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            CompositeMetadata baseGeoCode = baseMetaHolder.getCompositeMetadata(metadataName);
            ModifiableCompositeMetadata targetGeoCode = targetMetaHolder.getCompositeMetadata(metadataName, true);
            
            targetGeoCode.setMetadata("longitude", baseGeoCode.getDouble("longitude"));
            targetGeoCode.setMetadata("latitude", baseGeoCode.getDouble("latitude"));
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Duplicate a metadata of type {@link MetadataType#USER}.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     */
    public void copyUserMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            CompositeMetadata baseUser = baseMetaHolder.getCompositeMetadata(metadataName);
            ModifiableCompositeMetadata targetUser = targetMetaHolder.getCompositeMetadata(metadataName, true);
            
            targetUser.setMetadata("login", baseUser.getString("login"));
            targetUser.setMetadata("population", baseUser.getString("population"));
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Duplicate a metadata of type {@link MetadataType#REFERENCE}.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     * @param metadataDefinition The associated definition 
     */
    public void copyReferenceMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDefinition, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            CompositeMetadata baseReferenceMeta = baseMetaHolder.getCompositeMetadata(metadataName);
            ModifiableCompositeMetadata targetReferenceMeta = targetMetaHolder.getCompositeMetadata(metadataName, true);
            
            targetReferenceMeta.setMetadata("type", baseReferenceMeta.getString("type"));
            targetReferenceMeta.setMetadata("value", baseReferenceMeta.getString("value"));
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Duplicate a metadata of type {@link MetadataType#BINARY}.
     * @param baseMetaHolder The metadata holder to copy
     * @param targetMetaHolder The metadata holder where to copy
     * @param metadataName The metadata to consider
     */
    public void copyBinaryMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            BinaryMetadata baseBinaryMetadata = baseMetaHolder.getBinaryMetadata(metadataName);
            ModifiableBinaryMetadata targetBinaryMetadata = targetMetaHolder.getBinaryMetadata(metadataName, true);
            
            targetBinaryMetadata.setFilename(baseBinaryMetadata.getFilename());
            targetBinaryMetadata.setMimeType(baseBinaryMetadata.getMimeType());
            targetBinaryMetadata.setLastModified(baseBinaryMetadata.getLastModified());
            targetBinaryMetadata.setEncoding(baseBinaryMetadata.getEncoding());
            targetBinaryMetadata.setInputStream(baseBinaryMetadata.getInputStream());
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Copy a file metadata
     * @param baseMetaHolder The copied composite metadata
     * @param targetMetaHolder The target composite metadata
     * @param metadataDef The metadata definition
     * @param metadataName The metadata name
     */
    public void copyFileMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDef, String metadataName)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            // Could be a binary or a string.
            if (CompositeMetadata.MetadataType.BINARY.equals(baseMetaHolder.getType(metadataName)))
            {
                copyBinaryMetadata(baseMetaHolder, targetMetaHolder, metadataName);
            }
            else
            {
                targetMetaHolder.setMetadata(metadataName, baseMetaHolder.getString(metadataName));
                copyBasicMetadata(baseMetaHolder, targetMetaHolder, metadataDef, metadataName);
            }
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Copy a rich-text metadata
     * @param baseMetaHolder The copied composite metadata
     * @param targetMetaHolder The target composite metadata
     * @param metadataName The metadata name
     * @param metadataDef The metadata definition
     * @param copyReport The copy report
     */
    protected void copyRichTextMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDef, String metadataName, CopyReport copyReport)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            RichText baseRichText = baseMetaHolder.getRichText(metadataName);
            ModifiableRichText targetRichText = targetMetaHolder.getRichText(metadataName, true);
            
            // Notify the report that a rich text has been copied.
            copyReport.addRichText(targetRichText, metadataDef);
            
            targetRichText.setEncoding(baseRichText.getEncoding());
            targetRichText.setMimeType(baseRichText.getMimeType());
            targetRichText.setLastModified(baseRichText.getLastModified());
            targetRichText.setInputStream(baseRichText.getInputStream());
            
            // Copy additional data
            _copyFolder(baseRichText.getAdditionalDataFolder(), targetRichText.getAdditionalDataFolder());
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Folder copy during the copy of a rich text metadata.
     * @param baseFolder The folder to copy
     * @param targetFolder The folder where to copy
     */
    protected void _copyFolder(Folder baseFolder, ModifiableFolder targetFolder)
    {
        // Files and folders removal
        targetFolder.removeAll();
        
        // Copy folders
        Collection< ? extends Folder> baseSubFolders = baseFolder.getFolders();
        for (Folder baseSubFolder : baseSubFolders)
        {
            ModifiableFolder targetSubFolder = targetFolder.addFolder(baseSubFolder.getName());
            _copyFolder(baseSubFolder, targetSubFolder);
        }
        
        // Copy files
        Collection< ? extends File> baseFiles = baseFolder.getFiles();
        for (File baseFile : baseFiles)
        {
            _copyFile(baseFile, targetFolder);
        }
    }
    
    /**
     * File copy during the copy of a folder.
     * @param baseFile The file to copy
     * @param targetFolder The folder where to copy
     */
    protected void _copyFile(File baseFile, ModifiableFolder targetFolder)
    {
        ModifiableFile file = targetFolder.addFile(baseFile.getName());
        
        Resource baseResource = baseFile.getResource();
        ModifiableResource targetResource = file.getResource();
        
        targetResource.setLastModified(baseResource.getLastModified());
        targetResource.setMimeType(baseResource.getMimeType());
        targetResource.setEncoding(baseResource.getEncoding());
        targetResource.setInputStream(baseResource.getInputStream());
    }
    
    /**
     * Duplicate a metadata of type {@link MetadataType#CONTENT}.
     * If the copy map has a '$mode' parameter set to 'create', a new content will be created for each referenced content in the base metadata.
     * The referenced contents are created if needed but content references are not set here.
     * It should be done manually as done in {@link #_runContentReferencesEdition}
     * @param baseMetaHolder The metadata holder of the content to copy
     * @param targetMetaHolder The metadata holder of the target content
     * @param metadataDefinition The definition of the metadata
     * @param metadataPath The content metadata path.
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties of sub objects
     * @param copyReport The report of the copy
     */
    public void copyContentReferenceMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, MetadataDefinition metadataDefinition, String metadataPath, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        String metadataName = metadataDefinition.getName();
        
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            String[] baseContentIds = baseMetaHolder.getStringArray(metadataName);
            String[] targetContentIds = baseContentIds;
            
            if (copyMap != null && StringUtils.equals((String) copyMap.get("$mode"), "create"))
            {
                targetContentIds = _copyReferencedContents(baseContentIds, copyMap, innerCopyMapInputs, copyReport);
            }
            
            if (targetContentIds.length > 0)
            {
                Object values = metadataDefinition.isMultiple() ? Arrays.asList(targetContentIds) : targetContentIds[0];
                copyReport.addContentReferenceValues(metadataPath, values);
            }
            else if (targetMetaHolder.hasMetadata(metadataName))
            {
                Object values = metadataDefinition.isMultiple() ? Collections.EMPTY_LIST : null;
                copyReport.addContentReferenceValues(metadataPath, values);
            }
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            Object values = metadataDefinition.isMultiple() ? Collections.EMPTY_LIST : null;
            copyReport.addContentReferenceValues(metadataPath, values);
        }
    }
    
    /**
     * Duplicate base contents by creating new contents. If a specific metadata
     * set must be used, a '$metadataSetName' parameter must be specified. If
     * the copyMap for each inner duplication is already present in the current
     * copyMap, a '$loaded' parameter must be set to true, if not the copyMap
     * will be constructed from the requested metadata set.
     * @param baseContentIds The ids of contents to copy
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties of sub objects
     * @param copyReport The report of the copy
     * @return The array of identifiers of the new contents.
     */
    protected String[] _copyReferencedContents(String[] baseContentIds, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        String defaultMetadataSetName = StringUtils.defaultString((String) copyMap.get("$metadataSetName"), copyReport._metadataSetName);
        String defaultMetadataSetType = copyReport._metadataSetType;
        
        Map<String, Object> innerCopyMap = _handleInnerCopyMap(copyMap, innerCopyMapInputs);
        List<String> targetContentIds = new ArrayList<>();
        
        for (String baseContentId : baseContentIds)
        {
            CopyReport innerReport = copyContent(baseContentId, innerCopyMap, defaultMetadataSetName, defaultMetadataSetType, getDefaultInitActionId(), getDefaultActionIdForEditingContentReferences());
            
            if (innerReport._state == CopyState.SUCCESS)
            {
                targetContentIds.add(innerReport._targetContentId);
            }
            
            copyReport.addReport(innerReport);
        }
        
        return targetContentIds.toArray(new String[targetContentIds.size()]);
    }
    
    /**
     * Handle the creation of the inner copy map given the current context.
     * The inner copy map will act as the copy map for underlying content copies.
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties of sub objects
     * @return The inner copy map
     */
    protected Map<String, Object> _handleInnerCopyMap(Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs)
    {
        // If the copy map does not contain the data for the inner duplications,
        // a null copy map should be passed to force the copy process to build
        // it.
        // If inner inputs for the copy map are supplied, they will be added to
        // the copy map.
        // In case of a null copy map, the copy map will no be null anymore but
        // a special parameters $forceBuild is added.
        
        Map<String, Object> innerCopyMap = null;
        if (copyMap != null && BooleanUtils.isTrue((Boolean) copyMap.get("$loaded")))
        {
            innerCopyMap = copyMap;
        }
        
        if (innerCopyMapInputs != null)
        {
            if (innerCopyMap == null)
            {
                innerCopyMap = new HashMap<>();
                innerCopyMap.put("$forceBuild", true);
            }
            
            innerCopyMap.put("$inputs", innerCopyMapInputs);
        }
        
        return innerCopyMap;
    }

    /**
     * Duplicate a metadata of type {@link MetadataType#SUB_CONTENT}.
     * If the copy map has a '$mode' parameter set to 'create', a new content will be created for each referenced content in the base metadata.
     * @param baseMetaHolder The metadata holder of the content to copy
     * @param targetMetaHolder The metadata holder of the target content
     * @param metadataName The name of the metadata 
     * @param metadataPath The content metadata path.
     * @param copyMap The properties to copy
     * @param innerCopyMapInputs The properties of sub objects
     * @param copyReport The report of the copy
     */
    public void copySubContentMetadata(CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataName, String metadataPath, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            String defaultMetadataSetType = copyReport._metadataSetType;
            String defaultMetadataSetName = copyReport._metadataSetName;
            if (copyMap != null && copyMap.containsKey("$metadataSetName"))
            {
                defaultMetadataSetName = (String) copyMap.get("$metadataSetName");
            }
            
            Map<String, Object> innerCopyMap = _handleInnerCopyMap(copyMap, innerCopyMapInputs);
            TraversableAmetysObject objectCollection = baseMetaHolder.getObjectCollection(metadataName);
            AmetysObjectIterable<Content> subContents = objectCollection.getChildren();
            
            for (Content content : subContents)
            {
                CopyReport innerReport = copyContent(content, null, innerCopyMap, defaultMetadataSetName, defaultMetadataSetType, copyReport.getTargetContentId(), metadataPath, getDefaultInitActionId(), getDefaultActionIdForEditingContentReferences());
                
                copyReport.addReport(innerReport);
            }
        }
        else if (targetMetaHolder.hasMetadata(metadataName))
        {
            targetMetaHolder.removeMetadata(metadataName);
        }
    }
    
    /**
     * Copy composite metadata
     * @param baseContent The copied content
     * @param baseMetaHolder The original composite metadata
     * @param targetMetaHolder The target composite metadata
     * @param metadataPath The metadata path
     * @param metadataDefinition The metadata definition
     * @param copyMap The map for copy
     * @param innerCopyMapInputs The properties of sub objects
     * @param copyReport The copy report
     */
    public void copyCompositeMetadata(Content baseContent, CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataPath, MetadataDefinition metadataDefinition, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        if (metadataDefinition instanceof RepeaterDefinition)
        {
            _copyRepeater(baseContent, baseMetaHolder, targetMetaHolder, metadataPath, metadataDefinition, copyMap, innerCopyMapInputs, copyReport);
        }
        else
        {
            String metadataName = metadataDefinition.getName();
            
            if (baseMetaHolder.hasMetadata(metadataName))
            {
                CompositeMetadata baseCompositeMetadata = baseMetaHolder.getCompositeMetadata(metadataName);
                ModifiableCompositeMetadata targetCompositeMetadata = targetMetaHolder.getCompositeMetadata(metadataName, true);
                
                _copyMetadataMap(baseContent, baseCompositeMetadata, targetCompositeMetadata, metadataPath, metadataDefinition, copyMap, innerCopyMapInputs, copyReport);
            }
            else if (targetMetaHolder.hasMetadata(metadataName))
            {
                targetMetaHolder.removeMetadata(metadataName);
            }
        }
    }
    
    /**
     * Copy a repeater
     * @param baseContent The copied content
     * @param baseMetaHolder The original composite metadata
     * @param targetMetaHolder The target composite metadata
     * @param metadataPath The metadata path
     * @param metadataDefinition The metadata definition
     * @param copyMap The map for copy
     * @param innerCopyMapInputs The properties of sub objects
     * @param copyReport The copy report
     */
    protected void _copyRepeater(Content baseContent, CompositeMetadata baseMetaHolder, ModifiableCompositeMetadata targetMetaHolder, String metadataPath, MetadataDefinition metadataDefinition, Map<String, Object> copyMap, Map<String, Object> innerCopyMapInputs, CopyReport copyReport)
    {
        String metadataName = metadataDefinition.getName();
        
        if (baseMetaHolder.hasMetadata(metadataName))
        {
            CompositeMetadata baseRepeaterMetadata = baseMetaHolder.getCompositeMetadata(metadataName);
            ModifiableCompositeMetadata targetRepeaterMetadata = targetMetaHolder.getCompositeMetadata(metadataName, true);
            
            // Find the higher index for the entries of the base repeater
            String[] baseEntryNames = baseRepeaterMetadata.getMetadataNames();
            Arrays.sort(baseEntryNames, MetadataManager.REPEATER_ENTRY_COMPARATOR);
            
            int maxEntryName = 0;
            for (String entryName : baseEntryNames)
            {
                if (baseRepeaterMetadata.getType(entryName) == CompositeMetadata.MetadataType.COMPOSITE)
                {
                    maxEntryName = Math.max(maxEntryName, Integer.parseInt(entryName));
                }
            }
            
            // Rename every repeater entry to ensure their removal later because index of the entry will be higher that the repeater size.
            // Sorted by reverse name order to avoid same name conflicts while renaming entries.
            if (maxEntryName > 0)
            {
                String[] targetEntryNames = targetRepeaterMetadata.getMetadataNames();
                Arrays.sort(targetEntryNames, Collections.reverseOrder(MetadataManager.REPEATER_ENTRY_COMPARATOR));
                
                for (String entryName : targetEntryNames)
                {
                    if (targetRepeaterMetadata.getType(entryName) == CompositeMetadata.MetadataType.COMPOSITE)
                    {
                        // Warning! Rename expects the full jcr name ('ametys:name'), not the metadata name as usual.
                        // FIXME REPOSITORY-277
                        targetRepeaterMetadata.getCompositeMetadata(entryName).rename("ametys:" + String.valueOf(maxEntryName + Integer.parseInt(entryName)));
                    }
                }
            }
            
            // Duplication base repeater entries
            // Fix target entry names if necessary (1,3,4 -> 1,2,3)
            int targetEntryName = 1;
            for (String entryName : baseEntryNames)
            {
                if (baseRepeaterMetadata.getType(entryName) == CompositeMetadata.MetadataType.COMPOSITE)
                {
                    CompositeMetadata baseRepeaterEntry = baseRepeaterMetadata.getCompositeMetadata(entryName);
                    ModifiableCompositeMetadata targetRepeaterEntry = targetRepeaterMetadata.getCompositeMetadata(String.valueOf(targetEntryName), true);
                    
                    String metaPrefix = metadataPath + "/" + targetEntryName;
                    
                    _copyMetadataMap(baseContent, baseRepeaterEntry, targetRepeaterEntry, metaPrefix, metadataDefinition, copyMap, innerCopyMapInputs, copyReport);
                    
                    targetEntryName++;
                }
            }
            
            // Sync repeater by storing base entry names. Remaining entries of
            // the target repeater metadata will be deleted with this (the job
            // is done via _runContentReferencesEdition)
            copyReport.addRepeaterInfo(metadataPath, baseEntryNames.length);
        }
        else /* if (targetMetaHolder.hasMetadata(metadataName)) */
        {
            // Info are mandatory even if repeater does not currently exists. Otherwise, the EditContentFunction called via _runContentReferencesEdition will fails.
            copyReport.addRepeaterInfo(metadataPath, 0);
        }
    }
    
    /**
     * Analyse the content to find outgoing references and store them
     * @param content The content to analyze
     */
    protected void _extractOutgoingReferences(ModifiableContent content)
    {
        Map<String, OutgoingReferences> outgoingReferencesByPath = _outgoingReferencesExtractor.getOutgoingReferences(content);
        content.setOutgoingReferences(outgoingReferencesByPath);
    }
    

    /**
     * This method analyzes content rich texts and update their content to
     * ensure consistency. (link to image, attachments...)
     * @param baseContent The copied content
     * @param targetContent The target content
     * @param copyReport  The copy report
     */
    protected void _updateRichTextMetadata(final Content baseContent, final ModifiableContent targetContent, CopyReport copyReport)
    {
        try
        {
            Map<ModifiableRichText, MetadataDefinition> copiedRichTexts = copyReport.getCopiedRichTexts();
            
            for (Entry<ModifiableRichText, MetadataDefinition> entry : copiedRichTexts.entrySet())
            {
                ModifiableRichText richText = entry.getKey();
                MetadataDefinition metadataDef = entry.getValue();
                
                String referenceContentType = metadataDef.getReferenceContentType();
                ContentType contentType = _contentTypeExtensionPoint.getExtension(referenceContentType);
                
                RichTextUpdater richTextUpdater = contentType.getRichTextUpdater();
                if (richTextUpdater != null)
                {
                    Map<String, Object> params = new HashMap<>();
                    params.put("initialContent", baseContent);
                    params.put("createdContent", targetContent);
                    params.put("initialAO", baseContent);
                    params.put("createdAO", targetContent);
                    
                    // create the transformer instance
                    TransformerHandler th = ((SAXTransformerFactory) TransformerFactory.newInstance()).newTransformerHandler();
                    
                    // create the format of result
                    Properties format = new Properties();
                    format.put(OutputKeys.METHOD, "xml");
                    format.put(OutputKeys.INDENT, "yes");
                    format.put(OutputKeys.ENCODING, "UTF-8");
                    format.put(OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, "2");
                    th.getTransformer().setOutputProperties(format);
                    
                    // Update rich text contents
                    // Copy the needed original attachments.
                    try (InputStream is = richText.getInputStream(); OutputStream os = richText.getOutputStream())
                    {
                        StreamResult result = new StreamResult(os);
                        th.setResult(result);
                        
                        ContentHandler richTextHandler = richTextUpdater.getContentHandler(th, th, params);
                        
                        // Copy attachments handler.
                        ContentHandlerProxy copyAttachmentsHandler = new CopyAttachmentsHandler(richTextHandler, baseContent, targetContent, copyReport, _resolver, getLogger());
                        
                        // Rich text update.
                        _saxParser.parse(new InputSource(is), copyAttachmentsHandler);
                    }
                    finally
                    {
                        th.getTransformer().reset();
                    }
                }
            }
        }
        catch (Exception e)
        {
            getLogger().error(
                    "An error occurred while updating rich text metadata for content '" + targetContent.getId() + " after copy from initial content '" + baseContent.getId() + "'",
                    e);
        }
    }
    
    /**
     * Run the edition of the content references that has been stored during the copy of the metadata.
     * It is done via the EditContentFunction at the end of the process for technical purposes.
     * @param baseContent The base content to copy
     * @param targetContentWorkflow the target content local workflow
     * @param editActionId The edit action id to edit references
     * @param forceEdition true to force edition regardless user's rights
     * @param copyReport the copy report
     * @throws Exception If an error occured
     */
    protected void _runContentReferencesEdition(Content baseContent, AmetysObjectWorkflow targetContentWorkflow, int editActionId, boolean forceEdition, CopyReport copyReport) throws Exception
    {
        Map<String, Object> editionValues = new HashMap<>();
        
        Map<String, Object> contentReferenceValues = copyReport.getContentReferenceValuesMap();
        for (Entry<String, Object> entry : contentReferenceValues.entrySet())
        {
            String valueKey = StringUtils.replaceChars(StringUtils.stripStart(entry.getKey(), "/"), '/', '.');
            editionValues.put(EditContentFunction.FORM_ELEMENTS_PREFIX + valueKey, entry.getValue());
        }
        
        Map<String, Integer> repeatersInfo = copyReport.getRepeatersInfo();
        for (Entry<String, Integer> entry : repeatersInfo.entrySet())
        {
            String valueKey = StringUtils.replaceChars(StringUtils.stripStart(entry.getKey(), "/"), '/', '.');
            Integer entryCount = entry.getValue();
            
            editionValues.put(EditContentFunction.FORM_ELEMENTS_PREFIX + valueKey, null);
            editionValues.put('_' + EditContentFunction.FORM_ELEMENTS_PREFIX + valueKey + ".size", String.valueOf(entryCount));
            
            for (int i = 1; i <= entryCount; i++)
            {
                String pos = String.valueOf(i);
                editionValues.put('_' + EditContentFunction.FORM_ELEMENTS_PREFIX + valueKey + "." + i + ".previous-position", pos);
                editionValues.put('_' + EditContentFunction.FORM_ELEMENTS_PREFIX + valueKey + "." + i + ".position", pos);
            }
        }
        
        if (editionValues.size() > 0)
        {
            WorkflowAwareContent targetContent = targetContentWorkflow.getAmetysObject();
            Map<String, Object> inputs = _getInputsForContentReferencesEdition(targetContent, targetContent, editionValues, copyReport);
            if (forceEdition)
            {
                inputs.put(CheckRightsCondition.FORCE, forceEdition);
            }
            
            try
            {
                targetContentWorkflow.doAction(targetContent.getWorkflowId(), editActionId, inputs);
            }
            catch (Exception e)
            {
                throw new ProcessingException("Error during content references edition. (base content identifier : " + baseContent.getId() 
                        + ", target content identifier : " + targetContent.getId() + "). ", e);
            }
        }
    }
    
    /**
     * Retrieve the inputs for the content references edition workflow function.
     * @param baseContent The content to copy
     * @param targetContent The content where to copy
     * @param editionValues The values representing the content references to be edited (also contains special repeater size values)
     * @param copyReport The report of the copy
     * @return The map of inputs.
     */
    protected Map<String, Object> _getInputsForContentReferencesEdition(Content baseContent, WorkflowAwareContent targetContent, Map<String, Object> editionValues, CopyReport copyReport)
    {
        Map<String, Object> inputs = new HashMap<>();
        
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, targetContent);
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new HashMap<String, Object>());
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
        
        Map<String, Object> contextParameters = new HashMap<>();
        contextParameters.put(EditContentFunction.QUIT, Boolean.TRUE);
        contextParameters.put(EditContentFunction.FORM_RAW_VALUES, editionValues);
        inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, contextParameters);
        
        return inputs;
    }
    
    /**
     * Get the default workflow action id for initialization of main content
     * @return the default action id
     */
    public int getDefaultInitActionId ()
    {
        return 111;
    }
    
    
    /**
     * Get the default workflow action id for editing content metadata of main content
     * @return the default action id
     */
    public int getDefaultActionIdForEditingContentReferences ()
    {
        return 2;
    }
    
    /**
     * Get the default workflow action id for editing content by copy
     * @return the default action id
     */
    public int getDefaultActionIdForContentEdition()
    {
        return 222;
    }
    
    /**
     * Retrieve the action id to execute for the content copy.
     * @return The action id
     */
    public int getActionIdForCopy2()
    {
        return 111;
    }
    
    /**
     * A copy attachments content handler.
     * To be used to copy the attachments linked in a rich text metadata.
     */
    protected static class CopyAttachmentsHandler extends ContentHandlerProxy
    {
        /** base content */
        protected Content _baseContent;
        /** target content */
        protected ModifiableContent _targetContent;
        /** copy report */
        protected CopyReport _copyReport;
        /** Ametys object resolver */
        protected AmetysObjectResolver _resolver;
        /** logger */
        protected Logger _logger;
        

        /**
         * Ctor
         * @param contentHandler The content handler to delegate to.
         * @param baseContent The content to copy
         * @param targetContent The content where to copy
         * @param copyReport The report of the copy
         * @param resolver The ametys object resolver
         * @param logger A logger to log informations
         */
        protected CopyAttachmentsHandler(ContentHandler contentHandler, Content baseContent, ModifiableContent targetContent, CopyReport copyReport, AmetysObjectResolver resolver, Logger logger)
        {
            super(contentHandler);
            _baseContent = baseContent;
            _targetContent = targetContent;
            _copyReport = copyReport;
            _resolver = resolver;
            _logger = logger;
        }
        
        @Override
        public void startElement(String uri, String loc, String raw, Attributes attrs) throws SAXException
        {
            if ("link".equals(loc))
            {
                // Copy attachment
                _copyIfAttachment(attrs.getValue("xlink:href"));
            }
            
            super.startElement(uri, loc, raw, attrs);
        }
        
        /**
         * Copy the linked resource to the new content if it is an attachment. 
         * @param href link href attribute
         */
        protected void _copyIfAttachment(String href)
        {
            if (_baseContent.getId().equals(href) || _targetContent.getId().equals(href))
            {
                // nothing to do
                return;
            }
            else if (_resolver.hasAmetysObjectForId(href))
            {
                AmetysObject ametysObject = _resolver.resolveById(href);
                
                ResourceCollection baseRootAttachments = _baseContent.getRootAttachments();
                if (!(ametysObject instanceof org.ametys.plugins.explorer.resources.Resource) || baseRootAttachments == null)
                {
                    // nothing to do
                    return;
                }
                
                String baseAttachmentsPath = _baseContent.getRootAttachments().getPath();
                String resourcePath = ametysObject.getPath();
                
                if (resourcePath.startsWith(baseAttachmentsPath + '/'))
                {
                    // Is in attachments path
                    String relPath = StringUtils.removeStart(resourcePath, baseAttachmentsPath + '/');
                    _copyAttachment(ametysObject, relPath);
                }
            }
        }

        /**
         * Copy an attachment
         * @param baseResource The resource to copy
         * @param relPath The path where to copy
         */
        protected void _copyAttachment(AmetysObject baseResource, String relPath)
        {
            boolean success = false;
            Exception exception = null;
            
            try
            {
                if (_targetContent instanceof ModifiableTraversableAmetysObject)
                {
                    ModifiableTraversableAmetysObject mtaoTargetContent = (ModifiableTraversableAmetysObject) _targetContent;
                    ModifiableResourceCollection targetParentCollection = mtaoTargetContent.getChild(DefaultContent.ATTACHMENTS_NODE_NAME);
                    
                    String[] parts = StringUtils.split(relPath, '/');
                    if (parts.length > 0)
                    {
                        // Traverse the path and create necessary resources collections
                        for (int i = 0; i < parts.length - 1; i++)
                        {
                            String childName = parts[i];
                            if (!targetParentCollection.hasChild(childName))
                            {
                                targetParentCollection = targetParentCollection.createChild(childName, JCRResourcesCollectionFactory.RESOURCESCOLLECTION_NODETYPE);
                            }
                            else
                            {
                                targetParentCollection = targetParentCollection.getChild(childName);
                            }
                        }
                        
                        // Copy the attachment resource.
                        String resourceName = parts[parts.length - 1];
                        if (baseResource instanceof CopiableAmetysObject)
                        {
                            ((CopiableAmetysObject) baseResource).copyTo(targetParentCollection, resourceName);
                            success = true;
                            _copyReport.addAttachment(relPath);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                exception = e;
            }
            
            if (!success)
            {
                String warnMsg = "Unable to copy attachment from base path '" + baseResource.getPath() + "' to the content at path : '" + _targetContent.getPath() + "'.";
                
                if (_logger.isWarnEnabled())
                {
                    if (exception != null)
                    {
                        _logger.warn(warnMsg, exception);
                    }
                    else
                    {
                        _logger.warn(warnMsg);
                    }
                }
            }
        }
    }
}