/*
 *  Copyright 2014 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.clientsideelement.relations;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentAttributeDefinition;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.model.restrictions.RestrictedModelItem;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.cms.workflow.InvalidInputWorkflowException;
import org.ametys.core.ui.Callable;
import org.ametys.core.ui.StaticClientSideRelation;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.data.holder.values.SynchronizableRepeater;
import org.ametys.plugins.repository.data.holder.values.SynchronizableValue;
import org.ametys.plugins.repository.data.holder.values.SynchronizableValue.Mode;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.i18n.I18nizableTextParameter;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.exception.UndefinedItemPathException;

/**
 * Set the attribute of type 'content' of a content, with another content 
 */
public class SetContentAttributeClientSideElement extends StaticClientSideRelation implements Component
{
    /** The Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    /** The content type helper */
    protected ContentTypesHelper _contentTypesHelper;
    /** The content types extension point */
    protected ContentTypeExtensionPoint _contentTypeExtensionPoint;
    /** The content workflow helper */
    protected ContentWorkflowHelper _contentWorkflowHelper;
    /** The content helper */
    protected ContentHelper _contentHelper;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) manager.lookup(ContentWorkflowHelper.ROLE);
    }
    
    /**
     * Find an attribute of type content in definition of 'contentIdsToReference' and set the attribute of contents 'contentIdsToEdit' with value 'contentIdsToReference'
     * @param contentIdsToReference The list of content identifiers that will be added as values in the content field
     * @param contentIdsToEdit The list of content identifiers to edit and that will have an attribute of type content modified
     * @return the list of all compatible attribute definitions
     */
    @Callable
    public List<Map<String, Object>> getCompatibleAttributes(List<String> contentIdsToReference, List<String> contentIdsToEdit)
    {
        List<? extends Content> contentsToReference = _resolve(contentIdsToReference);
        List<? extends Content> contentsToEdit = _resolve(contentIdsToEdit);

        Set<ModelItem> compatibleAtributes = _findCompatibleAttributes(contentsToReference, contentsToEdit);
        
        return _convert(compatibleAtributes);
    }
    
    /**
     * Convert attribute definitions to JSON object
     * @param attributeDefinitions The attribute definitions
     * @return the JSON object
     */
    protected List<Map<String, Object>> _convert(Set<ModelItem> attributeDefinitions)
    {
        List<Map<String, Object>> attributeInfo = new ArrayList<>(); 
        
        for (ModelItem attributeDefinition : attributeDefinitions) 
        {
            attributeInfo.add(_convert(attributeDefinition));
        }
        
        return attributeInfo;
    }

    /**
     * Convert an attribute definition to JSON
     * @param attributeDefinition the attribute definition
     * @return the JSON object
     */
    protected Map<String, Object> _convert(ModelItem attributeDefinition)
    {
        String attributePath = attributeDefinition.getPath();
        
        Map<String, Object> definition = new HashMap<>();
        definition.put("path", attributePath);
        definition.put("name", attributeDefinition.getName());
        definition.put("label", attributeDefinition.getLabel());
        definition.put("description", attributeDefinition.getDescription());

        if (attributePath.contains(ModelItem.ITEM_PATH_SEPARATOR))
        {
            ModelItem parentMetadatadef = attributeDefinition.getParent();
            definition.put("parent", _convert(parentMetadatadef));
        }
        
        return definition;
    }
    
    /**
     * Find the list of compatible attribute definitions
     * @param contentsToReference the contents to reference
     * @param contentsToEdit the contents to edit
     * @return the list of compatible attribute definitions
     */
    protected Set<ModelItem> _findCompatibleAttributes(List<? extends Content> contentsToReference, List<? extends Content> contentsToEdit)
    {
        // First we need to find the type of the target attribute we are looking for
        Collection<String> contentTypesToReference = _getContentTypesIntersection(contentsToReference);

        // Second we need to know if this attribute will be multiple or not
        boolean requiresMultiple = contentsToReference.size() > 1;
        
        // Third we need to know the target content type
        Collection<String> contentTypesToEdit = _getContentTypesIntersection(contentsToEdit);
        
        // Now lets navigate in the target content types to find an attribute of type content limited to the references content types (or its parent types), that is multiple if necessary
        Set<ModelItem> compatibleAttributes = new HashSet<>();
        
        for (String targetContentTypeId : contentTypesToEdit)
        {
            ContentType targetContentType = _contentTypeExtensionPoint.getExtension(targetContentTypeId);
            for (ModelItem modelItem : targetContentType.getModelItems())
            {
                compatibleAttributes.addAll(_findCompatibleAttributes(contentsToReference, contentsToEdit, targetContentTypeId, modelItem, false, contentTypesToReference, requiresMultiple));
            }
        }
        
        return compatibleAttributes;
    }
    
    private Set<ModelItem> _findCompatibleAttributes(List<? extends Content> contentsToReference, List<? extends Content> contentsToEdit, String targetContentTypeId, ModelItem modelItem, boolean anyParentIsMultiple, Collection<String> compatibleContentTypes, boolean requiresMultiple)
    {
        Set<ModelItem> compatibleAttributes = new HashSet<>();
        
        if (modelItem instanceof ContentAttributeDefinition) 
        {
            if (_isAttributeCompatible(contentsToEdit, targetContentTypeId, (ContentAttributeDefinition) modelItem, anyParentIsMultiple, compatibleContentTypes, requiresMultiple))
            {
                compatibleAttributes.add(modelItem);
            }
        }
        else if (modelItem instanceof ModelItemContainer)
        {
            for (ModelItem child : ((ModelItemContainer) modelItem).getModelItems())
            {
                compatibleAttributes.addAll(_findCompatibleAttributes(contentsToReference, contentsToEdit, targetContentTypeId, child, anyParentIsMultiple || modelItem instanceof RepeaterDefinition, compatibleContentTypes, requiresMultiple));
            }
        }
        
        return compatibleAttributes;
    }
    
    private boolean _isAttributeCompatible(List<? extends Content> contentsToEdit, String targetContentTypeId, ContentAttributeDefinition attributeDefinition, boolean anyParentIsMultiple, Collection<String> compatibleContentTypes, boolean requiresMultiple)
    {
        String contentTypeId = attributeDefinition.getContentTypeId();
        
        return (contentTypeId == null || compatibleContentTypes.contains(contentTypeId))
                && (!requiresMultiple || attributeDefinition.isMultiple() || anyParentIsMultiple)
                && attributeDefinition.getModel().getId().equals(targetContentTypeId)
                && _hasRight(contentsToEdit, attributeDefinition);
    }
    
    private boolean _hasRight (List<? extends Content> contentsToEdit, RestrictedModelItem<Content> modelItem)
    {
        for (Content content : contentsToEdit)
        {
            if (!modelItem.canWrite(content))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Set the attribute at path 'attributePath' of contents 'contentIdsToEdit' with value 'contentIdsToReference'
     * @param contentIdsToReference The list of content identifiers that will be added as values in the content field
     * @param contentIdsToEdit The map {key: content identifiers to edit and that will have an attribute of type content modified; value: the new position if attribute is multiple and it is a reorder of values. May be null or equals to -1 if it is not a reorder}
     * @param contentsToEditToRemove  The list of content to edit to remove currently referenced content. Keys are "contentId" and "valueToRemove"
     * @param attributePath The attribute path selected to do modification in the contents to edit
     * @param workflowActionIds The identifiers of workflow actions to use to edit the attribute. Actions will be tested in this order and first available action will be used
     * @return A map with key success: true or false. if false, it can be due to errors (list of error messages)
     */
    @Callable
    public Map<String, Object> setContentAttribute(List<String> contentIdsToReference, Map<String, Integer> contentIdsToEdit, List<Map<String, String>> contentsToEditToRemove, String attributePath, List<String> workflowActionIds)
    {
        return setContentAttribute(contentIdsToReference, contentIdsToEdit, contentsToEditToRemove, attributePath, workflowActionIds, new HashMap<>());
    }
    
    /**
     * Set the attribute at path 'attributePath' of contents 'contentIdsToEdit' with value 'contentIdsToReference'
     * @param contentIdsToReference The list of content identifiers that will be added as values in the content field
     * @param contentIdsToEdit The map {key: content identifiers to edit and that will have an attribute of type content modified; value: the new position if attribute is multiple and it is a reorder of values. May be null or equals to -1 if it is not a reorder}
     * @param contentsToEditToRemove  The list of content to edit to remove currently referenced content. Keys are "contentId" and "valueToRemove"
     * @param attributePath The attribute path selected to do modification in the contents to edit
     * @param workflowActionIds The identifiers of workflow actions to use to edit the attribute. Actions will be tested in this order and first available action will be used
     * @param additionalParams the map of additional parameters
     * @return A map with key success: true or false. if false, it can be due to errors (list of error messages)
     */
    @SuppressWarnings("unchecked")
    @Callable
    public Map<String, Object> setContentAttribute(List<String> contentIdsToReference, Map<String, Integer> contentIdsToEdit, List<Map<String, String>> contentsToEditToRemove, String attributePath, List<String> workflowActionIds, Map<String, Object> additionalParams)
    {
        Map<WorkflowAwareContent, Integer> contentsToEdit = (Map<WorkflowAwareContent, Integer>) _resolve(contentIdsToEdit);
 
        List<String> errorIds = new ArrayList<>();
        List<I18nizableText> errorMessages = new ArrayList<>();

        if (!contentsToEditToRemove.isEmpty())
        {
            // There are some relations to remove, so we consider the content has been moving
            additionalParams.put("mode", "move");
        }
        
        // We filter contents to edit. If some error occurs, the relation is not cleaned and we return the errors
        // Default implementation returns the same map of contents to edit with no errors
        Map<WorkflowAwareContent, Integer> filteredContentsToEdit = _filterContentsToEdit(contentsToEdit, contentIdsToReference, errorMessages, errorIds, additionalParams);
        if (!errorIds.isEmpty() || !errorMessages.isEmpty())
        {
            // If some error occurs, return the errors
            return _returnValue(errorMessages, errorIds);
        }
        
        // Clean the old relations
        _clean(contentsToEditToRemove, workflowActionIds, errorMessages, errorIds);
        if (filteredContentsToEdit.isEmpty() || contentIdsToReference.isEmpty())
        {
            return _returnValue(errorMessages, errorIds);
        }
        
        // Get the content types of target contents
        Collection<String> contentTypeIdsToEdit = _getContentTypesIntersection(filteredContentsToEdit.keySet());
        List<ContentType> contentTypesToEdit = contentTypeIdsToEdit.stream()
            .map(id -> _contentTypeExtensionPoint.getExtension(id))
            .collect(Collectors.toList());
        
        try
        {
            ModelItem attributeDefinition = ModelHelper.getModelItem(attributePath, contentTypesToEdit);
            // Get the content type holding this attribute
            ContentType targetContentType = _contentTypeExtensionPoint.getExtension(attributeDefinition.getModel().getId());
            _setContentAttribute(contentIdsToReference, filteredContentsToEdit, targetContentType, attributePath, workflowActionIds, errorMessages, errorIds, additionalParams);
            return _returnValue(errorMessages, errorIds);
        }
        catch (UndefinedItemPathException e)
        {
            throw new IllegalStateException("Unable to set attribute at path '" + attributePath + "'.", e);
        }
    }
    
    /**
     * Filter the list of contents to edit
     * @param contentsToEdit the map of contents to edit
     * @param contentIdsToReference The list of content ids that will be added as values in the content field
     * @param errorMessages the error messages
     * @param errorIds the error content ids
     * @param additionalParams the map of additional parameters
     * @return the list of filtered contents
     */
    protected Map<WorkflowAwareContent, Integer> _filterContentsToEdit(Map<WorkflowAwareContent, Integer> contentsToEdit, List<String> contentIdsToReference, List<I18nizableText> errorMessages, List<String> errorIds, Map<String, Object> additionalParams)
    {
        // Default implementation
        return contentsToEdit;
    }

    private Map<String, Object> _returnValue(List<I18nizableText> errorMessages, List<String> errorIds)
    {
        Map<String, Object> returnValues = new HashMap<>();
        returnValues.put("success", errorMessages.isEmpty() && errorIds.isEmpty());
        if (!errorMessages.isEmpty())
        {
            returnValues.put("errorMessages", errorMessages);
        }
        if (!errorIds.isEmpty())
        {
            returnValues.put("errorIds", errorIds);
        }
        return returnValues;
    }
    
    private void _clean(List<Map<String, String>> contentsToEditToRemove, List<String> workflowActionIds, List<I18nizableText> errorMessages, List<String> errorIds)
    {
        for (Map<String, String> removeObject : contentsToEditToRemove)
        {
            String contentIdToEdit = removeObject.get("contentId");
            String referencingAttributePath = removeObject.get("referencingAttributePath");
            String valueToRemove = removeObject.get("valueToRemove");
            
            WorkflowAwareContent content = _resolver.resolveById(contentIdToEdit);
            
            List<ModelItem> items = ModelHelper.getAllModelItemsInPath(referencingAttributePath, content.getModel());
            
            Object valuesToRemove;
            ModelItem attributeDefinition = items.get(items.size() - 1);
            ContentValue contentValueToRemove = new ContentValue(_resolver, valueToRemove);
            if (attributeDefinition instanceof ElementDefinition && ((ElementDefinition) attributeDefinition).isMultiple())
            {
                valuesToRemove = new ContentValue[] {contentValueToRemove};
            }
            else
            {
                valuesToRemove = contentValueToRemove;
            }
            
            SynchronizableValue value = new SynchronizableValue(valuesToRemove);
            value.setMode(Mode.REMOVE);
            
            Map<String, Object> values = Map.of(attributeDefinition.getName(), value);
            for (int i = items.size() - 2; i >= 0; i--)
            {
                ModelItem item = items.get(i);
                if (item instanceof RepeaterDefinition)
                {
                    throw new IllegalArgumentException("SetContentAttributeClientSideElement does not support a path containing repeater for removing references");
                }
                
                values = Map.of(item.getName(), values);
            }
            
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Content " + contentIdToEdit + " must be edited at " + referencingAttributePath +  " to remove " + valueToRemove);
            }
            
            _doAction(content, workflowActionIds, values, errorIds, errorMessages);
        }
    }
    

    /**
     * Set the attribute at path 'attributePath' of contents 'contentsToEdit' with value 'contentIdsToReference'
     * @param contentIdsToReference The list of content identifiers that will be added as values in the content field
     * @param contentsToEdit The map {key: contents to edit and that will have an attribute of type content modified; value: the new position if attribute is multiple and it is a reorder of values. May be null or equals to -1 if it is not a reorder}
     * @param contentType The content type
     * @param attributePath The attribute path selected to do modification in the contents to edit
     * @param workflowActionIds The identifiers of workflow actions to use to edit the attribute. Actions will be tested in this order and first available action will be used
     * @param errorMessages The list that will be felt with error messages of content that had an issue during the operation 
     * @param errorIds The list that will be felt with ids of content that had an issue during the operation
     * @param additionalParams the map of additional parameters
     */
    protected void _setContentAttribute(List<String> contentIdsToReference, Map<WorkflowAwareContent, Integer> contentsToEdit, ContentType contentType, String attributePath, List<String> workflowActionIds, List<I18nizableText> errorMessages, List<String> errorIds, Map<String, Object> additionalParams)
    {
        // On each content
        for (WorkflowAwareContent content : contentsToEdit.keySet())
        {
            List<ModelItem> items = ModelHelper.getAllModelItemsInPath(attributePath, content.getModel());
            int size = items.size();

            ModelItem attributeDefinition = items.get(size - 1);
            if (!(attributeDefinition instanceof ContentAttributeDefinition))
            {
                throw new IllegalStateException("No definition of type content found for path '" + attributePath + "' in the content type '" + contentType.getId() + "'.");
            }
            
            // find the last repeater in path
            Pair<RepeaterDefinition, Integer> lastRepeaterDefinitionAndIndex = _getLastRepeaterDefinitionAndIndex(items);
            RepeaterDefinition lastRepeaterDefinition = lastRepeaterDefinitionAndIndex.getLeft();
            int lastRepeaterIndex = lastRepeaterDefinitionAndIndex.getRight();
            
            Object value;
            int lastHandledIndex = size;
            ModelItem lastHandledItem = attributeDefinition;
            if (((ContentAttributeDefinition) attributeDefinition).isMultiple())
            {
                Integer newPosition = contentsToEdit.get(content);
                if (lastRepeaterDefinition != null)
                {
                    // if there is a repeater we can't merge values, they will be put in a single multiple value
                    value = _getContentValues(contentIdsToReference);
                }
                else if (newPosition == null || newPosition < 0)
                {
                    // Normal case, it is not a move
                    SynchronizableValue syncValue = new SynchronizableValue(_getContentValues(contentIdsToReference));
                    syncValue.setMode(Mode.APPEND);
                    value = syncValue;
                }
                else
                {
                    // Specific case where there is no new content id to reference, but a reorder in a multiple attribute
                    ContentValue[] contentValues = content.getValue(attributePath);
                    List<String> currentAttributeValue = Arrays.stream(contentValues)
                            .map(ContentValue::getContentId)
                            .collect(Collectors.toList());
                    List<String> reorderedAttributeValue = _reorder(currentAttributeValue, contentIdsToReference, newPosition);
                    
                    value = _getContentValues(reorderedAttributeValue);
                }
            }
            else if (lastRepeaterDefinition != null)
            {
                // Special case if there is a repeater in the path and the attribute is single valued.
                // Create as many repeater entries as there are referenced contents.
                List<Map<String, Object>> entries = new ArrayList<>();
                for (int i = 0; i < contentIdsToReference.size(); i++)
                {
                    Map<String, Object> currentValue =  Map.of(attributeDefinition.getName(), contentIdsToReference.get(i));
                    for (int j = items.size() - 2; j > lastRepeaterIndex; j--)
                    {
                        ModelItem item = items.get(j);
                        currentValue = Map.of(item.getName(), currentValue);
                    }
                    
                    entries.add(currentValue);
                }
                
                lastHandledIndex = lastRepeaterIndex + 1;
                lastHandledItem = lastRepeaterDefinition;
                value = SynchronizableRepeater.appendOrRemove(entries, Set.of());
            }
            else
            {
                value = contentIdsToReference.get(0);
            }
            
            Map<String, Object> values = Map.of(lastHandledItem.getName(), value);
            for (int i = lastHandledIndex - 2; i >= 0; i--)
            {
                ModelItem item = items.get(i);
                if (item instanceof RepeaterDefinition)
                {
                    values = Map.of(item.getName(), SynchronizableRepeater.appendOrRemove(List.of(values), Set.of()));
                }
                else
                {
                    values = Map.of(item.getName(), values);
                }
            }
            
            // Find the edit action to use
            _doAction(content, workflowActionIds, values, errorIds, errorMessages);
        }
    }
    
    private Pair<RepeaterDefinition, Integer> _getLastRepeaterDefinitionAndIndex(List<ModelItem> items)
    {
        int index = items.size() > 1 ? items.size() - 2 : -1;
        RepeaterDefinition lastRepeaterDefinition = null;
        int lastRepeaterIndex = -1;
        while (index >= 0 && lastRepeaterDefinition == null)
        {
            ModelItem item = items.get(index);
            if (item instanceof RepeaterDefinition)
            {
                lastRepeaterDefinition = (RepeaterDefinition) item;
                lastRepeaterIndex = index;
            }
            
            index--;
        }
        
        return new ImmutablePair<>(lastRepeaterDefinition, lastRepeaterIndex);
    }
    
    private ContentValue[] _getContentValues(List<String> ids)
    {
        return ids.stream().map(s -> new ContentValue(_resolver, s)).toArray(ContentValue[]::new);
    }
    
    private List<String> _reorder(List<String> currentElements, List<String> elementsToReorder, int newPosition)
    {
        List<String> reorderedList = new ArrayList<>(currentElements);
        
        // 1/ in currentElements, replace the ones to reorder by null, in order to keep all indexes
        for (int i = 0; i < currentElements.size(); i++)
        {
            String element = currentElements.get(i);
            if (elementsToReorder.contains(element))
            {
                reorderedList.set(i, null);
            }
        }
        
        // 2/ insert the elements to reorder at the new position
        reorderedList.addAll(newPosition, elementsToReorder);
        
        // 3/ remove null elements, corresponding to the old positions of the elements that were reordered
        reorderedList.removeIf(Objects::isNull);
        
        return reorderedList;
    }

    private void _doAction(WorkflowAwareContent content, List<String> workflowActionIds, Map<String, Object> values, List<String> errorIds, List<I18nizableText> errorMessages)
    {
        Integer actionId = null; 
        
        int[] actionIds = _contentWorkflowHelper.getAvailableActions(content);
        for (String workflowActionIdToTryAsString : workflowActionIds)
        {
            Integer workflowActionIdToTry = Integer.parseInt(workflowActionIdToTryAsString);
            if (ArrayUtils.contains(actionIds, workflowActionIdToTry))
            {
                actionId = workflowActionIdToTry;
                break;
            }
        }
        
        if (actionId == null)
        {
            List<String> parameters = new ArrayList<>();
            parameters.add(_contentHelper.getTitle(content));
            parameters.add(content.getName());
            parameters.add(content.getId());
            errorMessages.add(new I18nizableText("plugin.cms", "PLUGINS_CMS_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_WORKFLOW", parameters));
            errorIds.add(content.getId());
        }
        else
        {
            // edit
            Map<String, Object> contextParameters = new HashMap<>();
            contextParameters.put(EditContentFunction.QUIT, true);
            contextParameters.put(EditContentFunction.VALUES_KEY, values);
            
            Map<String, Object> inputs = new HashMap<>();
            inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, contextParameters);
            
            try
            {
                _contentWorkflowHelper.doAction(content, actionId, inputs);
            }
            catch (Exception e)
            {
                getLogger().error("Content '" + _contentHelper.getTitle(content) + "' (" + content.getName() + "/" + content.getId() + ") was not modified", e);
                
                Map<String, I18nizableTextParameter> parameters = new HashMap<>();
                parameters.put("0", new I18nizableText(_contentHelper.getTitle(content)));
                parameters.put("1", new I18nizableText(content.getName()));
                parameters.put("2", new I18nizableText(content.getId()));
                
                if (e instanceof InvalidInputWorkflowException iiwe)
                {
                    I18nizableText rootError = null;
                    
                    Map<String, List<I18nizableText>> allErrorsMap = iiwe.getValidationResults().getAllErrors();
                    for (String errorDataPath : allErrorsMap.keySet())
                    {
                        List<I18nizableText> errors = allErrorsMap.get(errorDataPath);
                        I18nizableText insideError = null;
                        for (I18nizableText error : errors)
                        {
                            Map<String, I18nizableTextParameter> i18nparameters = new HashMap<>();
                            i18nparameters.put("0", error);
                            
                            I18nizableText localError = new I18nizableText("plugin.cms", "PLUGINS_CMS_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_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(errorDataPath))
                        {
                            i18ngeneralkey = "PLUGINS_CMS_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_GLOBAL_VALIDATION";
                            i18ngeneralparameters.put("1", insideError);
                        }
                        else
                        {
                            i18ngeneralkey = "PLUGINS_CMS_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_VALIDATION_ATTRIBUTE";
                            i18ngeneralparameters.put("0", new I18nizableText(errorDataPath));
                            i18ngeneralparameters.put("1", insideError);
                        }

                        I18nizableText generalError = new I18nizableText("plugin.cms", i18ngeneralkey, i18ngeneralparameters);
                        if (rootError == null)
                        {
                            rootError = generalError;
                        }
                        else
                        {
                            rootError.getParameterMap().put("2", generalError);
                        }
                    }
                    
                    parameters.put("3", rootError);
                }
                else
                {
                    if (e.getMessage() != null)
                    {
                        parameters.put("3", new I18nizableText(e.getMessage()));
                    }
                    else
                    {
                        parameters.put("3", new I18nizableText(e.getClass().getName()));
                    }
                }
                errorMessages.add(new I18nizableText("plugin.cms", "PLUGINS_CMS_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_EDIT", parameters));
                errorIds.add(content.getId());
            }
        }
    }
    
    /**
     * Resolve content by their identifiers
     * @param contentIds The id of contents to resolve
     * @return the contents
     */
    protected List<? extends Content> _resolve(List<String> contentIds)
    {
        List<Content> contents = new ArrayList<>();

        for (String contentId: contentIds)
        {
            Content content = _resolver.resolveById(contentId);
            contents.add(content);
        }
        
        return contents;
    }
    
    /**
     * Resolve content by their identifiers
     * @param contentIds The id of contents to resolve
     * @return the contents
     */
    protected Map<? extends Content, Integer> _resolve(Map<String, Integer> contentIds)
    {
        Map<Content, Integer> contents = new LinkedHashMap<>();
        
        for (Map.Entry<String, Integer> entry: contentIds.entrySet())
        {
            Content content = _resolver.resolveById(entry.getKey());
            contents.put(content, entry.getValue());
        }
        
        return contents;
    }
    
    private Collection<String> _getContentTypesIntersection(Collection<? extends Content> contents)
    {
        Collection<String> contentTypes = new ArrayList<>();
        for (Content content: contents)
        {
            Set<String> ancestorsAndMySelf = new HashSet<>();
            
            String[] allContentTypes = (String[]) ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());
            for (String id : allContentTypes)
            {
                ancestorsAndMySelf.addAll(_contentTypesHelper.getAncestors(id));
                ancestorsAndMySelf.add(id);
            }
            
            if (contentTypes.isEmpty())
            {
                contentTypes = ancestorsAndMySelf;
            }
            else
            {
                contentTypes = CollectionUtils.intersection(contentTypes, ancestorsAndMySelf);
            }
        }
        return contentTypes;
    }
}