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

import java.lang.reflect.Array;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.ContentSaxer;
import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.content.references.OutgoingReferencesExtractor;
import org.ametys.cms.contenttype.AttributeDefinition;
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.contenttype.ContentValidator;
import org.ametys.cms.data.ContentDataHelper;
import org.ametys.cms.data.ContentSynchronizationContext;
import org.ametys.cms.data.ContentSynchronizationResult;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.ReferencedContents;
import org.ametys.cms.data.holder.DataHolderDisableConditionsEvaluator;
import org.ametys.cms.model.restrictions.RestrictedModelItem;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.I18nUtils;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.data.DataComment;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.external.ExternalizableDataProviderExtensionPoint;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.Repeater;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
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.data.holder.values.SynchronizationResult;
import org.ametys.plugins.repository.data.holder.values.UntouchedValue;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.repository.model.RepositoryDataContext;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.plugins.workflow.EnhancedFunction;
import org.ametys.plugins.workflow.component.CheckRightsCondition;
import org.ametys.runtime.authentication.AccessDeniedException;
import org.ametys.runtime.config.Config;
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.ModelViewItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewHelper;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.ViewItemContainer;
import org.ametys.runtime.model.disableconditions.DisableConditions;
import org.ametys.runtime.model.disableconditions.DisableConditionsEvaluator;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.ValidationResult;
import org.ametys.runtime.parameter.ValidationResults;
import org.ametys.runtime.parameter.Validator;

import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.workflow.WorkflowException;

/**
 * OSWorkflow function to edit a content.<br>
 * <br>
 * Values are set either programmatically, or parsed from form submission by their {@link ElementType}s according to the {@link Content} model.<br>
 * <br>
 * The required transient variables:<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY - Map&lt;String, Object&gt; The map containing the results of the function.<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.result - String "true" when everything goes fine. Missing in other case.<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt; - Errors Each error during edition will be set here. Key will be the metadata path (with '.' separator). Value will be the error message.<br>
 * - AbstractContentWorkflowComponent.CONTENT_KEY - WorkflowAwareContent The content that will be edited. Should have the lock token.<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY - Map&lt;String, Object&gt; Contains the following parameters:<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.QUIT - boolean True to specify edition mode will be quit, this imply to unlock the content.<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.VIEW_PARAM The name of the view to use and to check attributes. If missing a view will be created from values. <br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FALLBACK_VIEW_PARAM The name of the view to use if the initial view does not exist on the Content's model. <br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.VALUES_KEY - Map&lt;String, Object&gt; The typed values. If present, raw values must not be present.<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_VALUES - Map&lt;String, Object&gt; The values of the submitted form. If present, types values must not be present.<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_VALUES.&lt;MetadataPath&gt; Object Key is the path of the metadata ('.' separated) prefixed by FORM_ELEMENTS_PREFIX. Value is a depending on the type of metadata.
 *                                                                                         Sometimes types require additional information. In that case : Key is a metadata path ('.' separated) prefixed by INTERNAL_FORM_ELEMENTS_PREFIX and suffixed by '.' + an additional information name.<br>
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_COMMENTS - Map&lt;String, List&lt;Map&lt;String, String&gt;&gt;&gt; The comments of the metadata of the submitted form :<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt; - List&lt;Map&lt;String, String&gt;&gt; Key is the path of the metadata ('.' separated) prefixed by FORM_ELEMENTS_PREFIX. Value is the list of comments.<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt;.&lt;X&gt; - &lt;Map&lt;String, String&gt; A comment with the following parameters<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt;.&lt;X&gt;.author String The login of the author of the comment<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt;.&lt;X&gt;.text String The text of the comment<br>
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.&lt;MetadataPath&gt;.&lt;X&gt;.date String The date of the comment using the ISODateTimeFormat (See DateUtils.parse)<br>
 * 
 * Where &lt;MetadataPath&gt; is the path of a metadata (using a '.' separator). In some cases it is prefixed by FORM_ELEMENTS_PREFIX. A metadata path with in a repeater include the number of the repeated instance (1 based).<br>
 * Where &lt;X&gt; Is an element of the parent list.<br>
 */
public class EditContentFunction extends AbstractContentWorkflowComponent implements EnhancedFunction, Initializable
{
    /** Constant for storing the action id for editing revert relations. */
    public static final String INVERT_RELATION_EDIT_WORKFLOW_ACTION_ID = EditContentFunction.class.getName() + "$invertEditActionId";
    
    /** Prefix for HTML form elements. */
    public static final String FORM_ELEMENTS_PREFIX = "content.input.";
    /** The key for global errors */
    public static final String GLOBAL_VALIDATION_RESULT_KEY = "_global";
    /** Prefix for internal HTML form elements. */
    public static final String INTERNAL_FORM_ELEMENTS_PREFIX = "_" + FORM_ELEMENTS_PREFIX;
    /** Inputs key for typed values. */
    public static final String VALUES_KEY = "typedValues";
    /** Request parameter key for the field values. */
    public static final String FORM_RAW_VALUES = "values";
    /** Request parameter key for the field comments. */
    public static final String FORM_RAW_COMMENTS = "comments";
    /** Request parameter key for the field with version. */
    public static final String FORM_RAW_VERSION = "_version";
    /** View parameter. */
    public static final String VIEW = "view";
    /** View items parameter. */
    public static final String VIEW_ITEMS = "view.items";
    /** View name parameter. */
    public static final String VIEW_NAME = "content.view";
    /** Fallback view name parameter. */
    public static final String FALLBACK_VIEW_NAME = "content.fallback.view";
    /** Set to <code>false</code> to deactivate global validation, default value is <code>true</code> */
    public static final String GLOBAL_VALIDATION = "content.validation.global";
    /** Set to <code>true</code> to ignore warnings and continue edition, default value is <code>true</code> */
    public static final String IGNORE_WARNINGS = "ignore.warnings";
    /** Quit edition mode parameter. */
    public static final String QUIT = "quit";
    /** Local only parameter. */
    public static final String LOCAL_ONLY = "local.only";
    /** Optional previous synchronization result */
    public static final String SYNCHRONIZATION_RESULT = "synchronization.result";
    /** Default action id of editing revert relations. */
    public static final int INVERT_EDIT_ACTION_ID = 2;
    /** Key for notify argument */
    public static final String KEY_NOTIFY_ARGUMENTS = "notify";
    
    /** Constant for storing the result's state (ok / warnings / errors) into the transient variables map. */
    public static final String RESULT_STATE_KEY = "result";
    /** Constant for the OK result's state */
    public static final String RESULT_STATE_OK = "ok";
    
    /** Constant for storing the field validation's result */
    public static final String VALIDATION_RESULTS_FIELD_RESULT_KEY = "fieldResult";
    /** Constant for storing the field's label */
    public static final String VALIDATION_RESULTS_FIELD_LABEL_KEY = "fieldLabel";
    /** Constant for storing the field's path */
    public static final String VALIDATION_RESULTS_FIELD_PATH_KEY = "fieldPath";
    
    /** Content type extension point. */
    protected ContentTypeExtensionPoint _contentTypeExtensionPoint;
    /** Helper for content types */
    protected ContentTypesHelper _contentTypesHelper;
    /** Observation manager available to subclasses. */
    protected ObservationManager _observationManager;
    /** The content workflow helper. */
    protected ContentWorkflowHelper _workflowHelper;
    /** The outgoing references extractor */
    protected OutgoingReferencesExtractor _outgoingReferencesExtractor;
    /** The user manager */
    protected UserManager _userManager;
    /** Provider for externalizable data */
    protected ExternalizableDataProviderExtensionPoint _externalizableDataProviderEP;
    /** Helper for collecting content references */
    protected ContentDataHelper _contentDataHelper;
    /** The {@link DisableConditions} evaluator */
    protected DisableConditionsEvaluator<ModelAwareDataHolder> _disableConditionsEvaluator;
    /** The i18n utils */
    protected I18nUtils _i18nUtils;
    

    @SuppressWarnings("unchecked")
    @Override
    public void initialize() throws Exception
    {
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) _manager.lookup(ContentTypeExtensionPoint.ROLE);
        _observationManager = (ObservationManager) _manager.lookup(ObservationManager.ROLE);
        _workflowHelper = (ContentWorkflowHelper) _manager.lookup(ContentWorkflowHelper.ROLE);
        _contentTypesHelper = (ContentTypesHelper) _manager.lookup(ContentTypesHelper.ROLE);
        _outgoingReferencesExtractor = (OutgoingReferencesExtractor) _manager.lookup(OutgoingReferencesExtractor.ROLE);
        _userManager = (UserManager) _manager.lookup(UserManager.ROLE);
        _externalizableDataProviderEP = (ExternalizableDataProviderExtensionPoint) _manager.lookup(ExternalizableDataProviderExtensionPoint.ROLE);
        _contentDataHelper = (ContentDataHelper) _manager.lookup(ContentDataHelper.ROLE);
        _disableConditionsEvaluator = (DisableConditionsEvaluator<ModelAwareDataHolder>) _manager.lookup(DataHolderDisableConditionsEvaluator.ROLE);
        _i18nUtils = (I18nUtils) _manager.lookup(I18nUtils.ROLE);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public void execute(Map transientVars, Map args, PropertySet ps) throws WorkflowException
    {
        _logger.info("Performing edit workflow function");

        // Retrieve current content
        WorkflowAwareContent content = getContent(transientVars);
        UserIdentity user = getUser(transientVars);
        
        if (!(content instanceof ModifiableContent))
        {
            throw new IllegalArgumentException("The provided content " + content.getId() + " is not a ModifiableContent.");
        }
        
        ModifiableContent modifiableContent = (ModifiableContent) content;
        
        try
        {
            LockableAmetysObject lockableContent = _checkLock(content, user);
            
            Map<String, Object> parameters = getContextParameters(transientVars);
            
            long time_0 = System.currentTimeMillis();
            
            // get inputs, either typed values (eg. set programmatically)
            // or raw values (eg. from request parameters)
            
            Map<String, Object> typedValues = (Map<String, Object>) parameters.get(VALUES_KEY);
            Map<String, Object> rawValues = (Map<String, Object>) parameters.get(FORM_RAW_VALUES);
            
            if (typedValues != null && rawValues != null)
            {
                throw new WorkflowException("Cannot have both typed values and raw values for EditContentFunction");
            }
            
            if (typedValues == null && rawValues == null)
            {
                typedValues = Collections.EMPTY_MAP;
            }
            
            // get the view, either set from inputs or computed from values
            View view = getView(parameters, typedValues, rawValues, modifiableContent, transientVars);
            
            long time_1 = System.currentTimeMillis();
            
            // get the attributes comments
            Map<String, List<Map<String, String>>> rawComments = (Map<String, List<Map<String, String>>>) parameters.get(FORM_RAW_COMMENTS);
            
            boolean localOnly = (boolean) parameters.getOrDefault(LOCAL_ONLY, false);
            
            // get values
            Map<String, Object> values = getValues(view, modifiableContent, typedValues, rawValues, rawComments, localOnly, transientVars);
            
            // validate values
            ValidationResults validationResults = validateValues(view, modifiableContent, values, transientVars);
            
            if ((boolean) parameters.getOrDefault(GLOBAL_VALIDATION, true))
            {
                validationResults.addResult(GLOBAL_VALIDATION_RESULT_KEY, globalValidate(view, modifiableContent, values));
            }

            _checkConcurrentModifications(validationResults, rawValues, content, view);

            Collection<ReferencedContents> referencedContents = null;
            if (!validationResults.hasErrors())
            {
                // prepare synchronize - compute referenced contents only if there is no error for now
                // FIXME CMS-10952: find external invert relations
                referencedContents = prepareSynchronize(modifiableContent, view, values, user, validationResults, transientVars);
            }

            // Put validation results (errors /warnings / infos) in result map
            _handleValidationResults(transientVars, validationResults, view);
            
            long time_2 = System.currentTimeMillis();
            
            // Notify the observers of the upcoming modification.
            notifyContentModifying(content, values, transientVars);
            
            // actually write changes
            SynchronizationResult synchronizationResult = synchronize(modifiableContent, view, values, referencedContents, transientVars);
            
            // Aggregate the synchronization result with the one in transient var if any
            synchronizationResult.aggregateResult((SynchronizationResult) parameters.getOrDefault(SYNCHRONIZATION_RESULT, new SynchronizationResult()));
            
            updateCommonMetadata(modifiableContent, user, synchronizationResult);
            
            extractOutgoingReferences(modifiableContent, synchronizationResult);
            
            long time_3 = System.currentTimeMillis();
            
            // Commit changes
            modifiableContent.saveChanges();
            
            long time_4 = System.currentTimeMillis();
            
            // Notify the observers of the modification.
            prepareOrNotifyContentModified(content, transientVars, args, synchronizationResult);
            
            long time_5 = System.currentTimeMillis();
            
            // Unlock content if we are not in save & quit mode
            Boolean quit = (Boolean) parameters.get(QUIT);
            if (Boolean.TRUE.equals(quit) && lockableContent != null && lockableContent.isLocked())
            {
                lockableContent.unlock();
            }
            
            long time_6 = System.currentTimeMillis();
            
            boolean logAbnormalTime = Config.getInstance().getValue("runtime.log.abnormal.time");
            if (time_6 - time_0 > 5000 && logAbnormalTime)
            {
                _logger.warn("Edit content action has taken an abnormally long time : get view in " + (time_1 - time_0) + " ms / bind attributes in " + (time_2 - time_1) + " ms / build consistencies in " + (time_3 - time_2) + " ms / save in " + (time_4 - time_3) + " / notify listeners in " + (time_5 - time_4) + " / total in " + (time_6 - time_0) + " ms");
            }
            else if (_logger.isDebugEnabled())
            {
                _logger.debug("Edit timers : get view in " + (time_1 - time_0) + " ms / bind attributes in " + (time_2 - time_1) + " ms / build consistencies in " + (time_3 - time_2) + " ms / save in " + (time_4 - time_3) + " / notify listeners in " + (time_5 - time_4) + " / total in " + (time_6 - time_0) + " ms");
            }
            
            Map<String, Object> resultsMap = getResultsMap(transientVars);
            resultsMap.put(RESULT_STATE_KEY, RESULT_STATE_OK);
            resultsMap.put(HAS_CHANGED_KEY, synchronizationResult.hasChanged());
        }
        catch (AmetysRepositoryException | AccessDeniedException e)
        {
            throw new WorkflowException("Unable to edit content " + modifiableContent + " from the repository", e);
        }
    }
    
    private void _checkConcurrentModifications(ValidationResults validationResults, Map<String, Object> rawValues, Content content, View view)
    {
        if (rawValues != null && rawValues.containsKey(FORM_ELEMENTS_PREFIX + FORM_RAW_VERSION))
        {
            String editedVersion = (String) rawValues.get(FORM_ELEMENTS_PREFIX + FORM_RAW_VERSION);
            String currentVersion = ContentSaxer.getEditionRevision((VersionableAmetysObject) content);
            if (StringUtils.isNotBlank(editedVersion) && !StringUtils.equals(editedVersion, currentVersion))
            {
                // WARN
                ValidationResult globalValidationResult = validationResults.getResults().computeIfAbsent(GLOBAL_VALIDATION_RESULT_KEY, key -> new ValidationResult());
                globalValidationResult.addWarning(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_VERSION_COLLISION", Map.of(
                        "old_version", new I18nizableText(_toReadableVersion(editedVersion)),
                        "new_version", new I18nizableText(_toReadableVersion(currentVersion)),
                        "compare_link", new I18nizableText("Ext.getCmp(Ext.fly(this).findParent('.ametys-dialogbox').id).close(); Ametys.tool.ToolsManager.openTool('uitool-diff-content', { id: '" + content.getId() + "', contentId: '" + content.getId() + "', baseVersion: '" + editedVersion + "', version: '" + currentVersion + "'" + (view.getName() != null ? ", 'view-name': '" + view.getName() + "'" : "") + ", 'allData': false });")
                )));
            }
        }
    }
    
    private String _toReadableVersion(String v)
    {
        return Integer.toString(Integer.parseInt(StringUtils.substringAfter(v, ".")) + 1);
    }
    
    private LockableAmetysObject _checkLock(Content content, UserIdentity user) throws WorkflowException
    {
        LockableAmetysObject lockableContent = null;
        
        if (content instanceof LockableAmetysObject)
        {
            lockableContent = (LockableAmetysObject) content;
            if (lockableContent.isLocked() && !LockHelper.isLockOwner(lockableContent, user))
            {
                throw new WorkflowException("User '" + user + "' try to save content '" + content.getName() + "' but it is locked by another user");
            }
        }
        
        return lockableContent;
    }
    
    private void _handleValidationResults(Map transientVars, ValidationResults validationResults, View view) throws WorkflowException, InvalidInputWorkflowException
    {
        Map<String, Object> result = getResultsMap(transientVars);

        for (Map.Entry<String, ValidationResult> entry : validationResults.getResults().entrySet())
        {
            ValidationResult fieldResult = entry.getValue();
            if (!fieldResult.isEmpty())
            {
                String dataPath = entry.getKey();
                String canonicalDataPath = StringUtils.replaceChars(dataPath, "/[]", "..");
                
                Map<String, Object> fieldData = new HashMap<>();
                fieldData.put(VALIDATION_RESULTS_FIELD_RESULT_KEY, fieldResult);
                
                if (!GLOBAL_VALIDATION_RESULT_KEY.equals(dataPath))
                {
                    fieldData.put(VALIDATION_RESULTS_FIELD_PATH_KEY, dataPath);
                    I18nizableText fieldFullLabel = _getFieldFullLabel(dataPath, view);
                    fieldData.put(VALIDATION_RESULTS_FIELD_LABEL_KEY, _i18nUtils.translate(fieldFullLabel));
                }
    
                result.put(canonicalDataPath, fieldData);
            }
        }

        if (_hasInvalidInput(transientVars, validationResults))
        {
            throw new InvalidInputWorkflowException("At least one validation error is preventing from saving the modifications", validationResults);
        }
    }
    
    private I18nizableText _getFieldFullLabel(String dataPath, View view)
    {
        String[] dataPathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        String viewItemPath = ModelHelper.getDefinitionPathFromDataPath(dataPath);
        ViewItem viewItem = ViewHelper.getModelViewItem(view, viewItemPath);
        
        I18nizableText result = Optional.ofNullable(viewItem.getLabel())
                                        .orElseGet(() -> new I18nizableText(viewItem.getName()));
        ViewItemAccessor parent = viewItem.getParent();
        
        int segmentIndexOfCurrentParentModelViewItem = dataPathSegments.length - 1;
        while (parent != null && parent instanceof ViewItem parentViewItem)
        {
            // Data path contains segments only for model view items
            if (parentViewItem instanceof ModelViewItem parentModelViewItem)
            {
                segmentIndexOfCurrentParentModelViewItem--;
            }
            
            Map<String, I18nizableTextParameter> i18nparameters = new HashMap<>();

            // Add parent label to parameters
            I18nizableText parentLabel = Optional.ofNullable(parentViewItem.getLabel())
                                                 .orElseGet(() -> new I18nizableText(parentViewItem.getName()));
            i18nparameters.put("0", parentLabel);
                
            // Add repeater position if needed
            String segmentOfCurrentParentModelViewItem = dataPathSegments[segmentIndexOfCurrentParentModelViewItem];
            if (DataHolderHelper.isRepeaterEntryPath(segmentOfCurrentParentModelViewItem))
            {
                Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(segmentOfCurrentParentModelViewItem);
                I18nizableText positionParameter = new I18nizableText(" (" + repeaterNameAndEntryPosition.getRight() + ")");
                i18nparameters.put("1", positionParameter);
            }
            
            i18nparameters.put("2", result);
            result = new I18nizableText("plugin.cms", "PLUGINS_CMS_VIEW_ITEM_PATH_CONCATENATION", i18nparameters);
            
            parent = parentViewItem.getParent();
        }
        
        return result;
    }
    
    private boolean _hasInvalidInput(Map transientVars, ValidationResults validationResults) throws WorkflowException
    {
        Map<String, Object> parameters = getContextParameters(transientVars);
        return validationResults.hasErrors()
                || validationResults.hasWarnings() && !((boolean) parameters.getOrDefault(IGNORE_WARNINGS, true));
    }
    
    /**
     * Get the identifier of the invert edit action
     * @param transientVars The workflow vars
     * @param referencedContent the content concerned by the invert relation
     * @return the identifier of the invert edit action
     */
    protected int getInvertEditActionId(Map transientVars, Content referencedContent)
    {
        return transientVars.containsKey(INVERT_RELATION_EDIT_WORKFLOW_ACTION_ID) ? (Integer) transientVars.get(INVERT_RELATION_EDIT_WORKFLOW_ACTION_ID) : INVERT_EDIT_ACTION_ID;
    }
    
    /**
     * Notify observers that the content is being modified
     * @param content The content being modified
     * @param values the new values being set to the content
     * @param transientVars The workflow vars
     * @throws WorkflowException If an error occurred
     */
    protected void notifyContentModifying(Content content, Map<String, Object> values, Map transientVars) throws WorkflowException
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        eventParams.put(ObservationConstants.ARGS_CONTENT_VALUES, values);
        
        _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFYING, getUser(transientVars), eventParams));
    }
    
    /**
     * Prepare or notify observers that the content has been modified
     * @param content The content modified
     * @param transientVars The workflow vars
     * @param args the workflow args
     * @param synchronizationResult The result of the content values synchronization
     * @throws WorkflowException If an error occurred
     */
    @SuppressWarnings("unchecked")
    protected void prepareOrNotifyContentModified(Content content, Map transientVars, Map args, SynchronizationResult synchronizationResult) throws WorkflowException
    {
        boolean notify = Boolean.parseBoolean((String) args.getOrDefault(KEY_NOTIFY_ARGUMENTS, "true"));
        if (notify)
        {
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_CONTENT, content);
            eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
            
            _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, getUser(transientVars), eventParams));
        }
        else // if notify is false, just prepare the event to send. A post notifyFunction will notify this event...
        {
            transientVars.put(AbstractContentFunction.EVENT_TO_NOTIFY_KEY, ObservationConstants.EVENT_CONTENT_MODIFIED);
        }
    }

    /**
     * Get the view for the content
     * @param parameters The parameters
     * @param values Typed values from inputs
     * @param rawValues The raw values of the form
     * @param content The content
     * @param transientVars the parameters from the call
     * @return The view asked in the request or a built-in view
     * @throws WorkflowException If an error occurred while getting the view
     */
    @SuppressWarnings("unchecked")
    protected View getView(Map<String, Object> parameters, Map<String, Object> values, Map<String, Object> rawValues, Content content, Map transientVars) throws WorkflowException
    {
        View view = (View) parameters.get(VIEW);
        if (view == null)
        {
            List<String> viewItems = (List<String>) parameters.get(VIEW_ITEMS);
            if (viewItems != null)
            {
                view = ViewHelper.createViewItemAccessor(content.getModel(), viewItems.toArray(String[]::new));
            }
            else
            {
                String viewName = (String) parameters.get(VIEW_NAME);
                String fallbackViewName = (String) parameters.get(FALLBACK_VIEW_NAME);
                if (viewName != null)
                {
                    view = _contentTypesHelper.getViewWithFallback(viewName, fallbackViewName, content.getTypes(), content.getMixinTypes());
                }
            }
        }

        if (view != null)
        {
            if (ViewHelper.areItemsPresentsOnlyOnce(view))
            {
                return ViewHelper.getTruncatedView(view);
            }
            else
            {
                throw new WorkflowException("The view '" + view.getName() + "' of content '" + content + "'cannot be used to edit the content because one or more items do not appear only once.");
            }
        }
        
        // Compute a view from input values
        Collection<? extends ModelItemContainer> model = content.getModel();
        if (values != null)
        {
            Map<String, Object> filteredValues = _filterWritableValues(values, model, content, transientVars);
            return (View) DataHolderHelper.createViewItemAccessorFromValues(model, filteredValues);
        }
        else
        {
            Set<String> allDataPaths = rawValues.keySet()
                                                .stream()
                                                .filter(path -> path.startsWith(FORM_ELEMENTS_PREFIX))
                                                .map(path -> path.substring(FORM_ELEMENTS_PREFIX.length()))
                                                .collect(Collectors.toSet());
            
            // Catch up removed repeaters
            rawValues.keySet()
                     .stream()
                     .filter(path -> path.startsWith(INTERNAL_FORM_ELEMENTS_PREFIX) && path.endsWith("/size"))
                     .map(path -> path.substring(INTERNAL_FORM_ELEMENTS_PREFIX.length()))
                     .map(path -> StringUtils.removeEnd(path, "/size"))
                     .forEach(allDataPaths::add);
            
            String[] itemPaths = allDataPaths.stream()
                                             .map(ModelHelper::getDefinitionPathFromDataPath)
                                             .toArray(String[]::new);
            
            return ViewHelper.createViewItemAccessor(model, itemPaths);
        }
    }
    
    @SuppressWarnings("unchecked")
    private Map<String, Object> _filterWritableValues(Map<String, Object> values, Collection<? extends ModelItemContainer> parent, Content content, Map transientVars)
    {
        Map<String, Object> filteredValues = new HashMap<>();
        
        for (String name : values.keySet())
        {
            ModelItem modelItem = ModelHelper.getModelItem(name, parent);
            if (_canWriteModelItem(modelItem, content, transientVars))
            {
                if (modelItem instanceof AttributeDefinition)
                {
                    filteredValues.put(name, values.get(name));
                }
                else if (modelItem instanceof CompositeDefinition compositeDefinition)
                {
                    Object value = values.get(name);
                    
                    if (!(value instanceof Map))
                    {
                        throw new IllegalArgumentException("CompositeDefinition should correspond to a Map<String, Object> value.");
                    }
                    
                    filteredValues.put(name, _filterWritableValues((Map<String, Object>) value, List.of(compositeDefinition), content, transientVars));
                }
                else if (modelItem instanceof RepeaterDefinition repeaterDefinition)
                {
                    Object value = values.get(name);
                    
                    if (!(value instanceof List) && !(value instanceof SynchronizableRepeater))
                    {
                        throw new IllegalArgumentException("RepeaterDefinition should correspond to a SynchronizableRepeater or List<Map<String, Object>> value.");
                    }
                    
                    List<Map<String, Object>> entries = value instanceof SynchronizableRepeater ? ((SynchronizableRepeater) value).getEntries() : (List<Map<String, Object>>) value;
                    List<Map<String, Object>> newEntries = new ArrayList<>();
                    
                    for (Map<String, Object> entry : entries)
                    {
                        newEntries.add(_filterWritableValues(entry, List.of(repeaterDefinition), content, transientVars));
                    }
                    
                    filteredValues.put(name, newEntries);
                }
            }
        }
        
        return filteredValues;
    }
    
    /**
     * Computes the actual typed values from the input.
     * @param view the current {@link View}
     * @param content the current Content
     * @param typedValues typed values, if any
     * @param rawValues raw values from form, if any
     * @param rawComments the form comments, if any
     * @param localOnly if the form values are local only or may include external values
     * @param transientVars the parameters from the call.
     * @return the actual values to be set
     * @throws WorkflowException If an error occurred
     */
    protected Map<String, Object> getValues(View view, ModifiableContent content, Map<String, Object> typedValues, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, boolean localOnly, Map transientVars) throws WorkflowException
    {
        Map<String, Object> values = typedValues;
        if (values == null)
        {
            values = _parseValues(view, StringUtils.EMPTY, Optional.of(StringUtils.EMPTY), content, rawValues, rawComments, localOnly, transientVars);
        }
        else
        {
            values = _convertValues(content, view, values, transientVars);
        }
        
        Map<String, Object> contextualParametersForDisableConditions = new HashMap<>();
        contextualParametersForDisableConditions.put(DataHolderDisableConditionsEvaluator.SYNCHRONIZATION_CONTEXT_PARAMETER_KEY, getSynchronizationContext(transientVars));
        values = processDisableConditions(view, content, values, contextualParametersForDisableConditions);
        
        return values;
    }

    @SuppressWarnings("unchecked")
    private Map<String, Object> _parseValues(ViewItemContainer viewItemContainer, String prefix, Optional<String> oldPrefix, ModifiableContent content, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, boolean localOnly, Map transientVars)
    {
        Map<String, Object> values = new HashMap<>();

        org.ametys.plugins.repository.model.ViewHelper.visitView(viewItemContainer,
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                ElementType type = definition.getType();
                
                Object value;
                if (!_canWriteModelItem(definition, content, transientVars))
                {
                    value = new UntouchedValue();
                }
                else
                {
                    String dataPath = prefix + name;
                    
                    // For the fromJSONForClient method, the context needs the path of the data as it is in the repository
                    // So we compute the old data path, i.e. with the repeater entries previous positions
                    Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
                    DataContext dataContext = RepositoryDataContext.newInstance()
                                                                   .withObject(content);
                    
                    // If the entry did not exist, the optional prefix is empty
                    if (oldDataPath.isPresent())
                    {
                        dataContext.withDataPath(oldDataPath.get());
                    }
                    
                    Object initialValue = rawValues.get(FORM_ELEMENTS_PREFIX + dataPath);
                    Object rawValue = initialValue;
                    ExternalizableDataStatus status = null;
                    Object externalValue = null;
                   
                    // if the value is externalizable, rawValue is actually a Map {local:<value>, external:<value>, status:<local or external>}
                    if (!localOnly && _externalizableDataProviderEP.isDataExternalizable(content, definition))
                    {
                        Map<String, Object> externalizableValue = (Map<String, Object>) initialValue;
                        
                        status = ExternalizableDataStatus.valueOf(((String) externalizableValue.get("status")).toUpperCase());
                        rawValue = externalizableValue.get("local");
                        
                        Object rawExternalValue = externalizableValue.get("external");
                        externalValue = type.fromJSONForClient(rawExternalValue, dataContext);
                    }
                    
                    // get the typed value
                    Object typedValue = type.fromJSONForClient(rawValue, dataContext);
                    
                    // retrieve the associated comments
                    List<Map<String, String>> comments = rawComments == null ? null : rawComments.get(FORM_ELEMENTS_PREFIX + prefix + name);
                    
                    value = _getSynchronizableValue(typedValue, status, externalValue, comments);
                }
                
                values.put(name, value);
            },
            (group, definition) -> {
                // composite
                String name = definition.getName();
                String updatedPrefix = prefix + name + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> updatedOldPrefix = oldPrefix.map(p -> p + name + ModelItem.ITEM_PATH_SEPARATOR);
                values.put(name, _parseValues(group, updatedPrefix, updatedOldPrefix, content, rawValues, rawComments, localOnly, transientVars));
            },
            (group, definition) -> {
                // repeater
                String name = definition.getName();

                if (!_canWriteModelItem(definition, content, transientVars))
                {
                    values.put(name, new UntouchedValue());
                }
                else
                {
                    int size = (int) rawValues.get(INTERNAL_FORM_ELEMENTS_PREFIX + prefix + name + "/size");
                    
                    List<Map<String, Object>> entries = new ArrayList<>();
                    Map<Integer, Integer> mapping = new HashMap<>();
                    for (int i = 1; i <= size; i++)
                    {
                        String updatedPrefix = prefix + name + "[" + i + "]" + ModelItem.ITEM_PATH_SEPARATOR;
                        Optional<String> updatedOldPrefix = Optional.empty();
                        int previousPosition = (int) rawValues.get(INTERNAL_FORM_ELEMENTS_PREFIX + prefix + name + "[" + i + "]/previous-position");
                        if (previousPosition > 0)
                        {
                            updatedOldPrefix = oldPrefix.map(p -> p + name + "[" + previousPosition + "]" + ModelItem.ITEM_PATH_SEPARATOR);
                            mapping.put(previousPosition, i);
                        }
    
                        entries.add(_parseValues(group, updatedPrefix, updatedOldPrefix, content, rawValues, rawComments, localOnly, transientVars));
                    }
                    
                    values.put(name, SynchronizableRepeater.replaceAll(entries, mapping));
                }

            },
            group -> values.putAll(_parseValues(group, prefix, oldPrefix, content, rawValues, rawComments, localOnly, transientVars)));
        
        return values;
    }
    
    private Object _getSynchronizableValue(Object localValue, ExternalizableDataStatus status, Object externalValue, List<Map<String, String>> rawComments)
    {
        SynchronizableValue result = new SynchronizableValue(localValue);
        result.setExternalizableStatus(status != null ? status : ExternalizableDataStatus.LOCAL);
        result.setExternalValue(externalValue);
        
        if (rawComments != null)
        {
            List<DataComment> comments = new ArrayList<>();
            
            for (Map<String, String> rawComment : rawComments)
            {
                String author = rawComment.get("author");
                String text = rawComment.get("text");
                String rawDate = rawComment.get("date");
                
                DataComment comment = new DataComment(text, DateUtils.parseZonedDateTime(rawDate), author);
                
                comments.add(comment);
            }
            
            result.setComments(comments);
        }
        
        return result;
    }
    
    /**
     * Converts the given values according to the definitions in the given {@link ViewItemAccessor}
     * @param content the current content
     * @param view the current view
     * @param values the values to convert
     * @param transientVars the parameters from the call
     * @return the converted values
     */
    protected Map<String, Object> _convertValues(ModifiableContent content, View view, Map<String, Object> values, Map transientVars)
    {
        return DataHolderHelper.convertValuesWithSynchronizableValues(view, values, DataHolderHelper::convertValue, Optional.empty());
    }
    
    /**
     * Processes disable conditions on given values
     * @param view the current view
     * @param content the current content
     * @param values the values to process
     * @param contextualParameters the contextual parameters
     * @return the values with {@link UntouchedValue}s for instead of disabled ones
     */
    protected Map<String, Object> processDisableConditions(View view, ModifiableContent content, Map<String, Object> values, Map<String, Object> contextualParameters)
    {
        return _processDisableConditions(view, StringUtils.EMPTY, Optional.of(StringUtils.EMPTY), content, values, values, contextualParameters);
    }
    
    private Map<String, Object> _processDisableConditions(ViewItemContainer viewItemContainer, String prefix, Optional<String> oldPrefix, ModifiableContent content, Map<String, Object> currentValues, Map<String, Object> allValues, Map<String, Object> contextualParameters)
    {
        Map<String, Object> values = new HashMap<>();
        
        org.ametys.plugins.repository.model.ViewHelper.visitView(viewItemContainer,
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                processDisableConditionsOnElement(definition, prefix, oldPrefix, content, currentValues, allValues, contextualParameters)
                    .ifPresent(v -> values.put(name, v));
            },
            (group, definition) -> {
                // composite
                String name = definition.getName();
                processDisableConditionsOnComposite(group, definition, prefix, oldPrefix, content, currentValues, allValues, contextualParameters)
                    .ifPresent(v -> values.put(name, v));
            },
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                processDisableConditionsOnRepeater(group, definition, prefix, oldPrefix, content, currentValues, allValues, contextualParameters)
                    .ifPresent(v -> values.put(name, v));
            },
            group -> {
                // group
                values.putAll(_processDisableConditions(group, prefix, oldPrefix, content, currentValues, allValues, contextualParameters));
            }
        );
        
        return values;
    }
    
    /**
     * Processes disable conditions on given element
     * @param definition the element's definition
     * @param prefix the prefix for computing current data path
     * @param oldPrefix the prefix for computing old data path
     * @param content the current content
     * @param currentValues the values to process
     * @param allValues all values of the current edition
     * @param contextualParameters the contextual parameters
     * @return the values of the element, or {@link UntouchedValue} if disabled
     */
    protected Optional<Object> processDisableConditionsOnElement(ElementDefinition definition, String prefix, Optional<String> oldPrefix, ModifiableContent content, Map<String, Object> currentValues, Map<String, Object> allValues, Map<String, Object> contextualParameters)
    {
        String name = definition.getName();
        String dataPath = prefix + name;
        Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
        Object value = currentValues.get(name);

        return currentValues.containsKey(name) && value instanceof UntouchedValue // value exists in map but is untouched
                ? Optional.of(value)
                : _disableConditionsEvaluator.evaluateDisableConditions(definition, dataPath, oldDataPath, allValues, content, contextualParameters) // evaluate disable conditions, even if value does not exist in map
                    ? Optional.of(new UntouchedValue())
                    : currentValues.containsKey(name)
                        ? Optional.of(value)
                        : Optional.empty();
    }
    
    /**
     * Processes disable conditions on given composite
     * @param group the composite's view item
     * @param definition the composite's definition
     * @param prefix the prefix for computing current data path
     * @param oldPrefix the prefix for computing old data path
     * @param content the current content
     * @param currentValues the values to process
     * @param allValues all values of the current edition
     * @param contextualParameters the contextual parameters
     * @return the values of the composite, or {@link UntouchedValue} if disabled
     */
    protected Optional<Object> processDisableConditionsOnComposite(ModelViewItemGroup group, CompositeDefinition definition, String prefix, Optional<String> oldPrefix, ModifiableContent content, Map<String, Object> currentValues, Map<String, Object> allValues, Map<String, Object> contextualParameters)
    {
        String name = definition.getName();
        String dataPath = prefix + name;
        Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
        Object value = currentValues.get(name);

        if (currentValues.containsKey(name) && value instanceof UntouchedValue)
        {
            return Optional.of(value);
        }
        else if (_disableConditionsEvaluator.evaluateDisableConditions(definition, dataPath, oldDataPath, allValues, content, contextualParameters))
        {
            return Optional.of(new UntouchedValue());
        }
        else if (value instanceof Map)
        {
            String updatedPrefix = dataPath + ModelItem.ITEM_PATH_SEPARATOR;
            Optional<String> updatedOldPrefix = oldDataPath.map(p -> p + ModelItem.ITEM_PATH_SEPARATOR);
            
            @SuppressWarnings("unchecked")
            Map<String, Object> compositeValues = (Map<String, Object>) value;
            return Optional.of(_processDisableConditions(group, updatedPrefix, updatedOldPrefix, content, compositeValues, allValues, contextualParameters));
        }
        else
        {
            return Optional.empty();
        }
    }
    
    /**
     * Processes disable conditions on given repeater
     * @param group the repeater's view item
     * @param definition the repeater's definition
     * @param prefix the prefix for computing current data path
     * @param oldPrefix the prefix for computing old data path
     * @param content the current content
     * @param currentValues the values to process
     * @param allValues all values of the current edition
     * @param contextualParameters the contextual parameters
     * @return the values of the repeater, or {@link UntouchedValue} if disabled
     */
    protected Optional<Object> processDisableConditionsOnRepeater(ModelViewItemGroup group, RepeaterDefinition definition, String prefix, Optional<String> oldPrefix, ModifiableContent content, Map<String, Object> currentValues, Map<String, Object> allValues, Map<String, Object> contextualParameters)
    {
        String name = definition.getName();
        String dataPath = prefix + name;
        Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
        Object value = currentValues.get(name);

        if (currentValues.containsKey(name) && value instanceof UntouchedValue)
        {
            return Optional.of(value);
        }
        else if (_disableConditionsEvaluator.evaluateDisableConditions(definition, dataPath, oldDataPath, allValues, content, contextualParameters))
        {
            return Optional.of(new UntouchedValue());
        }
        else if (value instanceof List)
        {
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> currentEntries = (List<Map<String, Object>>) value;
            List<Map<String, Object>> entries = new ArrayList<>();

            for (int i = 0; i < currentEntries.size(); i++)
            {
                Map<String, Object> currentEntry = currentEntries.get(i);

                String entryPrefix = dataPath + "[" + (i + 1)  + "]" + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> entryOldPrefix = _getRepeaterEntryOldPrefix(oldDataPath, value, i + 1);

                entries.add(_processDisableConditions(group, entryPrefix, entryOldPrefix, content, currentEntry, allValues, contextualParameters));
            }

            return Optional.of(entries);
        }
        else if (value instanceof SynchronizableRepeater syncRepeater)
        {
            List<Map<String, Object>> currentEntries = syncRepeater.getEntries();

            for (int i = 0; i < currentEntries.size(); i++)
            {
                Map<String, Object> currentEntry = currentEntries.get(i);

                int entryPosition = i + 1;
                if (syncRepeater.getMode() == SynchronizableRepeater.Mode.REPLACE)
                {
                    entryPosition = syncRepeater.getReplacePositions().get(i);
                }
                else if (syncRepeater.getMode() == SynchronizableRepeater.Mode.APPEND)
                {
                    Repeater repeater = oldDataPath.map(path -> content.getRepeater(path)).orElse(null);
                    if (repeater != null)
                    {
                        entryPosition += repeater.getSize() - syncRepeater.getRemovedEntries().size();
                    }
                }

                String entryPrefix = dataPath + "[" + entryPosition  + "]" + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> entryOldPrefix = _getRepeaterEntryOldPrefix(oldDataPath, value, entryPosition);

                currentEntry.putAll(_processDisableConditions(group, entryPrefix, entryOldPrefix, content, currentEntry, allValues, contextualParameters));
            }

            return Optional.of(syncRepeater);
        }
        else
        {
            return Optional.empty();
        }
    }
    
    /**
     * Validates all input values.
     * @param view the model's view corresponding to the values
     * @param content the current content
     * @param values the actual input values
     * @param transientVars the parameters from the call
     * @return the validation results
     * @throws WorkflowException If an error occurred
     */
    protected ValidationResults validateValues(View view, ModifiableContent content, Map<String, Object> values, Map transientVars) throws WorkflowException
    {
        return _validateValues(view, StringUtils.EMPTY, Optional.of(StringUtils.EMPTY), content, Optional.of(values), transientVars);
    }

    private ValidationResults _validateValues(ViewItemContainer viewItemContainer, String prefix, Optional<String> oldPrefix, ModifiableContent content, Optional<Map<String, Object>> values, Map transientVars)
    {
        ValidationResults results = new ValidationResults();
        
        org.ametys.plugins.repository.model.ViewHelper.visitView(viewItemContainer,
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                
                String dataPath = prefix + name;
                Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
                
                Object value = values.map(v -> v.get(name)).orElse(null);
                results.addResult(dataPath, validateValue(definition, dataPath, oldDataPath, content, value, transientVars));
            },
            (group, definition) -> {
                // composite
                String name = definition.getName();

                String updatedPrefix = prefix + name + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> updatedOldPrefix = oldPrefix.map(p -> p + name + ModelItem.ITEM_PATH_SEPARATOR);
                
                Optional<Map<String, Object>> value = values.map(v -> v.get(name)).filter(Map.class::isInstance).map(Map.class::cast);
                results.addResults(_validateValues(group, updatedPrefix, updatedOldPrefix, content, value, transientVars));
            },
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                
                String dataPath = prefix + name;
                Optional<String> oldDataPath = oldPrefix.map(p -> p + name);
                
                Object value = values.map(v -> v.get(name)).orElse(null);
                results.addResults(validateRepeaterValue(group, definition, dataPath, oldDataPath, content, value, transientVars));
            },
            group -> results.addResults(_validateValues(group, prefix, oldPrefix, content, values, transientVars)));
        
        return results;
    }
    
    /**
     * Validate an attribute value.
     * @param definition the attribute definition.
     * @param dataPath the attribute path.
     * @param oldDataPath the old data path, i.e. with the repeater entries previous positions. Used to know the current status for externalizable data
     * @param content the Content being edited.
     * @param value the value.
     * @param transientVars the parameters from the call.
     * @return the validation result
     */
    protected ValidationResult validateValue(ElementDefinition definition, String dataPath, Optional<String> oldDataPath, ModifiableContent content, Object value, Map transientVars)
    {
        Object actualValue = DataHolderHelper.getValueFromSynchronizableValue(value, content, definition, oldDataPath, getSynchronizationContext(transientVars));
        Mode mode = value instanceof SynchronizableValue ? ((SynchronizableValue) value).getMode() : Mode.REPLACE;

        if (actualValue instanceof UntouchedValue)
        {
            // don't validate UntouchedValue, either they correspond to non-writable or previously stored data
            return ValidationResult.empty();
        }

        if (!_canWriteModelItem(definition, content, transientVars))
        {
            throw new EditContentAccessDeniedException(content, definition);
        }
        
        Validator validator = definition.getValidator();
        Object valueToValidate = actualValue;
        if (validator != null && validator.getClass().isAnnotationPresent(NeedAllValues.class))
        {
            if (definition.isMultiple())
            {
                // the validator need all attribute values
                Object[] oldValuesArray = content.getValue(dataPath);
                Object[] newValuesArray = (Object[]) actualValue;
                valueToValidate = mode == Mode.REPLACE ? actualValue : mode == Mode.APPEND ? ArrayUtils.addAll(oldValuesArray, newValuesArray) : CollectionUtils.disjunction(Arrays.asList(oldValuesArray), Arrays.asList(newValuesArray)).toArray(i -> (Object[]) Array.newInstance(definition.getType().getManagedClass(), i));
            }
            else
            {
                valueToValidate = mode != Mode.REMOVE ? actualValue : null;
            }
        }

        return ModelHelper.validateValue(definition, valueToValidate);
    }

    /**
     * Validate repeater values.
     * @param viewItem the view item referencing the repeater
     * @param definition the repeater definition.
     * @param dataPath the repeater path.
     * @param oldDataPath the old repeater data path, i.e. with the repeater entries previous positions. Used to know the current status for externalizable data
     * @param content the Content being edited.
     * @param value the value.
     * @param transientVars the parameters from the call.
     * @return the validation results
     */
    @SuppressWarnings("unchecked")
    protected ValidationResults validateRepeaterValue(ModelViewItemGroup viewItem, RepeaterDefinition definition, String dataPath, Optional<String> oldDataPath, ModifiableContent content, Object value, Map transientVars)
    {
        if (value instanceof UntouchedValue)
        {
            // don't validate UntouchedValue, either they correspond to non-writable or previously stored data
            return new ValidationResults();
        }

        if (!_canWriteModelItem(definition, content, transientVars))
        {
            throw new EditContentAccessDeniedException(content, definition);
        }
                
        List<Map<String, Object>> entries = value == null ? null : value instanceof List ? (List<Map<String, Object>>) value : ((SynchronizableRepeater) value).getEntries();
        SynchronizableRepeater.Mode mode = value instanceof SynchronizableRepeater ? ((SynchronizableRepeater) value).getMode() : SynchronizableRepeater.Mode.REPLACE_ALL;
        
        int oldRepeaterSize = 0;
        if (mode != SynchronizableRepeater.Mode.REPLACE_ALL)
        {
            Repeater repeater = oldDataPath.map(path -> content.getRepeater(path)).orElse(null);
            if (repeater != null)
            {
                oldRepeaterSize = repeater.getSize();
            }
        }
        
        int repeaterSize = entries != null ? entries.size() : 0;
        
        if (mode == SynchronizableRepeater.Mode.APPEND)
        {
            SynchronizableRepeater repeater = (SynchronizableRepeater) value;
            assert repeater != null;
            repeaterSize = oldRepeaterSize + repeaterSize - repeater.getRemovedEntries().size();
        }
        else if (mode == SynchronizableRepeater.Mode.REPLACE)
        {
            repeaterSize = oldRepeaterSize;
        }
        
        ValidationResults results = new ValidationResults();
        results.addResult(dataPath, _validateRepeaterSize(definition, repeaterSize));
        
        if (entries != null)
        {
            for (int i = 0; i < entries.size(); i++)
            {
                Map<String, Object> entry = entries.get(i);
                String prefix = dataPath + "[" + (i + 1)  + "]" + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> oldPrefix = _getRepeaterEntryOldPrefix(oldDataPath, value, i + 1);
                results.addResults(_validateValues(viewItem, prefix, oldPrefix, content, Optional.of(entry), transientVars));
            }
        }
        
        return results;
    }

    private ValidationResult _validateRepeaterSize(RepeaterDefinition definition, int repeaterSize)
    {
        ValidationResult result = new ValidationResult();

        int minSize = definition.getMinSize();
        int maxSize = definition.getMaxSize();
        
        if (repeaterSize < minSize)
        {
            List<String> parameters = new ArrayList<>();
            parameters.add(definition.getName());
            parameters.add(Integer.toString(minSize));
            result.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_REPEATER_MINSIZE", parameters));
        }

        if (maxSize > 0 && repeaterSize > maxSize)
        {
            List<String> parameters = new ArrayList<>();
            parameters.add(definition.getName());
            parameters.add(Integer.toString(maxSize));
            result.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_REPEATER_MAXSIZE", parameters));
        }
        
        return result;
    }
    
    private Optional<String> _getRepeaterEntryOldPrefix(Optional<String> oldDataPath, Object value, int currentPosition)
    {
        Optional<String> oldPrefix = Optional.empty();
        if (value instanceof SynchronizableRepeater)
        {
            Optional<Integer> previousPosition = ((SynchronizableRepeater) value).getPreviousPosition(currentPosition);
            if (previousPosition.isPresent())
            {
                oldPrefix = oldDataPath.map(path -> path + "[" + previousPosition.get()  + "]" + ModelItem.ITEM_PATH_SEPARATOR);
            }
        }
        return oldPrefix;
    }
    
    /**
     * Performs a global validation of the Content, based on declared {@link ContentValidator}s.
     * @param view the current {@link View}
     * @param content the current {@link Content}.
     * @param values the values being set
     * @return the validation results
     */
    protected ValidationResult globalValidate(View view, Content content, Map<String, Object> values)
    {
        ValidationResult result = new ValidationResult();
        
        String[] allContentTypes = ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());
        for (String cTypeId : allContentTypes)
        {
            ContentType contentType = _contentTypeExtensionPoint.getExtension(cTypeId);
            
            for (ContentValidator validator : contentType.getGlobalValidators())
            {
                result.addResult(validator.validate(content, values, view));
            }
        }
        
        return result;
    }
    
    /**
     * Prepares the write process by checking remote contents concerned by invert relations.
     * @param content the current content.
     * @param view the current View.
     * @param values the new values.
     * @param user the current user
     * @param validationResults the collected errors
     * @param transientVars the parameters from the call.
     * @return the {@link ReferencedContents}
     */
    protected Collection<ReferencedContents> prepareSynchronize(ModifiableContent content, View view, Map<String, Object> values, UserIdentity user, ValidationResults validationResults, Map transientVars)
    {
        if (!invertRelationEnabled())
        {
            return null;
        }
        
        Collection<ReferencedContents> referencedContents = _contentDataHelper.collectReferencedContents(view, content, values, getSynchronizationContext(transientVars));
        
        Map<ContentValue, Pair<Boolean, String>> refContents = new HashMap<>();
        
        // "flatten" the data, so that we only lock each content once
        // for each ref content, we only keep the first dataPath (for error reporting) and the weakest value for forceInvert (ie. false if any)
        for (ReferencedContents referencedContent : referencedContents)
        {
            ContentAttributeDefinition definition = referencedContent.getDefinition();
            boolean forceInvert = definition.getForceInvert();
            
            _flattenCollectedReferencedContents(referencedContent.getAddedContentsWithPaths(), refContents, forceInvert);
            _flattenCollectedReferencedContents(referencedContent.getRemovedContentsWithPaths(), refContents, forceInvert);
        }
        
        for (Entry<ContentValue, Pair<Boolean, String>> value : refContents.entrySet())
        {
            ContentValue refContentValue = value.getKey();
            ModifiableContent refContent = refContentValue.getContentIfExists().orElse(null);
            
            if (refContent != null)
            {
                // Check if edit action is available on referenced contents
                int invertEditActionId = getInvertEditActionId(transientVars, refContent);
                Optional<I18nizableText> errorLabel = _checkEditRefContentAvailability(invertEditActionId, refContent, value.getValue().getLeft(), user);
                if (errorLabel.isEmpty())
                {
                    if (refContent instanceof LockableAmetysObject && !((LockableAmetysObject) refContent).isLocked())
                    {
                        // Get lock on referenced content
                        ((LockableAmetysObject) refContent).lock();
                    }
                }
                else
                {
                    ValidationResult result = new ValidationResult();
                    result.addError(errorLabel.get());
                    validationResults.addResult(value.getValue().getRight(), result);
                }
            }
        }
        
        return referencedContents;
    }
    
    private void _flattenCollectedReferencedContents(Map<ContentValue, List<String>> references, Map<ContentValue, Pair<Boolean, String>> refContents, boolean forceInvert)
    {
        for (Entry<ContentValue, List<String>> value : references.entrySet())
        {
            ContentValue refContentValue = value.getKey();
            List<String> dataPaths = value.getValue();
            
            Pair<Boolean, String> invertData = refContents.get(refContentValue);
            if (invertData == null)
            {
                String firstData = dataPaths.isEmpty() ? "" : dataPaths.get(0);
                refContents.put(refContentValue, Pair.of(forceInvert, firstData));
            }
            else if (!forceInvert && invertData.getLeft())
            {
                String firstData = dataPaths.isEmpty() ? "" : dataPaths.get(0);
                refContents.put(refContentValue, Pair.of(forceInvert, firstData));
            }
        }
    }
    
    private Optional<I18nizableText> _checkEditRefContentAvailability(int editActionId, Content refContent, boolean forceInvert, UserIdentity user)
    {
        if (refContent instanceof WorkflowAwareContent)
        {
            Map<String, Object> inputs = new HashMap<>();
            if (forceInvert)
            {
                // do not check user's right
                inputs.put(CheckRightsCondition.FORCE, true);
            }
            
            int[] availableActions = _workflowHelper.getAvailableActions((WorkflowAwareContent) refContent, inputs);
            if (!ArrayUtils.contains(availableActions, editActionId))
            {
                Map<String, I18nizableTextParameter> params = new HashMap<>();
                
                // Check lock
                if (refContent instanceof LockableAmetysObject)
                {
                    LockableAmetysObject lockableContent = (LockableAmetysObject) refContent;
                    if (lockableContent.isLocked() && !LockHelper.isLockOwner(lockableContent, user))
                    {
                        User lockOwner = _userManager.getUser(lockableContent.getLockOwner().getPopulationId(), lockableContent.getLockOwner().getLogin());
                        
                        params.put("content", new I18nizableText(_contentHelper.getTitle(refContent)));
                        params.put("lockOwner", new I18nizableText(lockOwner != null ? lockOwner.getFullName() + " (" + lockOwner.getIdentity().getLogin() + ")" : lockableContent.getLockOwner().getLogin()));
                        return Optional.of(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_REFERENCED_CONTENT_LOCKED", params));
                    }
                }
                
                // Action in unavailable
                params.put("content", new I18nizableText(_contentHelper.getTitle(refContent)));
                return Optional.of(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_UNAVAILABLE_ACTION", params));
            }
            else
            {
                return Optional.empty();
            }
        }
        else
        {
            Map<String, I18nizableTextParameter> params = new HashMap<>();
            params.put("content", new I18nizableText(_contentHelper.getTitle(refContent)));
            return Optional.of(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_NOWORKFLOWAWARE_CONTENT", params));
        }
    }
    
    /**
     * Synchronize the values of the given content
     * @param content the content to synchronize
     * @param view the content's view to use for synchronization
     * @param values the values to synchronize
     * @param referencedContents the contents referenced by invert relations
     * @param transientVars the parameters from the call.
     * @return The result of the synchronization
     * @throws WorkflowException if an error occurs while triggering the edition workflow action for related contents
     */
    protected SynchronizationResult synchronize(ModifiableContent content, View view, Map<String, Object> values, Collection<ReferencedContents> referencedContents, Map transientVars) throws WorkflowException
    {
        ContentSynchronizationContext context = getSynchronizationContext(transientVars)
                .withInvertRelations(invertRelationEnabled())
                .withReferencedContents(referencedContents);
        
        ContentSynchronizationResult synchronizationResult = content.synchronizeValues(view, values, context);
        
        ContentSynchronizationResult additionalOperationsResult = additionalOperations(content, transientVars);
        synchronizationResult.aggregateResult(additionalOperationsResult);
        
        // trigger edit workflow action on contents modified due to invert relations
        for (ModifiableContent refContent : synchronizationResult.getModifiedContents())
        {
            refContent.saveChanges();
            int invertEditActionId = getInvertEditActionId(transientVars, refContent);
            triggerInvertWorkflowAction(refContent, invertEditActionId);
        }
        
        
        return synchronizationResult;
    }

    /**
     * Retrieves the synchronization context
     * @param transientVars the parameters from the call
     * @return the synchronization context
     */
    protected ContentSynchronizationContext getSynchronizationContext(Map transientVars)
    {
        return ContentSynchronizationContext.newInstance();
    }
    
    /**
     * Allow to do some other modifications on the given content before saving changes
     * @param content the content
     * @param transientVars the parameters from the call
     * @return The synchronization result of additional operations
     * @throws WorkflowException If an error occurred
     */
    protected ContentSynchronizationResult additionalOperations(ModifiableContent content, Map transientVars) throws WorkflowException
    {
        // do nothing by default
        return new ContentSynchronizationResult();
    }
    
    /**
     * Updates common metadata (last contributor, last modification date, ...).
     * @param content the content.
     * @param user the user.
     * @param synchronizationResult The result of the content values synchronization
     * @throws WorkflowException if an error occurs.
     */
    protected void updateCommonMetadata(ModifiableContent content, UserIdentity user, SynchronizationResult synchronizationResult) throws WorkflowException
    {
        if (user != null)
        {
            content.setLastContributor(user);
        }
        
        content.setLastModified(ZonedDateTime.now());
        
        if (content instanceof WorkflowAwareContent)
        {
            // Remove the proposal date.
            ((WorkflowAwareContent) content).setProposalDate(null);
        }
    }

    /**
     * Analyze the content to extract outgoing references and store them
     * @param content The content to analyze
     * @param synchronizationResult The result of the content values synchronization
     */
    protected void extractOutgoingReferences(ModifiableContent content, SynchronizationResult synchronizationResult)
    {
        Map<String, OutgoingReferences> outgoingReferencesByPath = _outgoingReferencesExtractor.getOutgoingReferences(content);
        content.setOutgoingReferences(outgoingReferencesByPath);
    }
    
    /**
     * Template method to indicates if invert relation should be taken into account during the whole edition.
     * Override and return false to disabled invert relation management.
     * @return true if invert relation are enabled
     */
    protected boolean invertRelationEnabled()
    {
        return true;
    }
    
    /**
     * Trigger a 'edit content' workflow action (if the content is workflow-aware).
     * @param content The content.
     * @param actionId The current 'edit content' action ID.
     * @throws WorkflowException if an error occurs.
     */
    protected void triggerInvertWorkflowAction(Content content, int actionId) throws WorkflowException
    {
        if (content instanceof WorkflowAwareContent)
        {
            // The content has already been modified by this function
            SynchronizationResult synchronizationResult = new SynchronizationResult();
            synchronizationResult.setHasChanged(true);

            Map<String, Object> parameters = new HashMap<>();
            parameters.put(ValidateContentFunction.IS_MAJOR, false);
            parameters.put(SYNCHRONIZATION_RESULT, synchronizationResult);
            parameters.put(QUIT, true);

            Map<String, Object> inputs = new HashMap<>();
            inputs.put(CONTEXT_PARAMETERS_KEY, parameters);
            
            // Do action regarless of user's rights because user's rights was already checked during preparing process
            // This is necessary because the removal of a invert relation could removed the user rights in a referenced content, whereas user has authorized to edit the content before this removal
            inputs.put(CheckRightsCondition.FORCE, true);
            
            _workflowHelper.doAction((WorkflowAwareContent) content, actionId, inputs);
        }
    }

    /**
     * Returns <code>true</code> if the current model item is writable for this content in the current context.
     * @param modelItem The model item to check
     * @param content The content
     * @param transientVars The parameters from the call
     * @return <code>true</code> if the current model item is writable
     */
    @SuppressWarnings("unchecked")
    protected boolean _canWriteModelItem(ModelItem modelItem, Content content, Map transientVars)
    {
        return !(modelItem instanceof RestrictedModelItem) || ((RestrictedModelItem) modelItem).canWrite(content);
    }
    
    @Override
    public FunctionType getFunctionExecType()
    {
        return FunctionType.PRE;
    }
    
    @Override
    public I18nizableText getLabel()
    {
        return new I18nizableText("plugin.cms", "PLUGINS_CMS_EDIT_CONTENT_FUNCTION_LABEL");
    }
}