/*
 *  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.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
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.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.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.excalibur.xml.sax.ContentHandlerProxy;
import org.apache.excalibur.xml.sax.SAXParser;
import org.apache.xml.serializer.OutputPropertiesFactory;
import org.slf4j.Logger;
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.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.RichTextUpdater;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.RichText;
import org.ametys.cms.data.type.ModelItemTypeConstants;
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.ContentWorkflowHelper;
import org.ametys.cms.workflow.CreateContentFunction;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.cms.workflow.InvalidInputWorkflowException;
import org.ametys.cms.workflow.copy.CreateContentByCopyFunction;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.model.ViewHelper;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.i18n.I18nizableTextParameter;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.SimpleViewItemGroup;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.ViewItemContainer;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * <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 attribute to copy as well as some optional parameters.
 * It has the following form (JSON) :
 * </p>
 * <pre>
 * {
 *   "$param1": value,
 *   "attributeA": null,
 *   "attributeB": {
 *     "subattributeB1": null,
 *     "subattributeB2": {
 *       "$param1": value,
 *       "$param2": value,
 *       "subSubattributeB21": {...}
 *     },
 *     ...
 *   }
 * }
 * </pre>
 * <p>
 * Each attribute that should be copied must be present as a key in the map.
 * Composite attribute can contains child attributes 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 attribute name.
 * </p><p>
 * The entry points are the copyContent and editContent methods, which run a dedicated workflow
 * function (createByCopy or edit).<br>
 * Actual write of values is made through the EditContentFunction, with the values computed by this component.
 */
public class CopyContentComponent extends AbstractLogEnabled implements Serviceable, Component
{
    /** Avalon ROLE. */
    public static final String ROLE = CopyContentComponent.class.getName();
    
    /** Workflow provider. */
    protected WorkflowProvider _workflowProvider;
    
    /** Ametys object resolver available to subclasses. */
    protected AmetysObjectResolver _resolver;
    
    /** Helper for content types */
    protected ContentTypesHelper _contentTypesHelper;
    
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    /** The content workflow helper */
    protected ContentWorkflowHelper _contentWorkflowHelper;
    
    /** Avalon service manager */
    protected ServiceManager _manager;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) manager.lookup(ContentWorkflowHelper.ROLE);
        _manager = manager;
    }
    
    /**
     * Copy a content by creating a new content and copying the attributes value a source content into the new one.
     * @param contentId The source content id
     * @param title Desired title for the new content or null if computed from the source's title
     * @param copyMap The map of properties as described in {@link CopyContentComponent}. 
     *                Can be null in which case the map will be constructed from the provided view.
     * @param viewName The name of the view 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 fallbackViewName The fallback view name if 'viewName' is not found
     * @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
     * @return The copy report containing valuable information about the copy and the possible encountered errors.
     */
    public CopyReport copyContent(String contentId, String title, Map<String, Object> copyMap, String viewName, String fallbackViewName, String targetContentType, int initActionId)
    {
        Content content = _resolver.resolveById(contentId);
        CopyReport report = new CopyReport(contentId, _contentHelper.getTitle(content), _contentHelper.isReferenceTable(content), viewName, fallbackViewName, CopyMode.CREATION);
        
        try
        {
            Map<String, Object> inputs = getInputsForCopy(content, title, copyMap, targetContentType, report);
            String workflowName = getWorkflowName(content, inputs);
            
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow();
            workflow.initialize(workflowName, initActionId, inputs);
            
            ModifiableContent targetContent = workflow.getAmetysObject();
            
            report.notifyContentCreation(targetContent.getId(), _contentHelper.getTitle(targetContent), _contentHelper.isReferenceTable(content));
            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 : {}).", contentId, e);
            
            if (e instanceof InvalidInputWorkflowException iiwe)
            {
                I18nizableText rootError = null;
                
                Map<String, List<I18nizableText>> allErrors = iiwe.getValidationResults().getAllErrors();
                for (String errorItemPath : allErrors.keySet())
                {
                    List<I18nizableText> errors = allErrors.get(errorItemPath);
                    I18nizableText insideError = null;
                    for (I18nizableText error : errors)
                    {
                        Map<String, I18nizableTextParameter> i18nparameters = new HashMap<>();
                        i18nparameters.put("0", error);
                        
                        I18nizableText localError = new I18nizableText("plugin.cms", "CONTENT_COPY_ACTIONS_REPORT_ERROR_VALIDATION_ATTRIBUTE_CHAIN", i18nparameters);
                        
                        if (insideError == null)
                        {
                            insideError = localError;
                        }
                        else
                        {
                            insideError.getParameterMap().put("1", localError);
                        }
                    }

                    Map<String, I18nizableTextParameter> i18ngeneralparameters = new HashMap<>();
                    
                    String i18ngeneralkey = null;
                    if (EditContentFunction.GLOBAL_VALIDATION_RESULT_KEY.equals(errorItemPath))
                    {
                        i18ngeneralkey = "CONTENT_COPY_ACTIONS_REPORT_ERROR_GLOBAL_VALIDATION";
                        i18ngeneralparameters.put("error", insideError);
                    }
                    else
                    {
                        i18ngeneralkey = "CONTENT_COPY_ACTIONS_REPORT_ERROR_VALIDATION_ATTRIBUTE";
                        i18ngeneralparameters.put("path", new I18nizableText(errorItemPath));
                        i18ngeneralparameters.put("error", insideError);
                    }

                    I18nizableText generalError = new I18nizableText("plugin.cms", i18ngeneralkey, i18ngeneralparameters);
                    if (rootError == null)
                    {
                        rootError = generalError;
                    }
                    else
                    {
                        rootError.getParameterMap().put("2", generalError);
                    }
                }
                
                Map<String, I18nizableTextParameter> parameters = Map.of("title", new I18nizableText(_contentHelper.getTitle(content)), "error", rootError);
                I18nizableText errorMsg = new I18nizableText("plugin.cms", "CONTENT_COPY_ACTIONS_REPORT_ERROR_COPY", parameters);
                report.setErrorMessage(errorMsg);
            }
            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 copyReport The report of the copy
     * @return The map of inputs.
     */
    protected Map<String, Object> getInputsForCopy(Content baseContent, String title, Map<String, Object> copyMap, String targetContentType, CopyReport copyReport)
    {
        Map<String, Object> inputs = new HashMap<>();
        
        inputs.put(CreateContentByCopyFunction.BASE_CONTENT_KEY, baseContent);
        inputs.put(CreateContentByCopyFunction.COPY_MAP_KEY, copyMap);
        inputs.put(CreateContentByCopyFunction.COPY_REPORT_KEY, copyReport);
        inputs.put(CreateContentByCopyFunction.COPY_VIEW_NAME, copyReport.getViewName());
        inputs.put(CreateContentByCopyFunction.COPY_FALLBACK_VIEW_NAME, copyReport.getFallbackViewName());
        
        if (StringUtils.isNoneBlank(title))
        {
            inputs.put(CreateContentFunction.CONTENT_TITLE_KEY, title);
        }

        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new LinkedHashMap<>());
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<>());
        
        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 getWorkflowName(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 = String.format("Unable to retrieve the workflow name for the content with identifier '%s'.", content.getId());
            
            getLogger().error(errorMsg);
            throw new IllegalArgumentException(errorMsg);
        }
        
        return workflowName;
    }
    
    /**
     * Edit a content by copying attribute values a source content into a target content.
     * @param contentId The identifier of the source content
     * @param targetContentId The identifier of the target content
     * @param copyMap The map of properties as described in {@link CopyContentComponent}. 
     *                Can be null in which case the map will be constructed from the provided view.
     * @param viewName The name of the view 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 fallbackViewName The fallback view name if 'viewName' is not found
     * @return The copy report containing valuable information about the copy and the possible encountered errors.
     */
    public CopyReport editContent(String contentId, String targetContentId, Map<String, Object> copyMap, String viewName, String fallbackViewName)
    {
        return editContent(contentId, targetContentId, copyMap, viewName, fallbackViewName, getDefaultActionIdForContentEdition());
    }

    /**
     * Edit a content by copying attribute values a source content into a target content.
     * @param contentId The identifier of the source content
     * @param targetContentId The identifier of the target content
     * @param copyMap The map of properties as described in {@link CopyContentComponent}. 
     *                Can be null in which case the map will be constructed from the provided view.
     * @param viewName The name of the view 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 fallbackViewName The fallback view name if 'viewName' is not found
     * @param actionId the edit workflow action id
     * @return The copy report containing valuable information about the copy and the possible encountered errors.
     */
    public CopyReport editContent(String contentId, String targetContentId, Map<String, Object> copyMap, String viewName, String fallbackViewName, int actionId)
    {
        Content content = _resolver.resolveById(contentId);
        
        String auxViewName = StringUtils.defaultIfEmpty(viewName, "default-edition");
        String auxFallbackViewName = StringUtils.defaultIfEmpty(fallbackViewName, "main");
        
        CopyReport report = new CopyReport(contentId, _contentHelper.getTitle(content), _contentHelper.isReferenceTable(content), auxViewName, auxFallbackViewName, CopyMode.EDITION);
        try
        {
            WorkflowAwareContent targetContent = _resolver.resolveById(targetContentId);
            
            Map<String, Object> values = computeValues(content, (ModifiableContent) targetContent, copyMap, null, auxViewName, auxFallbackViewName, report);
            
            _contentWorkflowHelper.editContent(targetContent, values, actionId);
            
            report.notifyContentCreation(targetContent.getId(), _contentHelper.getTitle(targetContent), _contentHelper.isReferenceTable(content));
            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 : {}, target content identifier : {}).",
                    contentId, targetContentId, e);
            
            report.notifyContentCopyError();
        }
        
        return report;
    }
    
    /**
     * Extract values to copy from the given parameters.
     * @param content the source content
     * @param targetContent the target content
     * @param copyMap the map of properties as described in {@link CopyContentComponent}. 
     * @param additionalCopyMap an additional map of properties if needed. Can be null. Often used in case of recursive copies.
     * @param viewName The name of the view 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 fallbackViewName The fallback view name if 'viewName' is not found
     * @param copyReport The copy report containing valuable information about the copy and the possible encountered errors.
     * @return the computed values, ready to be synchronized to the target content.
     */
    public Map<String, Object> computeValues(Content content, ModifiableContent targetContent, Map<String, Object> copyMap, Map<String, Object> additionalCopyMap, String viewName, String fallbackViewName, CopyReport copyReport)
    {
        Pair<View, Map<String, Object>> viewAndValues = _getViewAndValues(content, copyMap, additionalCopyMap, viewName, fallbackViewName, copyReport);
        View view = viewAndValues.getLeft();
        Map<String, Object> values = viewAndValues.getRight();

        _updateRichTexts(content, targetContent, view, values, copyReport);
        
        return values;
    }
    
    private Pair<View, Map<String, Object>> _getViewAndValues(Content content, Map<String, Object> copyMap, Map<String, Object> additionalCopyMap, String viewName, String fallbackViewName, CopyReport copyReport)
    {
        Set<String> viewItems;
        Map<String, Map<String, Object>> contentToCopy = new HashMap<>();
        
        Map<String, Object> finalCopyMap = null;
        if (copyMap != null)
        {
            finalCopyMap = new HashMap<>();
            for (Entry<String, Object> entry : copyMap.entrySet())
            {
                if (!entry.getKey().startsWith("$"))
                {
                    // cannot use stream here as entry values are often null and Collectors.toMap don't like that...
                    finalCopyMap.put(entry.getKey(), entry.getValue());
                }
            }
        }
        
        View viewToCopy = _contentTypesHelper.getViewWithFallback(viewName, fallbackViewName, content.getTypes(), content.getMixinTypes());
        if (finalCopyMap != null && !finalCopyMap.isEmpty())
        {
            viewItems = new HashSet<>();
            _fillViewItemsFromCopyMap(content, viewToCopy, viewItems, contentToCopy, finalCopyMap, StringUtils.EMPTY);
        }
        else
        {
            viewItems = new HashSet<>(org.ametys.runtime.model.ViewHelper.getModelItemsPathsFromView(viewToCopy));
        }
        
        if (additionalCopyMap != null)
        {
            _fillViewItemsFromCopyMap(content, viewToCopy, viewItems, contentToCopy, additionalCopyMap, StringUtils.EMPTY);
        }
        
        View view = View.of(content.getModel(), viewItems.toArray(String[]::new));
        Map<String, Object> values = content.dataToMap(view);

        _processLinkedContents(content, view, values, contentToCopy, copyReport);

        return Pair.of(view, values);
    }
    
    @SuppressWarnings("unchecked")
    private void _fillViewItemsFromCopyMap(Content content, ViewItemAccessor viewItemAccessor, Set<String> items, Map<String, Map<String, Object>> contentToCopy, Map<String, Object> copyMap, String prefix)
    {
        for (String name : copyMap.keySet())
        {
            if (!name.startsWith("$"))
            {
                Object value = copyMap.get(name);
                if (value == null)
                {
                    items.add(prefix + name);
                }
                else
                {
                    Map<String, Object> subCopyMap = (Map<String, Object>) value;
                    if (subCopyMap.containsKey("$mode"))
                    {
                        // content attribute
                        items.add(prefix + name);
                        contentToCopy.put(prefix + name, subCopyMap);
                    }
                    else
                    {
                        ViewItem viewItem = viewItemAccessor.getViewItem(name);
                        if (viewItem == null)
                        {
                            // The view item is in an unnamed group, get the model view item
                            viewItem = viewItemAccessor.getModelViewItem(name);
                        }
                        
                        if (viewItem instanceof SimpleViewItemGroup group)
                        {
                            _fillViewItemsFromCopyMap(content, group, items, contentToCopy, subCopyMap, prefix);
                        }
                        else if (viewItem instanceof ModelViewItemGroup modelViewItemGroup)
                        {
                            _fillViewItemsFromCopyMap(content, modelViewItemGroup, items, contentToCopy, subCopyMap, prefix + name + ModelItem.ITEM_PATH_SEPARATOR);
                        }
                    }
                }
            }
        }
    }
    
    @SuppressWarnings("unchecked")
    private void _processLinkedContents(Content content, ViewItemContainer viewItemContainer, Map<String, Object> values, Map<String, Map<String, Object>> contentToCopy, CopyReport copyReport)
    {
        ViewHelper.visitView(viewItemContainer, 
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                String path = definition.getPath();
                Object value = values.get(name);
                if (value != null && definition.getType().getId().equals(ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID))
                {
                    // create the content and replace the old value by the new one
                    Map<String, Object> copyMap = contentToCopy.get(path);
                    boolean referenceMode = copyMap == null || !"create".equals(copyMap.get("$mode"));
                    
                    if (definition.isMultiple())
                    {
                        ContentValue[] contentValues = (ContentValue[]) value;
                        List<ContentValue> targets = new ArrayList<>();
                        
                        Arrays.stream(contentValues)
                              .map(contentValue -> contentValue.getContentIfExists())
                              .flatMap(Optional::stream)
                              .forEach(subContent -> {
                                  ContentValue contentValue = handleLinkedContent(definition, subContent, referenceMode, copyMap, copyReport);
                                  if (contentValue != null)
                                  {
                                      targets.add(contentValue);
                                  }
                              });
                        
                        values.put(name, targets.toArray(ContentValue[]::new));
                    }
                    else
                    {
                        ContentValue contentValue = (ContentValue) value;
                        ModifiableContent subContent = contentValue.getContentIfExists().orElse(null);
                        if (subContent != null)
                        {
                            ContentValue linkedValue = handleLinkedContent(definition, subContent, referenceMode, copyMap, copyReport);
                            values.put(name, linkedValue);
                        }
                    }
                }
            }, 
            (group, definition) -> {
                // composite
                String name = definition.getName();
                Map<String, Object> composite = (Map<String, Object>) values.get(name);
                if (composite != null)
                {
                    _processLinkedContents(content, group, composite, contentToCopy, copyReport);
                }
            }, 
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                List<Map<String, Object>> entries = (List<Map<String, Object>>) values.get(name);
                if (entries != null)
                {
                    for (Map<String, Object> entry : entries)
                    {
                        _processLinkedContents(content, group, entry, contentToCopy, copyReport);
                    }
                }
            }, 
            group -> _processLinkedContents(content, group, values, contentToCopy, copyReport));
    }
    
    /**
     * Handle a single value of a content attribute
     * @param definition the attribute definition
     * @param value the linked value on the source content
     * @param referenceMode true if a reference was initially requested, false if it was a copy
     * @param copyMap the current copy map
     * @param copyReport the copy report
     * @return the {@link ContentValue} (copied or not) to insert in the current Content. 
     */
    protected ContentValue handleLinkedContent(ElementDefinition definition, ModifiableContent value, boolean referenceMode, Map<String, Object> copyMap, CopyReport copyReport)
    {
        if (!referenceMode)
        {
            String targetContentId = copyLinkedContent(value, copyMap, copyReport);
            if (targetContentId != null)
            {
                return new ContentValue(_resolver, targetContentId);
            }
        }
        else
        {
            return new ContentValue(value);
        }
        
        return null;
    }
    
    /**
     * Copy a value of a content attribute.
     * @param content the initial content value.
     * @param copyMap the current copy map
     * @param copyReport the current copy report
     * @return the id of the copied Content.
     */
    protected String copyLinkedContent(Content content, Map<String, Object> copyMap, CopyReport copyReport)
    {
        String defaultViewName = copyMap != null ? (String) copyMap.getOrDefault("$viewName", copyReport.getViewName()) : copyReport.getViewName();
        String defaultFallbackViewName = copyMap != null ? (String) copyMap.getOrDefault("$fallbackViewName", copyReport.getFallbackViewName()) : copyReport.getFallbackViewName();
        
        CopyReport innerReport = copyContent(content.getId(), content.getTitle(), copyMap, defaultViewName, defaultFallbackViewName, null, getDefaultInitActionId());
        
        String targetContentId = null;
        if (innerReport.getStatus() == CopyState.SUCCESS)
        {
            targetContentId = innerReport.getTargetContentId();
        }
        
        copyReport.addReport(innerReport);
        
        return targetContentId;
    }
    
    @SuppressWarnings("unchecked")
    private void _updateRichTexts(Content content, ModifiableContent targetContent, ViewItemContainer viewItemContainer, Map<String, Object> values, CopyReport copyReport)
    {
        ViewHelper.visitView(viewItemContainer, 
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                Object value = values.get(name);
                if (value != null && definition.getType().getId().equals(ModelItemTypeConstants.RICH_TEXT_ELEMENT_TYPE_ID))
                {
                    // update richTexts
                    RichTextUpdater richTextUpdater = ((ContentType) definition.getModel()).getRichTextUpdater();
                    if (richTextUpdater != null)
                    {
                        if (definition.isMultiple())
                        {
                            RichText[] richTexts = (RichText[]) value;
                            for (RichText richText : richTexts)
                            {
                                _updateRichText(richText, richTextUpdater, content, targetContent, copyReport);
                            }
                        }
                        else
                        {
                            RichText richText = (RichText) value;
                            _updateRichText(richText, richTextUpdater, content, targetContent, copyReport);
                        }
                    }
                }
            }, 
            (group, definition) -> {
                // composite
                String name = definition.getName();
                Map<String, Object> composite = (Map<String, Object>) values.get(name);
                if (composite != null)
                {
                    _updateRichTexts(content, targetContent, group, composite, copyReport);
                }
            }, 
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                List<Map<String, Object>> entries = (List<Map<String, Object>>) values.get(name);
                if (entries != null)
                {
                    for (Map<String, Object> entry : entries)
                    {
                        _updateRichTexts(content, targetContent, group, entry, copyReport);
                    }
                }
            }, 
            group -> _updateRichTexts(content, targetContent, group, values, copyReport));
    }
    
    private void _updateRichText(RichText richText, RichTextUpdater richTextUpdater, Content initialContent, ModifiableContent targetContent, CopyReport copyReport)
    {
        try
        {
            Map<String, Object> params = new HashMap<>();
            params.put("initialContent", initialContent);
            params.put("createdContent", targetContent);
            params.put("initialAO", initialContent);
            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, initialContent, targetContent, copyReport, _resolver, getLogger());
                
                // Rich text update.
                SAXParser saxParser = null;
                try
                {
                    saxParser = (SAXParser) _manager.lookup(SAXParser.ROLE);
                    saxParser.parse(new InputSource(is), copyAttachmentsHandler);
                }
                catch (ServiceException e)
                {
                    throw new ProcessingException("Unable to get a SAX parser", e);
                }
                finally
                {
                    _manager.release(saxParser);
                }
            }
        }
        catch (Exception e)
        {
            getLogger().error("An error occurred while updating rich text attribute for content '{}' after copy from initial content '{}'", targetContent.getId(), initialContent.getId(), e);
        }
    }
    
    /**
     * 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 by copy
     * @return the default action id
     */
    public int getDefaultActionIdForContentEdition()
    {
        return 222;
    }
    
    /**
     * A copy attachments content handler.
     * To be used to copy the attachments linked in a rich text attribute.
     */
    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)
        {
            try
            {
                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);
                    }
                }
            }
            catch (AmetysRepositoryException e)
            {
                // the reference was not <protocol>://<protocol-specific-part> (for example : mailto:mymail@example.com )
                _logger.debug("The link '{}' is not recognized as Ametys object. It will be ignored", href);
                return; 
            }
        }

        /**
         * 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);
                    }
                }
            }
        }
    }
}