/*
 *  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.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TreeMap;

import javax.jcr.AccessDeniedException;
import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;
import javax.jcr.Value;
import javax.jcr.ValueFactory;
import javax.jcr.ValueFormatException;
import javax.jcr.lock.Lock;
import javax.jcr.lock.LockException;
import javax.jcr.lock.LockManager;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.version.VersionException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.comparators.ReverseComparator;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.content.external.ExternalizableMetadataProvider.ExternalizableMetadataStatus;
import org.ametys.cms.content.external.ExternalizableMetadataProviderExtensionPoint;
import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.content.references.OutgoingReferencesExtractor;
import org.ametys.cms.contenttype.AbstractMetadataSetElement;
import org.ametys.cms.contenttype.ContentConstants;
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.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataDefinitionReference;
import org.ametys.cms.contenttype.MetadataSet;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.form.AbstractField;
import org.ametys.cms.form.AbstractField.MODE;
import org.ametys.cms.form.BinaryField;
import org.ametys.cms.form.ExternalizableField;
import org.ametys.cms.form.Form;
import org.ametys.cms.form.ReferenceField;
import org.ametys.cms.form.RepeaterField;
import org.ametys.cms.form.RepeaterField.RepeaterEntry;
import org.ametys.cms.form.RichTextField;
import org.ametys.cms.form.SimpleField;
import org.ametys.cms.form.SubContentField;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.transformation.RichTextTransformer;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.upload.Upload;
import org.ametys.core.upload.UploadManager;
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.JSONUtils;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CommentableCompositeMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.MetadataComment;
import org.ametys.plugins.repository.metadata.ModifiableBinaryMetadata;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.metadata.ModifiableFolder;
import org.ametys.plugins.repository.metadata.ModifiableResource;
import org.ametys.plugins.repository.metadata.ModifiableRichText;
import org.ametys.plugins.repository.metadata.Resource;
import org.ametys.plugins.repository.metadata.UnknownMetadataException;
import org.ametys.plugins.repository.metadata.jcr.JCRCompositeMetadata;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.component.CheckRightsCondition;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.Errors;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.parameter.ParameterHelper.ParameterType;
import org.ametys.runtime.parameter.Validator;

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

/**
 * OSWorkflow function to edit a content.
 * 
 * The required transient variables:
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY - Map<String, Object> The map containing the results of the function.
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.result - String "true" when everything goes fine. Missing in other case.
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath> - Errors Each error during edition will be set here. Key will be the metadata path (with '.' separator). Value will be the error message.
 * - AbstractContentWorkflowComponent.CONTENT_KEY - WorkflowAwareContent The content that will be edited. Should have the lock token.
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY - Map<String, Object> Contains the following parameters:
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.QUIT - boolean True to specify edition mode will be quit, this imply to unlock the content.
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.METADATA_SET_PARAM The name of the edition metadata set to use and to check metadata. If missing a metadataset will be created.
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_VALUES - Map<String, Object> The values of the submitted form :
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_VALUES.<MetadataPath> 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.
 * - AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY.FORM_RAW_COMMENTS - Map<String, List<Map<String, String>>> The comments of the metadata of the submitted form :
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath> - List<Map<String, String>> Key is the path of the metadata ('.' separated) prefixed by FORM_ELEMENTS_PREFIX. Value is the list of comments.
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath>.<X> - <Map<String, String> A comment with the following parameters
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath>.<X>.author String The login of the author of the comment
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath>.<X>.text String The text of the comment
 * - AbstractContentWorkflowComponent.RESULT_MAP_KEY.<MetadataPath>.<X>.date String The date of the comment using the ISODateTimeFormat (See ParameterHelper.castValue)
 * 
 * Where <MetadataPath> 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).
 * Where <X> Is an element of the parent list.
 * 
 * Here is the list of required information and values depending on the type of the metadata:
 * - MetadataType.STRING
 *      When simple, the value is a String containing the value. Ex: "content.input.abstract": "Sample of abstract"
 *      When multiple, the value is a String[] containing the values. Ex: "content.input.abstract": ["value 1", "value 2"]. An additional information can be provided: "mode" that can be "replace" (default value) or "insert". When "replace", the given String[] will replace the existing value. When "insert"; the given String[] will be appended. Ex: "_content.input.abstract.mode": "insert".
 * - MetadataType.DATE 
 *      Same as MetadataType.STRING where values are String encoded at ISODateTimeFormat (See ParameterHelper.castValue). Ex: "content.input.date": "2014-03-12T00:00:00.000+01:00".
 * - MetadataType.DATETIME
 *      See MetadataType.DATE.
 * - MetadataType.LONG
 *      Same as MetadataType.STRING where values are String that can be parsed as Long.
 * - MetadataType.DOUBLE
 *      Same as MetadataType.STRING where values are String that can be parsed as Double.
 * - MetadataType.BOOLEAN
 *      Same as MetadataType.STRING where values are String that can be parsed as Boolean.
 * - MetadataType.GEOCODE
 *      A single String that is are a map encoded with 2 keys 'latitude' and 'longitude' and double values. Ex: "content.input.address.gps": "{\"latitude\":1.574576,\"longitude\":103.79255799999999}"
 * - MetadataType.COMPOSITE
 *      A composite metadata does not have values itself. The values are sub metadata.
 *      A repeater (sort of multiple composite) does not have value either, but do have additional information: 
 *          "size" in a String representing a Long with the number of elements submitted. Ex: "_content.input.attachments.size": "2". This information is crucial since this function only handle repeated values going from 1 to size. Ex: "content.input.attachments.1.*" and "content.input.attachments.2.*".
 *          "mode" as for MetadataType.STRING, mode can be "replace" (default value) to remove all current entries before adding new one, or "insert" to add only the new values (see "position" under to see where to insert).
 *          Each instance in the repeater does also have additional information.
 *              "previous-position" As explained above, a metadatapath inside a repeater include the current position of the element. This value is a String encoding a Long with the position of the repeater instance BEFORE this edition: this allow to move the repeater instance, instead of removing it and add it again (specially with FILE or BINARY metadata). Ex: "_content.input.attachments.1.previous-position": "1". Will be "-1" when it is a new instance.
 *              "position" In "insert" mode, we do not want to use the value set in the metadata path as a "current position". The position given by path is wrong as it always start at 1 and finish at size. Values >= 1 are positions. Ex: "_content.input.attachments.1.position": "20", means that all values "content.input.attachments.1.*" will be added to an instance at the position "20" (and not "1" as it will be in "replace" mode). Values < 1 are positions indexed by the end. 0 means to add it to the end. -1 to add it just before the last one. In "insert" mode, elements are insersected at the given positions and do not replace those elements. Inserting 5 elements at "position" "1", will insert 5 elements at position 1, 2, 3, 4 and 5.
 * - MetadataType.BINARY
 *      TODO
 * - MetadataType.RICH_TEXT
 *      TODO
 * - MetadataType.USER
 *      A single String that is a map encoded with 2 keys 'login' and 'populationId' and string values. Ex: "content.input.user": "{\"login\":"alogin",\"populationId\":"apopulation"}"
 * - MetadataType.REFERENCE
 *      When simple, a single String that is a map encoded with 2 keys 'value' and 'type', both are string. 'type' is the type of the reference (ex: external-url), and 'value' its value.
 *      When multiple, an Array of String. Where each string is formatted the same way as done in the simple case.
 * - MetadataType.CONTENT
 *      TODO
 * - MetadataType.SUB_CONTENT
 *      TODO
 * - MetadataType.FILE
 *      TODO
 *      TODO talk about UNTOUCHED_BINARY UNTOUCHED_FILE METADATA_FILE EXPLORER_FILE
 */
public class EditContentFunction extends AbstractContentWorkflowComponent implements FunctionProvider, 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";
    
    /** Constant for storing the action id for editing revert relations. */
    public static final String EDIT_MUTUAL_RELATIONSHIP = EditContentFunction.class.getName() + "$mutualRelationship";
    
    /** Prefix for HTML form elements. */
    public static final String FORM_ELEMENTS_PREFIX = "content.input.";
    /** Prefix for internal HTML form elements. */
    public static final String INTERNAL_FORM_ELEMENTS_PREFIX = "_" + FORM_ELEMENTS_PREFIX;
    /** 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";
    /** Prefix for the metadata set name request parameter. */
    public static final String METADATA_SET_PARAM = "content.metadata.set";
    /** Prefix for the quit edition mode request parameter. */
    public static final String QUIT = "quit";
    /** Constant for untouched binary metadata. */
    public static final String UNTOUCHED_BINARY = "untouched";
    /** Constant for untouched file metadata. */
    public static final String UNTOUCHED_FILE = "untouched";
    /** Constant for local file metadata. */
    public static final String METADATA_FILE = "metadata";
    /** Constant for shared file metadata. */
    public static final String EXPLORER_FILE = "explorer";
    /** Constant for JCR reference prefix. */
    public static final String JCR_REFERENCE_PREFIX = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":ref-";
    
    /** Default action id of editing revert relations. */
    private static final int __INVERT_EDIT_ACTION_ID = 2;
    
    /** The AmetysObject resolver. */
    protected AmetysObjectResolver _resolver;
    /** Content type extension point. */
    protected ContentTypeExtensionPoint _contentTypeExtensionPoint;
    /** Helper for content types */
    protected ContentTypesHelper _contentTypesHelper;
    /** Upload manager. */
    protected UploadManager _uploadManager;
    /** Observation manager available to subclasses. */
    protected ObservationManager _observationManager;
    /** The JSON conversion utilities. */
    protected JSONUtils _jsonUtils;
    /** The workflow provider */
    protected WorkflowProvider _workflowProvider;
    /** The content workflow helper. */
    protected ContentWorkflowHelper _workflowHelper;
    /** The outgoing references extractor */
    protected OutgoingReferencesExtractor _outgoingReferencesExtractor;
    /** The user manager */
    protected UserManager _userManager;
    /** Provider for externalizable metadata */
    protected ExternalizableMetadataProviderExtensionPoint _externalizableMetadataProviderEP;
    /** Set of already checked node */
    protected Set<String> _lockAlreadyChecked = new HashSet<>();
    
    @Override
    public void initialize() throws Exception
    {
        _resolver = (AmetysObjectResolver) _manager.lookup(AmetysObjectResolver.ROLE);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) _manager.lookup(ContentTypeExtensionPoint.ROLE);
        _uploadManager = (UploadManager) _manager.lookup(UploadManager.ROLE);
        _observationManager = (ObservationManager) _manager.lookup(ObservationManager.ROLE);
        _jsonUtils = (JSONUtils) _manager.lookup(JSONUtils.ROLE);
        _workflowProvider = (WorkflowProvider) _manager.lookup(WorkflowProvider.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);
        _externalizableMetadataProviderEP = (ExternalizableMetadataProviderExtensionPoint) _manager.lookup(ExternalizableMetadataProviderExtensionPoint.ROLE);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public void execute(Map transientVars, Map args, PropertySet ps) throws WorkflowException
    {
        _logger.info("Performing edit workflow function");

        _lockAlreadyChecked = new HashSet<>();
        
        // Retrieve current content
        WorkflowAwareContent content = getContent(transientVars);
        UserIdentity user = getUser(transientVars);
        
        // Get the action id for editing invert relations
        int invertEditActionId = transientVars.containsKey(INVERT_RELATION_EDIT_WORKFLOW_ACTION_ID) ? (Integer) transientVars.get(INVERT_RELATION_EDIT_WORKFLOW_ACTION_ID) : __INVERT_EDIT_ACTION_ID;
        
        if (!(content instanceof ModifiableContent))
        {
            throw new IllegalArgumentException("The provided content " + content.getId() + " is not a ModifiableContent.");
        }
        
        ModifiableContent modifiableContent = (ModifiableContent) content;
        
        try
        {
            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 '" + modifiableContent.getName() + "' but it is locked by another user");
                }
            }
            
            AllErrors errors = new AllErrors();
            
            Map<String, Object> parameters = getContextParameters(transientVars);  
            
            long time_0 = System.currentTimeMillis();
            
            Map<String, Object> rawValues = (Map<String, Object>) parameters.get(FORM_RAW_VALUES);
            MetadataSet metadataSet = getMetadataSet(parameters, rawValues, modifiableContent);
            
            long time_1 = System.currentTimeMillis();
            
            Map<String, List<Map<String, String>>> rawComments = (Map<String, List<Map<String, String>>>) parameters.get(FORM_RAW_COMMENTS);
            
            Set<String> externalAndLocalMetadata = _externalizableMetadataProviderEP.getExternalAndLocalMetadata(modifiableContent);
            
            _bindAndValidateContent(modifiableContent, errors, metadataSet, rawValues, rawComments, user, invertEditActionId, externalAndLocalMetadata);

            long time_2 = System.currentTimeMillis();
            
            if (errors.hasErrors())
            {
                // Populate the map to render
                Map<String, Object> result = getResultsMap(transientVars);
                
                for (Map.Entry<String, Errors> entry : errors.getAllErrors().entrySet())
                {
                    String canonicalMetadataPath = entry.getKey().replace('/', '.');
                    
                    result.put(canonicalMetadataPath, entry.getValue());
                }
                
                throw new InvalidInputWorkflowException("At least one validation error is preventing from saving the modifications", errors);
            }
            
            _updateCommonMetadata(modifiableContent, user);
            
            _extractOutgoingReferences(modifiableContent);
            
            long time_3 = System.currentTimeMillis();
            
            // Commit changes
            modifiableContent.saveChanges();
            
            long time_4 = System.currentTimeMillis();
            
            // Notify the observers of the modification.
            _notifyContentModified(content, transientVars);
            
            long time_5 = System.currentTimeMillis();
            
            // Unlock content if we are not in save & quit mode
            boolean quit = (Boolean) parameters.get(QUIT);
            if (quit && lockableContent != null && lockableContent.isLocked())
            {
                lockableContent.unlock();
            }
            
            long time_6 = System.currentTimeMillis();
            
            if (time_6 - time_0 > 5000 && Config.getInstance().getValueAsBoolean("runtime.log.abnormal.time"))
            {
                _logger.warn("Edit content action has taken an abnormally long time : get metadata set in " + (time_1 - time_0) + " ms / bind metadata 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 metadata set in " + (time_1 - time_0) + " ms / bind metadata 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");
            }
            
            getResultsMap(transientVars).put("result", "ok");
        }
        catch (AmetysRepositoryException e)
        {
            throw new WorkflowException("Unable to edit content " + modifiableContent + " from the repository", e);
        }
    }
    
    /**
     * Notify observers that the content has been modified
     * @param content The content modified
     * @param transientVars The workflow vars
     * @throws WorkflowException If an error occurred
     */
    protected void _notifyContentModified(Content content, Map transientVars) throws WorkflowException
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        
        if (transientVars.containsKey(EditContentFunction.EDIT_MUTUAL_RELATIONSHIP))
        {
            eventParams.put(EditContentFunction.EDIT_MUTUAL_RELATIONSHIP, true);
        }
        _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, getUser(transientVars), eventParams));
    }

    /**
     * Get the metadata set for the content
     * @param jsParameters The request parameters
     * @param rawValues The raw values of the form
     * @param content The content
     * @return The metadata set asked in the request or a built-in metadataset
     * @throws WorkflowException If an error occurred while getting the metadata set
     */
    protected MetadataSet getMetadataSet(Map<String, Object> jsParameters, Map<String, Object> rawValues, Content content) throws WorkflowException
    {
        MetadataSet metadataSet;
        
        String metadataSetName = (String) jsParameters.get(METADATA_SET_PARAM);
        if (metadataSetName != null)
        {
            metadataSet = _contentTypesHelper.getMetadataSetForEdition(metadataSetName, content.getTypes(), content.getMixinTypes());
            if (metadataSet == null)
            {
                throw new WorkflowException(String.format("No metadata set for name '%s' and content type(s) '%s'", metadataSetName, StringUtils.join(content.getTypes(), ',')));
            }
        }
        else
        {
            // Let us compute a metadataset
            metadataSet = _createMetadataSet(rawValues);
        }
        
        return metadataSet;
    }

    private MetadataSet _createMetadataSet(Map<String, Object> rawValues)
    {
        MetadataSet metadataSet;
        metadataSet = new MetadataSet();
        metadataSet.setName("__generated__");
        metadataSet.setLabel(new I18nizableText("Live edition metadataset"));
        metadataSet.setDescription(new I18nizableText("Live edition metadataset"));
        metadataSet.setSmallIcon(null);
        metadataSet.setMediumIcon(null);
        metadataSet.setLargeIcon(null);
        metadataSet.setEdition(true);
        metadataSet.setInternal(true);
         
        // Lets remove numbers in repeaters definitions
        @SuppressWarnings("unchecked")
        Map<String, Integer> sizePrefixes = new TreeMap<>(new ReverseComparator());
        for (String parameterName : rawValues.keySet())
        {
            if (StringUtils.startsWith(parameterName, INTERNAL_FORM_ELEMENTS_PREFIX) && StringUtils.endsWith(parameterName, ".size"))
            {
                String prefix = parameterName.substring(1, parameterName.length() - 5); // 5 is ".size" length
                Integer size = Integer.parseInt((String) rawValues.get(parameterName));
                
                sizePrefixes.put(prefix, size);
            }
        }
        
        Set<String> parameterNames2MetadataDefPaths = new HashSet<>(rawValues.keySet());
        boolean setWasModified = true;
        while (setWasModified)
        {
            setWasModified = false;
            
            Iterator<String> sizePrefixesIterator = sizePrefixes.keySet().iterator();
            while (!setWasModified && sizePrefixesIterator.hasNext())
            {
                String sizePrefix = sizePrefixesIterator.next();
                
                for (int i = 1; !setWasModified && i <= sizePrefixes.get(sizePrefix); i++)
                {
                    String numPrefix = "." + i + ".";
                    String prefix = sizePrefix + numPrefix;
                    
                    Iterator<String> parameterNames2MetadataDefPathsIterator = parameterNames2MetadataDefPaths.iterator();
                    while (!setWasModified && parameterNames2MetadataDefPathsIterator.hasNext())
                    {
                        String parameterNames2MetadataDefPath = parameterNames2MetadataDefPathsIterator.next();
                        
                        if (StringUtils.startsWith(parameterNames2MetadataDefPath, prefix))
                        {
                            parameterNames2MetadataDefPaths.remove(parameterNames2MetadataDefPath);
                            
                            String newName = parameterNames2MetadataDefPath.substring(0, prefix.length() - numPrefix.length()) + parameterNames2MetadataDefPath.substring(prefix.length() - 1);
                            parameterNames2MetadataDefPaths.add(newName);
                            
                            setWasModified = true;
                        }
                    }
                }
            }
        }
        
        for (String parameterName : parameterNames2MetadataDefPaths)
        {
            if (parameterName.startsWith(FORM_ELEMENTS_PREFIX))
            {
                String metadataName = parameterName.substring(FORM_ELEMENTS_PREFIX.length());
                _addMetadataDefRef(metadataSet, metadataName);
            }
        }
        return metadataSet;
    }
    
    private void _addMetadataDefRef(AbstractMetadataSetElement metadataSetElement, String metadataName)
    {
        String currentLevelMetadataName = StringUtils.substringBefore(metadataName, ".");
        MetadataDefinitionReference metaDefRef = metadataSetElement.getMetadataDefinitionReference(currentLevelMetadataName);
        if (metaDefRef == null)
        {
            metaDefRef = new MetadataDefinitionReference(currentLevelMetadataName, "main");
            metadataSetElement.addElement(metaDefRef);
        }
        
        String subLevelMetadataName = StringUtils.substringAfter(metadataName, ".");
        if (StringUtils.isNotBlank(subLevelMetadataName))
        {
            _addMetadataDefRef(metaDefRef, subLevelMetadataName);
        }
    }

    /**
     * Analyze the content to extract outgoing references and store them
     * @param content The content to analyze
     */
    protected void _extractOutgoingReferences(ModifiableContent content)
    {
        Map<String, OutgoingReferences> outgoingReferencesByPath = _outgoingReferencesExtractor.getOutgoingReferences(content);
        content.setOutgoingReferences(outgoingReferencesByPath);
    }
    
    /**
     * 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;
    }
    
    /**
     * Bind and validate a form.
     * @param content the content.
     * @param allErrors the errors.
     * @param metadataSet the metadataset
     * @param rawValues the raw values of the form
     * @param rawComments the raw comments of the form
     * @param user the user.
     * @param invertEditActionId The current 'edit content' action ID.
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateContent(ModifiableContent content, AllErrors allErrors, MetadataSet metadataSet, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, UserIdentity user, int invertEditActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        Form form = new Form();
        
        // First bind and validate in the form object
        _bindAndValidateMetadataSetElement(content, form, allErrors, metadataSet, rawValues, rawComments, null, "", externalAndLocalMetadata);
        
        // Additional validation
        _validateForm(content, form, metadataSet, allErrors);
        
        // Do not synchronize if there is at least one error
        if (!allErrors.hasErrors())
        {
            // Prepare to synchronize
            _prepareSynchronizeMetadataSetElement(content, content.getMetadataHolder(), form, allErrors, user, metadataSet, null, "", invertEditActionId);
            
            if (!allErrors.hasErrors())
            {
                // Synchronize form fields and content metadata if no error
                _synchronizeMetadataSetElement(content, content.getMetadataHolder(), form, allErrors, user, metadataSet, null, "", invertEditActionId, externalAndLocalMetadata);
            }
            
        }
    }

    /**
     * Bind and validate a metadata set element.
     * @param content the content.
     * @param form the form.
     * @param allErrors the errors.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param rawValues the raw values of the form
     * @param rawComments the raw comments of the form
     * @param parentMetadataDefinition the metadata definition.
     * @param parentMetadataPath the metadata path.
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateMetadataSetElement(Content content, Form form, AllErrors allErrors, AbstractMetadataSetElement metadataSetElement, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, MetadataDefinition parentMetadataDefinition, String parentMetadataPath, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        for (AbstractMetadataSetElement subElement : metadataSetElement.getElements())
        {
            if (subElement instanceof MetadataDefinitionReference)
            {
                MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) subElement;
                MetadataDefinition metadataDefinition = _getMetadataDefinition(content, parentMetadataDefinition, metadataDefRef.getMetadataName());
                
                if (metadataDefinition == null)
                {
                    throw new IllegalArgumentException("Unable to get the metadata definition of metadata \"" + parentMetadataPath + ContentConstants.METADATA_PATH_SEPARATOR + metadataDefRef.getMetadataName() + "\"");
                }
                
                if (_contentTypesHelper.canWrite(content, metadataDefinition))
                {
                    String subMetadataPath = parentMetadataPath + metadataDefinition.getName();
                    _bindAndValidateMetadata(content, form, allErrors, subElement, rawValues, rawComments, metadataDefinition, subMetadataPath, externalAndLocalMetadata);
                    _bindComments(rawComments, form, metadataDefinition, subMetadataPath); // Handle metadata comments
                }
            }
            else
            {
                _bindAndValidateMetadataSetElement(content, form, allErrors, subElement, rawValues, rawComments, parentMetadataDefinition, parentMetadataPath, externalAndLocalMetadata);
            }
        }
    }

    /**
     * Validates the form.
     * @param content the content.
     * @param form the form.
     * @param metadataSet the metadata set.
     * @param allErrors the errors.
     */
    protected void _validateForm(Content content, Form form, MetadataSet metadataSet, AllErrors allErrors)
    {
        Errors errors = new Errors();
        
        String[] allContentTypes = ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());
        
        for (String cTypeId : allContentTypes)
        {
            ContentType contentType = _contentTypeExtensionPoint.getExtension(cTypeId);
            
            for (ContentValidator validator : contentType.getGlobalValidators())
            {
                validator.validate(content, form, metadataSet, errors);
            }
        }
        
        if (errors.hasErrors())
        {
            // Global error
            allErrors.addError("_global", errors);
        }
       
    }

    /**
     * Synchronize a metadata set element with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param parentMetadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeMetadataSetElement(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition parentMetadataDefinition, String metadataPath, int invertEditActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        for (AbstractMetadataSetElement subElement : metadataSetElement.getElements())
        {
            if (subElement instanceof MetadataDefinitionReference)
            {
                MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) subElement;
                MetadataDefinition metadataDefinition = _getMetadataDefinition(content, parentMetadataDefinition, metadataDefRef.getMetadataName());
                
                if (_contentTypesHelper.canWrite(content, metadataDefinition))
                {
                    String subMetadataPath = metadataPath + metadataDefinition.getName();
                    _synchronizeMetadata(content, metadata, form, allErrors, user, subElement, metadataDefinition, subMetadataPath, invertEditActionId, externalAndLocalMetadata);
                }
            }
            else
            {
                _synchronizeMetadataSetElement(content, metadata, form, allErrors, user, subElement, parentMetadataDefinition, metadataPath, invertEditActionId, externalAndLocalMetadata);
            }
        }
    }
    
    /**
     * Synchronize to synchronize a metadata set element with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param parentMetadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @throws WorkflowException if an error occurs.
     * @throws AmetysRepositoryException if an error occurred
     */
    protected void _prepareSynchronizeMetadataSetElement(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition parentMetadataDefinition, String metadataPath, int invertEditActionId) throws WorkflowException, AmetysRepositoryException
    {
        for (AbstractMetadataSetElement subElement : metadataSetElement.getElements())
        {
            if (subElement instanceof MetadataDefinitionReference)
            {
                MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) subElement;
                MetadataDefinition metadataDefinition = _getMetadataDefinition(content, parentMetadataDefinition, metadataDefRef.getMetadataName());
                
                if (_contentTypesHelper.canWrite(content, metadataDefinition))
                {
                    String subMetadataPath = metadataPath + metadataDefinition.getName();
                    _prepareSynchronizeMetadata(content, metadata, form, allErrors, user, subElement, metadataDefinition, subMetadataPath, invertEditActionId);
                }
            }
            else
            {
                _prepareSynchronizeMetadataSetElement(content, metadata, form, allErrors, user, subElement, parentMetadataDefinition, metadataPath, invertEditActionId);
            }
        }
    }
    
    

    /**
     * Updates common metadata (last contributor, last modification date, ...).
     * @param content the content.
     * @param user the user.
     * @throws WorkflowException if an error occurs.
     */
    protected void _updateCommonMetadata(ModifiableContent content, UserIdentity user) throws WorkflowException
    {
        if (user != null)
        {
            content.setLastContributor(user);
        }
        content.setLastModified(new Date());
        
        if (content instanceof WorkflowAwareContent)
        {
            // Remove the proposal date.
            ((WorkflowAwareContent) content).setProposalDate(null);
        }
    }

    /**
     * Retrieves a sub metadata definition from a content type or
     * a parent metadata definition. 
     * @param content the content.
     * @param parentMetadataDefinition the parent metadata definition.
     * @param metadataName the metadata name.
     * @return the metadata definition found or <code>null</code> otherwise.
     */
    protected MetadataDefinition _getMetadataDefinition(Content content, MetadataDefinition parentMetadataDefinition, String metadataName)
    {
        if (parentMetadataDefinition == null)
        {
            return _contentTypesHelper.getMetadataDefinition(metadataName, content.getTypes(), content.getMixinTypes());
        }
        else
        {
            return parentMetadataDefinition.getMetadataDefinition(metadataName);
        }
    }
    
    /**
     * Bind and validate a form.
     * @param content the content.
     * @param form the form.
     * @param allErrors the errors.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param rawValues the raw values.
     * @param rawComments the raw comments.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateMetadata(Content content, Form form, AllErrors allErrors, AbstractMetadataSetElement metadataSetElement, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, MetadataDefinition metadataDefinition, String metadataPath, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        MetadataType type = metadataDefinition.getType();
        
        if (!_contentTypesHelper.canWrite(content, metadataDefinition))
        {
            throw new WorkflowException("Current user has no right to edit metadata " + metadataName);
        }
        
        boolean externalizable = externalAndLocalMetadata.contains(metadataPath);
        Object rawValue = rawValues.get(FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.'));
        
        switch (type)
        {
            case STRING:
                _bindAndValidateStringMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case USER:
                _bindAndValidateUserMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case DATE:
                _bindAndValidateDateMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case DATETIME:
                _bindAndValidateDateTimeMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case LONG:
                _bindAndValidateLongMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case GEOCODE:
                _bindAndValidateGeocodeMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case DOUBLE:
                _bindAndValidateDoubleMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case BOOLEAN:
                _bindAndValidateBooleanMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case BINARY:
                _bindAndValidateBinaryMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case FILE:
                _bindAndValidateFileMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case RICH_TEXT:
                _bindAndValidateRichText(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case COMPOSITE:
                _bindAndValidateCompositeMetadata(allErrors, form, content, metadataName, metadataSetElement, metadataDefinition, metadataPath, rawValue, rawValues, rawComments, externalAndLocalMetadata);
                break;
            case REFERENCE:
                _bindAndValidateReferenceMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case CONTENT:
                _bindAndValidateContentReferenceMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            case SUB_CONTENT:
                _bindAndValidateSubContentMetadata(allErrors, form, content, metadataDefinition, metadataPath, rawValue, rawValues, externalizable);
                break;
            default:
                throw new WorkflowException("Unsupported type: " + type);   
        }
    }
    
    private String[] _getLocalValues (String rawValue, MetadataDefinition metadataDefinition)
    {
        Map<String, Object> externalizableValue = _jsonUtils.convertJsonToMap(rawValue);
        return _getMetadataValues(externalizableValue.get("local"), metadataDefinition);
    }
    
    private String[] _getExternalValues (String rawValue, MetadataDefinition metadataDefinition)
    {
        Map<String, Object> externalizableValue = _jsonUtils.convertJsonToMap(rawValue);
        return _getMetadataValues(externalizableValue.get("external"), metadataDefinition);
    }

    /**
     * Get a metadata values from the request.
     * @param rawValues the raw values.
     * @param form the form.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @return the metadata values as a String array.
     */
    protected String[] _getMetadataValues(Map<String, Object> rawValues, Form form, MetadataDefinition metadataDefinition, String metadataPath)
    {
        Object rawValue = rawValues.get(FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.'));
        return _getMetadataValues(rawValue, metadataDefinition);
    }
    
    /**
     * Get a metadata values from raw value
     * @param rawValue The raw value
     * @param metadataDefinition the metadata definition.
     * @return the metadata values as a String array.
     */
    @SuppressWarnings("unchecked")
    protected String[] _getMetadataValues(Object rawValue, MetadataDefinition metadataDefinition)
    {
        List<String> metadataValues = new ArrayList<>();
        
        if (rawValue != null)
        {
            if (metadataDefinition.isMultiple())
            {
                // The value can either be passed as a List object or as a JSON-encoded string.
                List<Object> listValue = Collections.emptyList();
                if (rawValue instanceof List)
                {
                    listValue = (List<Object>) rawValue;
                }
                else if (rawValue instanceof String)
                {
                    listValue = _jsonUtils.convertJsonToList((String) rawValue);
                }
                
                for (Object valueAsObject : listValue)
                {
                    if (valueAsObject instanceof String)
                    {
                        metadataValues.add((String) valueAsObject); 
                    }
                    else
                    {
                        metadataValues.add(_jsonUtils.convertObjectToJson(valueAsObject));
                    }
                }
            }
            else
            {
                metadataValues.add(String.valueOf(rawValue));
            }
        }
        
        return metadataValues.toArray(new String[metadataValues.size()]);
    }
    
    /**
     * Bind the comments of a field to the form
     * @param rawComments The raw comments of the form
     * @param form The forms
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     */
    protected void _bindComments(Map<String, List<Map<String, String>>> rawComments, Form form, MetadataDefinition metadataDefinition, String metadataPath)
    {
        if (rawComments == null)
        {
            return;
        }

        String fieldName = metadataDefinition.getName();
        List<Map<String, String>> rawFieldcomments = rawComments.get(FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.'));
        List<MetadataComment> comments = new ArrayList<>();
        
        if (rawFieldcomments != null)
        {
            for (Map<String, String> rawEntry : rawFieldcomments)
            {
                String text = rawEntry.get("text");
                String author = rawEntry.get("author");
                Date date = (Date) ParameterHelper.castValue(rawEntry.get("date"), ParameterType.DATE);
                comments.add(new MetadataComment(text, date, author));
            }
        }
        
        form.setCommentsField(fieldName, comments.toArray(new MetadataComment[comments.size()]));
    }
    
    /**
     * Bind and validate a composite metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param metadataDefinition the metadata definition.
     * @param content the current content
     * @param metadataName the metadata name
     * @param metadataSetElement the metadata set element
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted values.
     * @param rawValues The raw values of the form
     * @param rawComments The raw comments of the form
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateCompositeMetadata(AllErrors allErrors, Form form, Content content, String metadataName, AbstractMetadataSetElement metadataSetElement, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, Set<String> externalAndLocalMetadata) throws AmetysRepositoryException, WorkflowException
    {
        if (metadataDefinition instanceof RepeaterDefinition)
        {
            _bindAndValidateRepeater(content, form, allErrors, metadataSetElement, rawValues, rawComments, (RepeaterDefinition) metadataDefinition, metadataPath, externalAndLocalMetadata);
        }
        else
        {
            String key = FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
            
            Form compositeForm = null;
            if (!rawValues.containsKey(key) || rawValues.get(key) != null)
            {
                compositeForm = new Form();
                _bindAndValidateMetadataSetElement(content, compositeForm, allErrors, metadataSetElement, rawValues, rawComments, metadataDefinition, metadataPath + "/", externalAndLocalMetadata);
            }
            form.setCompositeField(metadataName, compositeForm);
        }
    }

    /**
     * Bind and validate a repeater.
     * @param content the content.
     * @param form the form.
     * @param allErrors the errors.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param rawValues the raw values of the form
     * @param rawComments the raw comments of the form
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @param externalAndLocalMetadata The paths of externalizable metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateRepeater(Content content, Form form, AllErrors allErrors, AbstractMetadataSetElement metadataSetElement, Map<String, Object> rawValues, Map<String, List<Map<String, String>>> rawComments, RepeaterDefinition repeaterDefinition, String metadataPath, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        int repeaterSizeValue;
        String repeaterParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        
        String repeaterSize = (String) rawValues.get(repeaterParamsPrefix + ".size");
        if (repeaterSize == null)
        {
            throw new WorkflowException("Missing request parameter size for metadata: " + metadataPath);
        }
        try
        {
            repeaterSizeValue = Integer.valueOf(repeaterSize);
        }
        catch (NumberFormatException e)
        {
            throw new WorkflowException("Invalid size: " + repeaterSize, e);
        }

        RepeaterField repeaterField = new RepeaterField();

        String repeaterMode = (String) rawValues.get(repeaterParamsPrefix + ".mode");
        repeaterField.setMode(repeaterMode);

        for (int i = 1; i <= repeaterSizeValue; i++)
        {
            RepeaterEntry repeaterEntry = new RepeaterEntry();
            
            
            int previousPositionValue = -1;
            String previousPosition = (String) rawValues.get(repeaterParamsPrefix + "." + i + ".previous-position");
            if (previousPosition != null)
            {
                try
                {
                    previousPositionValue = Integer.valueOf(previousPosition);
                    repeaterEntry.setPreviousPosition(previousPositionValue);
                }
                catch (NumberFormatException e)
                {
                    throw new WorkflowException("Invalid position: " + previousPosition, e);
                }
            }

            int positionValue = i;
            String position = (String) rawValues.get(repeaterParamsPrefix + "." + i + ".position");
            if (position != null)
            {
                try
                {
                    positionValue = Integer.valueOf(position);
                }
                catch (NumberFormatException e)
                {
                    throw new WorkflowException("Invalid position: " + position, e);
                }
            }
            repeaterEntry.setPosition(positionValue);

            // Bind and validate each entry
            _bindAndValidateMetadataSetElement(content, repeaterEntry, allErrors, metadataSetElement, rawValues, rawComments, repeaterDefinition, metadataPath + "/" + i + "/", externalAndLocalMetadata);
            
            repeaterField.addEntry(repeaterEntry);
        }

        // Size will be checked later
        
        form.setField(metadataName, repeaterField);
    }

    /**
     * Bind and validate a string metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param metadataDefinition the metadata definition.
     * @param content the content
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateStringMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();

        AbstractField field = null;
        
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<String> localField = new SimpleField<>(localValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<String> extField = new SimpleField<>(extValues);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = new SimpleField<>(metadataValues);
        }

        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);

        String[] values = field instanceof ExternalizableField ? ((SimpleField<String>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<String>) field).getValues();
        
        String[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<String>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (externalizable || (values.length > 0 && !values[0].equals("")))
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind and validate a user metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateUserMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<UserIdentity> localField = _bindUserField(localValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<UserIdentity> extField = _bindUserField(extValues);
            
            if (localField != null)
            {
                field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
            }
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindUserField(metadataValues);
        }
        
        if (field != null)
        {
            String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replaceAll("/", ".");
            String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
            field.setMode(metadataMode);
            form.setField(metadataName, field);
        }
    }
    
    /**
     * Bind a user field from form values
     * @param values the form values
     * @return The user field
     */
    protected SimpleField<UserIdentity> _bindUserField (String[] values)
    {
        List<UserIdentity> users = new ArrayList<>();
        for (String value : values)
        {
            Map<String, Object> userValue = _jsonUtils.convertJsonToMap(value);
            
            String login = (String) userValue.get("login");
            String populationId = (String) userValue.get("populationId");
            
            if (login != null && populationId != null)
            {
                users.add(new UserIdentity(login, populationId));
            }
        }
        
        return new SimpleField<>(users.toArray(new UserIdentity[users.size()]));
    }

    /**
     * Bind and validate a date metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateDateMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Date> localField = _bindDateField(localValues, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Date> extField = _bindDateField(extValues, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindDateField(metadataValues, metadataPath, allErrors);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);
        
        Date[] values = field instanceof ExternalizableField ? ((SimpleField<Date>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Date>) field).getValues();
        
        Date[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<Date>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (externalizable || values.length > 0)
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind a date field from form values
     * @param values the form values
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The date field
     */
    protected SimpleField<Date> _bindDateField (String[] values, String metadataPath, AllErrors allErrors)
    {
        List<Date> dateValues = new ArrayList<>();
        
        for (int i = 0; i < values.length; i++)
        {
            if (!"".equals(values[i]))
            {
                try
                {
                    LocalDate ld = LocalDate.parse(values[i], DateTimeFormatter.ISO_DATE_TIME);
                    dateValues.add(DateUtils.asDate(ld));
                }
                catch (DateTimeParseException e)
                {
                    Errors parseErrors = new Errors();
                    
                    List<String> parameters = new ArrayList<>();
                    parameters.add(values[i]);
                    parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_DATE_INVALID", parameters));
                    allErrors.addError(metadataPath, parseErrors);
                }
            }
        }
        
        Date[] dateArray = dateValues.toArray(new Date[dateValues.size()]);
        return new SimpleField<>(dateArray);
    }
    
    /**
     * Bind and validate a date time metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateDateTimeMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Date> localField = _bindDateTimeField(localValues, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Date> extField = _bindDateTimeField(extValues, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindDateTimeField(metadataValues, metadataPath, allErrors);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);

        Date[] values = field instanceof ExternalizableField ? ((SimpleField<Date>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Date>) field).getValues();
        
        Date[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<Date>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (externalizable || values.length > 0)
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind a date time field from form values
     * @param values the form values
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The date field
     */
    protected SimpleField<Date> _bindDateTimeField (String[] values, String metadataPath, AllErrors allErrors)
    {
        List<Date> dateValues = new ArrayList<>();
        
        for (int i = 0; i < values.length; i++)
        {
            if (!"".equals(values[i]))
            {
                try
                {
                    LocalDateTime ld = LocalDateTime.parse(values[i], DateTimeFormatter.ISO_DATE_TIME);
                    dateValues.add(DateUtils.asDate(ld));
                }
                catch (DateTimeParseException e)
                {
                    Errors parseErrors = new Errors();
                    
                    List<String> parameters = new ArrayList<>();
                    parameters.add(values[i]);
                    parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_DATETIME_INVALID", parameters));
                    allErrors.addError(metadataPath, parseErrors);
                }
            }
        }
        
        Date[] dateArray = dateValues.toArray(new Date[dateValues.size()]);
        return new SimpleField<>(dateArray);
    }

    /**
     * Bind and validate a long metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateLongMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Long> localField = _bindLongField(localValues, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Long> extField = _bindLongField(extValues, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindLongField(metadataValues, metadataPath, allErrors);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);
        
        Long[] values = field instanceof ExternalizableField ? ((SimpleField<Long>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Long>) field).getValues();
        
        Long[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<Long>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (externalizable || values.length > 0)
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind a long field from form values
     * @param values the form values
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The long field
     */
    protected SimpleField<Long> _bindLongField (String[] values, String metadataPath, AllErrors allErrors)
    {
        List<Long> longValues = new ArrayList<>();
        
        for (int i = 0; i < values.length; i++)
        {
            if (!"".equals(values[i]))
            {
                try
                {
                    longValues.add(Long.parseLong(values[i]));
                }
                catch (NumberFormatException e)
                {
                    Errors parseErrors = new Errors();

                    List<String> parameters = new ArrayList<>();
                    parameters.add(values[i]);
                    parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_LONG_INVALID", parameters));
                    allErrors.addError(metadataPath, parseErrors);
                }
            }
        }
        
        Long[] longArray = longValues.toArray(new Long[longValues.size()]);
        return new SimpleField<>(longArray);
    }
    
    /**
     * Bind and validate a geocode metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateGeocodeMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Double> localField = _bindGeoCodeField(localValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Double> extField = _bindGeoCodeField(extValues);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindGeoCodeField(metadataValues);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        
        // TODO Validate metadata. Need a DoubleValidator ??
        
        if (field != null)
        {
            field.setMode(metadataMode);
            form.setField(metadataName, field);
        }
    }
    
    /**
     * Bind a geocode field from form values
     * @param values the form values
     * @return The geocode field
     */
    protected SimpleField<Double> _bindGeoCodeField (String[] values)
    {
        if (values.length > 0)
        {
            Map<String, Object> geocodeValues = _jsonUtils.convertJsonToMap(values[0]);
            
            Double longitude = (Double) geocodeValues.get("longitude");
            Double latitude = (Double) geocodeValues.get("latitude");
            
            if (longitude != null && latitude != null)
            {
                return new SimpleField<>(new Double[]{longitude, latitude});
            }
        }
        return null;
    }

    /**
     * Bind and validate a double metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateDoubleMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Double> localField = _bindDoubleField(localValues, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Double> extField = _bindDoubleField(extValues, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindDoubleField(metadataValues, metadataPath, allErrors);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);
        
        Double[] values = field instanceof ExternalizableField ? ((SimpleField<Double>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Double>) field).getValues();
        
        Double[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<Double>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (externalizable || values.length != 0)
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind a double field from form values
     * @param values the form values
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The double field
     */
    protected SimpleField<Double> _bindDoubleField (String[] values, String metadataPath, AllErrors allErrors)
    {
        List<Double> doubleValues = new ArrayList<>();
        
        for (int i = 0; i < values.length; i++)
        {
            if (!"".equals(values[i]))
            {
                try
                {
                    doubleValues.add(Double.parseDouble(values[i]));
                }
                catch (NumberFormatException e)
                {
                    Errors parseErrors = new Errors();

                    List<String> parameters = new ArrayList<>();
                    parameters.add(values[i]);
                    parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_DOUBLE_INVALID", parameters));
                    allErrors.addError(metadataPath, parseErrors);
                }
            }
        }
        
        Double[] doubleArray = doubleValues.toArray(new Double[doubleValues.size()]);
        return new SimpleField<>(doubleArray);
    }

    /**
     * Bind and validate a boolean metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateBooleanMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Boolean> localField = _bindBooleanField(localValues, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Boolean> extField = _bindBooleanField(extValues, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindBooleanField(metadataValues, metadataPath, allErrors);
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);

        Boolean[] values = field instanceof ExternalizableField ? ((SimpleField<Boolean>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Boolean>) field).getValues();
        
        Boolean[] valuesToValidate = values;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            valuesToValidate = ((SimpleField<Boolean>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (metadataDefinition.isMultiple())
            {
                form.setField(metadataName, field);
            }
            else
            {
                if (values.length != 0)
                {
                    form.setField(metadataName, field);
                }
            }
        }
    }
    
    /**
     * Bind a boolean field from form values
     * @param values the form values
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The boolean field
     */
    protected SimpleField<Boolean> _bindBooleanField (String[] values, String metadataPath, AllErrors allErrors)
    {
        List<Boolean> booleanValues = new ArrayList<>();
        
        for (int i = 0; i < values.length; i++)
        {
            try
            {
                booleanValues.add(Boolean.parseBoolean(values[i]));
            }
            catch (NumberFormatException e)
            {
                Errors parseErrors = new Errors();
                
                List<String> parameters = new ArrayList<>();
                parameters.add(values[i]);
                parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_BOOLEAN_INVALID", parameters));
                allErrors.addError(metadataPath, parseErrors);
            }
        }
        
        Boolean[] boolArray = booleanValues.toArray(new Boolean[booleanValues.size()]);
        return new SimpleField<>(boolArray);
    }

    /**
     * Bind and validate a binary metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateBinaryMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        // FIXME metadataPath is the right metadata path ?
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        
        String[] realValues = new String[0];
        String[] valuesToValidate = new String[0];
        
        AbstractField field = null;
        if (externalizable)
        {
            realValues = _getLocalValues((String) rawValue, metadataDefinition);
            BinaryField localField = _bindBinaryField(realValues, metadataParamsPrefix, rawValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            BinaryField extField = _bindBinaryField(extValues, metadataParamsPrefix, rawValues);
            
            ExternalizableMetadataStatus status = _getExternalizableStatus((String) rawValue);
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
            
            valuesToValidate = status == ExternalizableMetadataStatus.EXTERNAL ? extValues : realValues;
        }
        else
        {
            realValues = _getMetadataValues(rawValue, metadataDefinition);
            valuesToValidate = realValues;
            field = _bindBinaryField(realValues, metadataParamsPrefix, rawValues);
        }
        
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);

        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (externalizable || (realValues.length > 0 && !realValues[0].equals("")))
            {
                form.setField(metadataName, field);
            }
        }
    }
    
    /**
     * Bind a binary field from form values
     * @param values the form values
     * @param metadataParamsPrefix the prefix for metadata
     * @param rawValues The raw values
     * @return The binary field
     */
    protected BinaryField _bindBinaryField (String[] values, String metadataParamsPrefix, Map<String, Object> rawValues)
    {
        BinaryField field = new BinaryField(values);
        
        BinaryMetadata binaryValue = (BinaryMetadata) rawValues.get(metadataParamsPrefix + ".rawValue");
        if (binaryValue != null)
        {
            field.setBinaryValue(binaryValue);
        }
        
        return field;
    }
    
    /**
     * Bind and validate a file metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateFileMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        // FIXME metadataPath is the right metadata path ?
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        
        String[] realValues = new String[0];
        String[] valuesToValidate = new String[0];
        
        SimpleField<String> typeField = null;
        
        AbstractField field = null;
        if (externalizable)
        {
            realValues = _getLocalValues((String) rawValue, metadataDefinition);
            
            Map<String, Object> fileValues = _jsonUtils.convertJsonToMap(realValues[0]);
            String fileType = (String) fileValues.get("type");
            
            AbstractField localField;
            if (EXPLORER_FILE.equals(fileType))
            {
                String fileId = (String) fileValues.get("id");
                localField = new SimpleField<>(new String[]{fileId});
                typeField = new SimpleField<>(new String[]{EXPLORER_FILE});
            }
            else if (METADATA_FILE.equals(fileType))
            {
                String uploadId = (String) fileValues.get("id");
                localField = _bindBinaryField(new String[]{uploadId}, metadataParamsPrefix, rawValues);
                typeField = new SimpleField<>(new String[]{METADATA_FILE});
            }
            else
            {
                localField = new SimpleField<>(null);
            }
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            Map<String, Object> extFileValues = _jsonUtils.convertJsonToMap(realValues[0]);
            String extFileType = (String) extFileValues.get("type");
            
            AbstractField extField;
            if (EXPLORER_FILE.equals(extFileType))
            {
                String fileId = (String) extFileValues.get("id");
                extField = new SimpleField<>(new String[]{fileId});
            }
            else if (METADATA_FILE.equals(extFileType))
            {
                String uploadId = (String) extFileValues.get("id");
                extField = _bindBinaryField(new String[]{uploadId}, metadataParamsPrefix, rawValues);
            }
            else
            {
                extField = new SimpleField<>(null);
            }
            
            ExternalizableMetadataStatus status = _getExternalizableStatus((String) rawValue);
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
            
            valuesToValidate = status == ExternalizableMetadataStatus.EXTERNAL ? extValues : realValues;
        }
        else
        {
            realValues = _getMetadataValues(rawValue, metadataDefinition);
            valuesToValidate = realValues;
            
            if (realValues.length > 0)
            {
                Map<String, Object> fileValues = _jsonUtils.convertJsonToMap(realValues[0]);
                String fileType = (String) fileValues.get("type");
                if (EXPLORER_FILE.equals(fileType))
                {
                    String fileId = (String) fileValues.get("id");
                    field = new SimpleField<>(new String[]{fileId});
                    typeField = new SimpleField<>(new String[]{EXPLORER_FILE});
                }
                else if (METADATA_FILE.equals(fileType))
                {
                    String uploadId = (String) fileValues.get("id");
                    field = _bindBinaryField(new String[]{uploadId}, metadataParamsPrefix, rawValues);
                    typeField = new SimpleField<>(new String[]{METADATA_FILE});
                }
                else
                {
                    field = new SimpleField<>(null);
                }
            }
            else
            {
                field = new SimpleField<>(null);
            }
        }
        
        field.setMode(metadataMode);

        if (typeField != null)
        {
            typeField.setMode(metadataMode);
            form.setField(metadataDefinition.getName() + "#type", typeField);
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate))
        {
            if (externalizable || (realValues.length > 0 && !realValues[0].equals("")))
            {
                form.setField(metadataName, field);
            }
        }
    }
    
    /**
     * Bind and validate a rich text metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateRichText(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            RichTextField localField = _bindRichTextField(localValues, metadataParamsPrefix, rawValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            RichTextField extField = _bindRichTextField(extValues, metadataParamsPrefix, rawValues);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindRichTextField(metadataValues, metadataParamsPrefix, rawValues);
        }
        
        String value = field instanceof ExternalizableField ? ((RichTextField) ((ExternalizableField) field).getLocalField()).getContent() : ((RichTextField) field).getContent();
        
        String valueToValidate = value;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            value = ((RichTextField) ((ExternalizableField) field).getExternalField()).getContent();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valueToValidate))
        {
            String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
            field.setMode(metadataMode);
            form.setField(metadataName, field);
        }
    }
    
    /**
     * Bind a richtext field from form values
     * @param values the form values
     * @param metadataParamsPrefix the prefix for metadata
     * @param rawValues The raw values
     * @return The richtext field
     */
    protected RichTextField _bindRichTextField (String[] values, String metadataParamsPrefix, Map<String, Object> rawValues)
    {
        if (values.length > 0 && !values[0].equals(""))
        {
            RichTextField field = new RichTextField(values[0]);
            
            String format = (String) rawValues.get(metadataParamsPrefix + ".format");
            if (StringUtils.isEmpty(format))
            {
                format = "html";
            }
            field.setFormat(format);
            
            @SuppressWarnings("unchecked")
            Map<String, Resource> addData = (Map<String, Resource>) rawValues.get(metadataParamsPrefix + ".additionalData");
            if (addData != null)
            {
                field.setAdditionalData(addData);
            }
            
            return field;
        }
        return new RichTextField(null);
    }

    /**
     * Bind and validate a reference metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateReferenceMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            ReferenceField localField = _bindReferenceField(localValues);
            
            String[] extValues = _getLocalValues((String) rawValue, metadataDefinition);
            ReferenceField extField = _bindReferenceField(extValues);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindReferenceField(metadataValues);
        }
        
        String value = field instanceof ExternalizableField ? ((ReferenceField) ((ExternalizableField) field).getLocalField()).getValue() : ((ReferenceField) field).getValue();
        
        String valueToValidate = value;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            value = ((ReferenceField) ((ExternalizableField) field).getExternalField()).getValue();
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valueToValidate))
        {
            if (StringUtils.isNotEmpty(value))
            {
                form.setField(metadataName, field);
            }
        }
    }
    
    /**
     * Bind a reference field from form values
     * @param values the form values
     * @return The reference field
     */
    protected ReferenceField _bindReferenceField (String[] values)
    {
        Map<String, Object> refValues = Collections.emptyMap();
        if (values.length > 0)
        {
            refValues = _jsonUtils.convertJsonToMap(values[0]);
        }
        
        return new ReferenceField(refValues);
    }
    
    /**
     * Bind and validate a content reference metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values of the form
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _bindAndValidateContentReferenceMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        String cTypeId = metadataDefinition.getContentType();
        Collection<String> validContentTypes = new HashSet<>();
        if (cTypeId != null)
        {
            validContentTypes.add(cTypeId);
            validContentTypes.addAll(_contentTypeExtensionPoint.getSubTypes(cTypeId));
        }
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SimpleField<Content> localField = _bindContentField(localValues, cTypeId, validContentTypes, metadataPath, allErrors);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SimpleField<Content> extField = _bindContentField(extValues, cTypeId, validContentTypes, metadataPath, allErrors);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindContentField(metadataValues, cTypeId, validContentTypes, metadataPath, allErrors);
        }
        
        Content[] contentValues = field instanceof ExternalizableField ? ((SimpleField<Content>) ((ExternalizableField) field).getLocalField()).getValues() : ((SimpleField<Content>) field).getValues();
        Content[] contentValuesToValidate = contentValues;
        if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
        {
            // Validate external values
            contentValuesToValidate = ((SimpleField<Content>) ((ExternalizableField) field).getExternalField()).getValues();
        }
        
        String metadataParamsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
        String metadataMode = (String) rawValues.get(metadataParamsPrefix + ".mode");
        field.setMode(metadataMode);
        
        List<Content> oldValues = _getContentValues(content.getMetadataHolder(), metadataPath);
        List<Content> valuesToValidate = new ArrayList<>();
        
        if (field.getMode() == MODE.INSERT && metadataDefinition.isMultiple())
        {
            valuesToValidate.addAll(oldValues);
            valuesToValidate.addAll(Arrays.asList(contentValues));
        }
        else if (field.getMode() == MODE.REMOVE)
        {
            valuesToValidate.addAll(oldValues);
            valuesToValidate.removeAll(Arrays.asList(contentValues));
        }
        else
        {
            valuesToValidate.addAll(Arrays.asList(contentValuesToValidate));
        }
        
        if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, valuesToValidate.toArray(new Content[valuesToValidate.size()])))
        {
            if (metadataDefinition.isMultiple() || externalizable || contentValues.length > 0)
            {
                form.setField(metadataName, field);
            }
        }
    }
    
    /**
     * Bind a content field from form values
     * @param values the form values
     * @param cTypeId The id of content type
     * @param validContentTypes The valid content types
     * @param metadataPath The path of metadata
     * @param allErrors for storing validation errors.
     * @return The content field
     */
    protected SimpleField<Content> _bindContentField (String[] values, String cTypeId, Collection<String> validContentTypes, String metadataPath, AllErrors allErrors)
    {
        Set<Content> contentList = new LinkedHashSet<>();
        
        for (String value : values)
        {
            if (StringUtils.isNotEmpty(value))
            {
                try
                {
                    AmetysObject ao = _resolver.resolveById(value);
                    
                    if (ao instanceof Content)
                    {
                        Content contentMeta = (Content) ao;
                        
                        String[] contentCTypes = ArrayUtils.addAll(contentMeta.getTypes(), contentMeta.getMixinTypes());
                        if (cTypeId != null && CollectionUtils.intersection(validContentTypes, Arrays.asList(contentCTypes)).isEmpty())
                        {
                            Errors parseErrors = new Errors();
                            
                            List<String> parameters = new ArrayList<>();
                            parameters.add(contentMeta.getTitle());
                            parameters.add(contentMeta.getId());
                            parameters.add(cTypeId);
                            parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_CONTENTREFERENCE_BADTYPED", parameters));
                            allErrors.addError(metadataPath, parseErrors);
                        }
                        else
                        {
                            contentList.add(contentMeta);
                        }
                    }
                    else
                    {
                        Errors parseErrors = new Errors();
                        
                        List<String> parameters = new ArrayList<>();
                        parameters.add(value);
                        parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_CONTENTREFERENCE_NOTCONTENT", parameters));
                        allErrors.addError(metadataPath, parseErrors);
                    }
                }
                catch (AmetysRepositoryException e)
                {
                    _logger.error(String.format("Content reference invalid at path '%s', value '%s'", metadataPath, value), e);
                    
                    Errors parseErrors = new Errors();
                    
                    List<String> parameters = new ArrayList<>();
                    parameters.add(value);
                    parseErrors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_CONTENTREFERENCE_INVALID", parameters));
                    allErrors.addError(metadataPath, parseErrors);
                }
            }
        }
        
        Content[] contentValues = contentList.toArray(new Content[contentList.size()]);
        
        return new SimpleField<>(contentValues);
    }
    
    /**
     * Get the content values
     * @param compositeMetadata The composite metadata
     * @param metadataPath The path of metadata
     * @return the list of content values
     */
    protected List<Content> _getContentValues (CompositeMetadata compositeMetadata, String metadataPath)
    {
        List<Content> values = new ArrayList<>();
        
        String[] pathSegments = StringUtils.split(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
        
        if (pathSegments.length == 0)
        {
            return values;
        }
        
        CompositeMetadata parentCompositeMetadata = compositeMetadata;
        for (int i = 1;  i < pathSegments.length - 1; i++)
        {
            if (parentCompositeMetadata.hasMetadata(pathSegments[i]))
            {
                parentCompositeMetadata = parentCompositeMetadata.getCompositeMetadata(pathSegments[i]);
            }
            else
            {
                // Metadata does not exist, no content values
                return values;
            }
        }
        
        if (parentCompositeMetadata.hasMetadata(pathSegments[pathSegments.length - 1]))
        { 
            String[] contentIds = parentCompositeMetadata.getStringArray(pathSegments[pathSegments.length - 1], new String[0]);
            for (String contentId : contentIds)
            {
                try
                {
                    Content content = _resolver.resolveById(contentId);
                    values.add(content);
                }
                catch (UnknownAmetysObjectException e)
                {
                    _logger.warn("The content with id " + contentId + " does not exist anymore. It will be removed from metadata " + metadataPath);
                }
                catch (AmetysRepositoryException e)
                {
                    throw new AmetysRepositoryException("Cannot edit metadata '" + metadataPath + "'", e);
                }
            }
        }
        
        return values;
    }
    
    /**
     * Bind and validate a content metadata.
     * @param allErrors for storing validation errors.
     * @param form the form. 
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path from the content.
     * @param rawValue the submitted value.
     * @param rawValues the raw values.
     * @param externalizable <code>true</code> true if the metadata is an externalizable metadata (local and external value)
     * @throws AmetysRepositoryException if an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _bindAndValidateSubContentMetadata(AllErrors allErrors, Form form, Content content, MetadataDefinition metadataDefinition, String metadataPath, Object rawValue, Map<String, Object> rawValues, boolean externalizable) throws AmetysRepositoryException, WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        String cTypeId = metadataDefinition.getContentType();
        Collection<String> validContentTypes = new HashSet<>();
        if (cTypeId != null)
        {
            validContentTypes.add(cTypeId);
            validContentTypes.addAll(_contentTypeExtensionPoint.getSubTypes(cTypeId));
        }
        
        AbstractField field = null;
        if (externalizable)
        {
            String[] localValues = _getLocalValues((String) rawValue, metadataDefinition);
            SubContentField localField = _bindSubContentField(localValues, metadataDefinition, metadataPath, rawValues);
            
            String[] extValues = _getExternalValues((String) rawValue, metadataDefinition);
            SubContentField extField = _bindSubContentField(extValues, metadataDefinition, metadataPath, rawValues);
            
            field = new ExternalizableField(localField, extField, _getExternalizableStatus((String) rawValue));
        }
        else
        {
            String[] metadataValues = _getMetadataValues(rawValue, metadataDefinition);
            field = _bindSubContentField(metadataValues, metadataDefinition, metadataPath, rawValues);
        }
        
        if (field != null)
        {
            List<Map<String, Object>> contentValues = field instanceof ExternalizableField ? ((SubContentField) ((ExternalizableField) field).getLocalField()).getContentValues() : ((SubContentField) field).getContentValues();
            
            List<Map<String, Object>> contentValuesToValidate = contentValues;
            if (field instanceof ExternalizableField && ((ExternalizableField) field).getStatus() == ExternalizableMetadataStatus.EXTERNAL)
            {
                // Validate external values
                contentValuesToValidate = ((SubContentField) ((ExternalizableField) field).getExternalField()).getContentValues();
            }
            
            String paramsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
            String metadataMode = (String) rawValues.get(paramsPrefix + ".mode");
            field.setMode(metadataMode);
            
            if (_validateMetadata(content, metadataDefinition, metadataPath, allErrors, contentValuesToValidate))
            {
                form.setField(metadataName, field);
            }
            
        }
    }
    
    /**
     * Bind a sub-content field from form values
     * @param values the form values
     * @param metadataDef The metadata definition
     * @param metadataPath The path of metadata
     * @param rawValues The raw values
     * @return The sub-content field
     */
    protected SubContentField _bindSubContentField (String[] values, MetadataDefinition metadataDef, String metadataPath, Map<String, Object> rawValues)
    {
        List<Map<String, Object>> contentValues = new ArrayList<>();
        Set<String> contentIds = new HashSet<>();
        
        for (String metadataValue : values)
        {
            Map<String, Object> contentValue = _jsonUtils.convertJsonToMap(metadataValue);
            
            String contentId = null;
            if (contentValue.containsKey("id"))
            {
                // Avoid duplicates id
                contentId = (String) contentValue.get("id");
                if (!contentIds.contains(contentId))
                {
                    contentIds.add(contentId);
                    contentValues.add(contentValue);
                }
            }
            else
            {
                contentValues.add(contentValue);
            }
        }
        
        if (metadataDef.isMultiple() || !contentValues.isEmpty())
        {
            String paramsPrefix = INTERNAL_FORM_ELEMENTS_PREFIX + metadataPath.replace('/', '.');
            String contentLanguage = (String) rawValues.get(paramsPrefix + ".contentLanguage");
            Integer initWorkflowActionId = (Integer) rawValues.get(paramsPrefix + ".initWorkflowActionId");
            String workflowName = (String) rawValues.get(paramsPrefix + ".workflowName");
            
            SubContentField subContentField = new SubContentField(contentValues, contentLanguage);
            subContentField.setWorkflow(workflowName, initWorkflowActionId);
            
            return subContentField;
        }
        
        return null;
    }
    
    /**
     * Validate a metadata value.
     * @param content the content
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param allErrors the errors.
     * @param value the value.
     * @return <code>true</code> if the validation is successful,
     *         <code>false</code> otherwise.
     * @throws WorkflowException if an error occurs.
     */
    protected boolean _validateMetadata(Content content, MetadataDefinition metadataDefinition, String metadataPath, AllErrors allErrors, Object value) throws WorkflowException
    {
        Validator validator = metadataDefinition.getValidator();
        
        if (validator != null)
        {
            Errors errors = new Errors();
            
            if (value != null && value.getClass().isArray() && !metadataDefinition.isMultiple())
            {
                Object singleValue = null;
                if (Array.getLength(value) != 0)
                {
                    singleValue = Array.get(value, 0);
                }
                
                validator.validate(singleValue, errors);
            }
            else
            {
                validator.validate(value, errors);
            }
            
            if (errors.hasErrors())
            {
                allErrors.addError(metadataPath, errors);
                
                return false;
            }
        }
        
        return true;
    }

    /**
     * Prepare to synchronize a metadata with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @throws WorkflowException if an error occurs.
     * @throws AmetysRepositoryException If an error occurred 
     */
    protected void _prepareSynchronizeMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId) throws WorkflowException, AmetysRepositoryException
    {
        MetadataType type = metadataDefinition.getType();
        switch (type)
        {
            case CONTENT:
                _prepareSynchronizeContentReferenceMetadata(content, metadata, form, allErrors, user, metadataDefinition, metadataPath, invertEditActionId);
                break;

            case COMPOSITE:
                _prepareSynchronizeCompositeMetadata(content, metadata, form, allErrors, user, metadataSetElement, metadataDefinition, metadataPath, invertEditActionId);
                break;
                
            default:
                break;
        }
    }
    
    /**
     * Synchronize a metadata with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @param externalAndLocalMetadata The paths of local and externam metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        MetadataType type = metadataDefinition.getType();
        
        boolean externalizable = externalAndLocalMetadata.contains(metadataPath);
        
        switch (type)
        {
            case STRING:
                _synchronizeStringMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case USER:
                _synchronizeUserMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case DATE:
                _synchronizeDateMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case DATETIME:
                _synchronizeDateMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case LONG:
                _synchronizeLongMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case DOUBLE:
                _synchronizeDoubleMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case BOOLEAN:
                _synchronizeBooleanMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case BINARY:
                _synchronizeBinaryMetadata(metadata, form, allErrors, user, metadataDefinition, metadataPath, externalizable);
                break;
            case FILE:
                _synchronizeFileMetadata(metadata, form, allErrors, user, metadataDefinition, metadataPath, externalizable);
                break;
            case RICH_TEXT:
                _synchronizeRichTextMetadata(metadata, form, allErrors, user, metadataDefinition, metadataPath, externalizable);
                break;
            case CONTENT:
                _synchronizeContentReferenceMetadata(content, metadata, form, allErrors, user, metadataDefinition, metadataPath, invertEditActionId, externalizable);
                break;
            case SUB_CONTENT:
                _synchronizeSubContentMetadata(content, metadata, form, allErrors, user, metadataDefinition, metadataPath, externalizable);
                break;
            case GEOCODE:
                _synchronizeGeocodeMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case REFERENCE:
                _synchronizeReferenceMetadata(metadata, form, metadataDefinition, externalizable);
                break;
            case COMPOSITE:
                _synchronizeCompositeMetadata(content, metadata, form, allErrors, user, metadataSetElement, metadataDefinition, metadataPath, invertEditActionId, externalAndLocalMetadata);
                break;
            default:
                throw new WorkflowException("Unsupported type: " + type);
        }
        
        // Synchronize metadata comments
        _synchronizeMetadataComments(metadata, form, metadataDefinition);
    }
    
    /**
     * Synchronize the comments of a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     */
    protected void _synchronizeMetadataComments(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition)
    {
        String metadataName = metadataDefinition.getName();
        MetadataComment[] comments = form.getCommentArray(metadataName);
        
        if (metadata instanceof CommentableCompositeMetadata)
        {
            CommentableCompositeMetadata commentableMetadata = (CommentableCompositeMetadata) metadata;
            int index = 1;
            
            // Do not modify comments if no info. However, with an empty array, all existing comments will be removed.
            if (comments != null)
            {
                // Add / edit comments
                for (MetadataComment comment : comments)
                {
                    if (commentableMetadata.hasComment(metadataName, index))
                    {
                        commentableMetadata.editComment(metadataName, index, comment.getComment(), comment.getAuthor(), comment.getDate());
                    }
                    else
                    {
                        commentableMetadata.addComment(metadataName, comment.getComment(), comment.getAuthor(), comment.getDate());
                    }
                    
                    index++;
                }
                
                // Delete remaining comments
                while (commentableMetadata.hasComment(metadataName, index))
                {
                    commentableMetadata.deleteComment(metadataName, index);
                    index++;
                }
            }
        }

    }

    /**
     * Synchronize a composite-typed metadata with a a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param editActionId The action id for editing invert relation
     * @throws WorkflowException if an error occurs.
     */
    protected void _prepareSynchronizeCompositeMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition metadataDefinition, String metadataPath, int editActionId) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        if (metadataDefinition instanceof RepeaterDefinition)
        {
            _prepareSynchronizeRepeater(content, metadata, form, allErrors, user, metadataSetElement, (RepeaterDefinition) metadataDefinition, metadataPath, editActionId);
        }
        else 
        {
            Form compositeForm = form.getCompositeField(metadataName);
            
            if (compositeForm != null)
            {
                ModifiableCompositeMetadata subMetadata = metadata.getCompositeMetadata(metadataName, true);
                _prepareSynchronizeMetadataSetElement(content, subMetadata, compositeForm, allErrors, user, metadataSetElement, metadataDefinition, metadataPath + ContentConstants.METADATA_PATH_SEPARATOR, editActionId);
            }
            else
            {
                if (metadata.hasMetadata(metadataName))
                {
                    metadata.removeMetadata(metadataName);
                }
            }
        }
    }
    
    /**
     * Synchronize a composite-typed metadata with a a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param editActionId The action id for editing invert relation
     * @param externalAndLocalMetadata The paths of local and externam metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeCompositeMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, MetadataDefinition metadataDefinition, String metadataPath, int editActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        if (metadataDefinition instanceof RepeaterDefinition)
        {
            _synchronizeRepeater(content, metadata, form, allErrors, user, metadataSetElement, (RepeaterDefinition) metadataDefinition, metadataPath, editActionId, externalAndLocalMetadata);
        }
        else 
        {
            Form compositeForm = form.getCompositeField(metadataName);
            
            if (compositeForm != null)
            {
                ModifiableCompositeMetadata subMetadata = metadata.getCompositeMetadata(metadataName, true);
                _synchronizeMetadataSetElement(content, subMetadata, compositeForm, allErrors, user, metadataSetElement, metadataDefinition, metadataPath + ContentConstants.METADATA_PATH_SEPARATOR, editActionId, externalAndLocalMetadata);
            }
            else
            {
                if (metadata.hasMetadata(metadataName))
                {
                    metadata.removeMetadata(metadataName);
                }
            }
        }
    }
    
    /**
     * Synchronize a repeater with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @param invertActionId The current 'edit content' action ID.
     * @throws WorkflowException if an error occurs.
     */
    protected void _prepareSynchronizeRepeater(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, RepeaterDefinition repeaterDefinition, String metadataPath, int invertActionId) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        
        List<RepeaterEntry> entries = repeaterField.getEntries();
        
        ModifiableCompositeMetadata repeaterMetadata = metadata.getCompositeMetadata(metadataName, true);
        
        // Add new entries
        for (RepeaterEntry repeaterEntry : entries)
        {
            int computedPosition = _computeRepeaterEntryPosition(repeaterMetadata, repeaterEntry);

            try
            {
                ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(String.valueOf(computedPosition));
                _prepareSynchronizeMetadataSetElement(content, entryMetadata, repeaterEntry, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath + "/" + computedPosition + "/", invertActionId);
            }
            catch (UnknownMetadataException e)
            {
                ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(String.valueOf(computedPosition), true);
                _prepareSynchronizeMetadataSetElement(content, entryMetadata, repeaterEntry, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath + "/" + computedPosition + "/", invertActionId);

                // Then remove created entry
                repeaterMetadata.removeMetadata(String.valueOf(computedPosition));
            }
        }
    }
    
    
    /**
     * Synchronize a repeater with a composite metadata.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @param editActionId The current 'edit content' action ID.
     * @param externalAndLocalMetadata The paths of local and externam metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeRepeater(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, RepeaterDefinition repeaterDefinition, String metadataPath, int editActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        
        _checkRepeaterSize(metadata, form, allErrors, repeaterDefinition, metadataPath);

        switch (repeaterField.getMode())
        {
            case REPLACE:
                _synchronizeRepeaterInReplaceMode(content, metadata, form, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath, editActionId, externalAndLocalMetadata);
                break;
            case REMOVE:
                _synchronizeRepeaterInRemoveMode(content, metadata, form, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath);
                break;
            case INSERT:
            default:
                _synchronizeRepeaterInInsertMode(content, metadata, form, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath, editActionId, externalAndLocalMetadata);
                break;
        }
    }
    
    /**
     * Check the repeater size will be correct
     * @param metadata The metadata values
     * @param form the form
     * @param allErrors the list of errors
     * @param repeaterDefinition the definition of the repeater
     * @param metadataPath The path of the metadata
     */
    protected void _checkRepeaterSize(ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, RepeaterDefinition repeaterDefinition, String metadataPath)
    {
        String metadataName = repeaterDefinition.getName();
        ModifiableCompositeMetadata repeaterMetadata = metadata.getCompositeMetadata(metadataName, true);
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        
        // Check size
        int minSize = repeaterDefinition.getMinSize();
        
        int newSize = (repeaterField.getMode() == MODE.REPLACE ? repeaterField.getEntries().size() : repeaterMetadata.getMetadataNames().length)
                + (repeaterField.getMode() == MODE.INSERT ? repeaterField.getEntries().size() : 0)
                + (repeaterField.getMode() == MODE.REMOVE ? -repeaterField.getEntries().size() : 0);

        // Min size validation
        if (newSize < minSize)
        {
            Errors errors = new Errors();
            
            List<String> parameters = new ArrayList<>();
            parameters.add(metadataName);
            parameters.add(Integer.toString(minSize));
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_REPEATER_MINSIZE", parameters));
            allErrors.addError(metadataPath, errors);
        }
        // Max size validation
        int maxSize = repeaterDefinition.getMaxSize();
        if (maxSize > 0 && newSize > maxSize)
        {
            Errors errors = new Errors();

            List<String> parameters = new ArrayList<>();
            parameters.add(metadataName);
            parameters.add(Integer.toString(maxSize));
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_REPEATER_MAXSIZE", parameters));
            allErrors.addError(metadataPath, errors);
        }
    }

    /**
     * Synchronize a repeater with a composite metadata, when the values has to be added to existing ones.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @param editActionId The current 'edit content' action ID.
     * @param externalAndLocalMetadata The paths of local and externam metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeRepeaterInInsertMode(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, RepeaterDefinition repeaterDefinition, String metadataPath, int editActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        List<RepeaterEntry> entries = repeaterField.getEntries();
        
        ModifiableCompositeMetadata repeaterMetadata = metadata.getCompositeMetadata(metadataName, true);
        
        // Add new entries
        for (RepeaterEntry repeaterEntry : entries)
        {
            int computedPosition = _computeRepeaterEntryPosition(repeaterMetadata, repeaterEntry);
            
            // Is somebody in the way?
            for (int i = repeaterMetadata.getMetadataNames().length; i >= computedPosition; i--)
            {
                // move to the next position
                _moveRepeaterEntry(repeaterMetadata, String.valueOf(i), String.valueOf(i + 1));
            }

            // New entry (computedPosition is free)
            ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(String.valueOf(computedPosition), true);
            _synchronizeMetadataSetElement(content, entryMetadata, repeaterEntry, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath + "/" + computedPosition + "/", editActionId, externalAndLocalMetadata);
        }
    }

    /**
     * Synchronize a repeater with a composite metadata, when the values has to removed from existing ones.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeRepeaterInRemoveMode(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, RepeaterDefinition repeaterDefinition, String metadataPath) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        List<RepeaterEntry> entries = repeaterField.getEntries();
        
        ModifiableCompositeMetadata repeaterMetadata = metadata.getCompositeMetadata(metadataName, true);
        
        // Add new entries
        for (RepeaterEntry repeaterEntry : entries)
        {
            int computedPosition = _computeRepeaterEntryPosition(repeaterMetadata, repeaterEntry);

            // remove
            repeaterMetadata.removeMetadata(String.valueOf(computedPosition));

            // Is there a hole?
            for (int i = computedPosition + 1; i < repeaterMetadata.getMetadataNames().length; i++)
            {
                // move to the next position
                _moveRepeaterEntry(repeaterMetadata, String.valueOf(i), String.valueOf(i - 1));
            }
        }

    }

    private int _computeRepeaterEntryPosition(ModifiableCompositeMetadata repeaterMetadata, RepeaterEntry repeaterEntry)
    {
        int position = repeaterEntry.getPosition();
        // -1, -2, -3... means 1, 2, 3 before the end
        // 0 means at the end
        // 1, 2, 3... means at position 1, 2 or 3
        int computedPosition;
        if (position > 0)
        {
            computedPosition = position;
        }
        else
        {
            computedPosition = repeaterMetadata.getMetadataNames().length + 1 - position;
        }
        
        computedPosition = Math.max(Math.min(computedPosition, repeaterMetadata.getMetadataNames().length + 1), 1);
        return computedPosition;
    }
    
    /**
     * Synchronize a repeater with a composite metadata, when the values has to replace existing ones.
     * @param content the content.
     * @param metadata the composite metadata to synchronize.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataSetElement the metadata set element for this metadata.
     * @param repeaterDefinition the repeater definition.
     * @param metadataPath the metadata path.
     * @param editActionId The current 'edit content' action ID.
     * @param externalAndLocalMetadata The paths of local and externam metadata
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeRepeaterInReplaceMode(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, AbstractMetadataSetElement metadataSetElement, RepeaterDefinition repeaterDefinition, String metadataPath, int editActionId, Set<String> externalAndLocalMetadata) throws WorkflowException
    {
        String metadataName = repeaterDefinition.getName();
        RepeaterField repeaterField = form.getRepeaterField(metadataName);
        List<RepeaterEntry> entries = repeaterField.getEntries();
        Map<String, String> laterMoves = new HashMap<>();
        
        ModifiableCompositeMetadata repeaterMetadata = metadata.getCompositeMetadata(metadataName, true);

        for (String entryName : repeaterMetadata.getMetadataNames())
        {
            // Only process composite metadata
            if (repeaterMetadata.getType(entryName) == org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.COMPOSITE)
            {
                // -1 is returns for custom composite metadata on a repeater which is not an entry
                int currentPosition = NumberUtils.toInt(entryName, -1);

                if (currentPosition != -1)
                {
                    RepeaterEntry repeaterEntry = _getEntry(entries, entryName);
                    
                    if (repeaterEntry == null)
                    {
                        // Do additional processing to remove entry sub-metadatas.
                        ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(entryName);
                        _synchronizeMetadataRemoval(content, entryMetadata, repeaterEntry, allErrors, user, repeaterDefinition, metadataPath + "/" + entryName + "/", editActionId);
                        
                        // This entry does not exist anymore
                        repeaterMetadata.removeMetadata(entryName);
                    }
                    else
                    {
                        int newPosition = repeaterEntry.getPosition();
                        
                        // Check if position has changed
                        if (newPosition != currentPosition)
                        {
                            String finalEntryName = String.valueOf(newPosition);
                            String tempEntryName = finalEntryName;
                            
                            // Check if there is already an entry by that name
                            if (!repeaterMetadata.hasMetadata(String.valueOf(newPosition)))
                            {
                                // Move the composite to the new name
                                _moveRepeaterEntry(repeaterMetadata, entryName, finalEntryName);
                            }
                            else
                            {
                                // Move to a temporary name
                                tempEntryName = "temp-" + String.valueOf(newPosition);
                                _moveRepeaterEntry(repeaterMetadata, entryName, tempEntryName);
                                // Keep in mind for later move
                                laterMoves.put(tempEntryName, finalEntryName);
                            }
                        }
                    }
                }
            }
        }
        
        // Process moves
        for (Map.Entry<String, String> move : laterMoves.entrySet())
        {
            // Move to a temporary name
            _moveRepeaterEntry(repeaterMetadata, move.getKey(), move.getValue());
        }

        for (String entryName : repeaterMetadata.getMetadataNames())
        {
            // Only process composite metadata
            if (repeaterMetadata.getType(entryName) == org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.COMPOSITE)
            {
                int currentPosition = NumberUtils.toInt(entryName, -1);

                if (currentPosition != -1)
                {
                    RepeaterEntry repeaterEntry = _getCurrentEntry(entries, entryName);
                    
                    if (repeaterEntry != null)
                    {
                        // Synchronization
                        ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(entryName, true);
                        _synchronizeMetadataSetElement(content, entryMetadata, repeaterEntry, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath + "/" + entryName + "/", editActionId, externalAndLocalMetadata);
                    }
                }
            }
        }
        
        // Creates new entries
        for (RepeaterEntry repeaterEntry : entries)
        {
            if (repeaterEntry.getPreviousPosition() == -1)
            {
                int position = repeaterEntry.getPosition();
                // New entry
                ModifiableCompositeMetadata entryMetadata = repeaterMetadata.getCompositeMetadata(String.valueOf(position), true);
                _synchronizeMetadataSetElement(content, entryMetadata, repeaterEntry, allErrors, user, metadataSetElement, repeaterDefinition, metadataPath + "/" + position + "/", editActionId, externalAndLocalMetadata);
            }
        }
    }
    
    /**
     * Do additional processing to remove entry sub-metadatas.
     * @param content the processed content.
     * @param metadata the composite metadata being removed.
     * @param form the form.
     * @param allErrors the errors.
     * @param user the user.
     * @param parentMetadataDefinition the parent metadata definition.
     * @param metadataPath the metadata path.
     * @param editActionId The current 'edit content' action ID.
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeMetadataRemoval(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition parentMetadataDefinition, String metadataPath, int editActionId) throws WorkflowException
    {
        // Currently only purpose is to handle
        if (_invertRelationEnabled())
        {
            // Use the real metadatas instead of the metadata-set, because they will be physically removed
            // even if they aren't in the metadata-set.
            for (String subMetadataName : parentMetadataDefinition.getMetadataNames())
            {
                MetadataDefinition metadataDefinition = parentMetadataDefinition.getMetadataDefinition(subMetadataName);
                if (metadataDefinition != null)
                {
                    String subMetadataPath = metadataPath + subMetadataName;
                    if (metadata.hasMetadata(subMetadataName))
                    {
                        if (metadataDefinition.getType() == MetadataType.COMPOSITE)
                        {
                            // Recurse in composites.
                            ModifiableCompositeMetadata compositeMetadata = metadata.getCompositeMetadata(subMetadataName);
                            _synchronizeMetadataRemoval(content, compositeMetadata, form, allErrors, user, metadataDefinition, subMetadataPath + "/", editActionId);
                        }
                        else if (metadataDefinition.getType() == MetadataType.CONTENT)
                        {
                            // In case of existing mutual relationship, remove it.
                            String[] refContentIds = metadata.getStringArray(subMetadataName, new String[0]);
                            _removeInvertRelations(content.getId(), metadataDefinition, subMetadataPath, refContentIds, editActionId, allErrors);
                        }
                    }
                }
            }
        }
    }
    
    /**
     * Move a repeater entry.
     * @param metadata the parent composite metadata.
     * @param fromName the current entry name.
     * @param toName the new entry name.
     * @throws WorkflowException if an error occurs.
     */
    protected void _moveRepeaterEntry(CompositeMetadata metadata, String fromName, String toName) throws WorkflowException
    {
        // FIXME movablemetadata
        if (!(metadata instanceof JCRCompositeMetadata))
        {
            throw new WorkflowException("Unable to manage non JCR composite metadata: " + metadata);
        }
        
        try
        {
            Node node = ((JCRCompositeMetadata) metadata).getNode();
            node.getSession().move(node.getNode(JCRCompositeMetadata.METADATA_PREFIX + fromName).getPath(),
                                   node.getPath() + "/" + JCRCompositeMetadata.METADATA_PREFIX + toName);
        }
        catch (RepositoryException e)
        {
            throw new WorkflowException("Unable to move repeater entry", e);
        }
    }

    /**
     * Retrieves a repeater entry corresponding to an entry name.
     * @param entries the entries.
     * @param entryName the entry name.
     * @return the entry found or <code>null</code> otherwise.
     */
    protected RepeaterEntry _getEntry(List<RepeaterEntry> entries, String entryName)
    {
        int position = Integer.valueOf(entryName);
        
        for (RepeaterEntry entry : entries)
        {
            int previousPosition = entry.getPreviousPosition();
            
            if (previousPosition != -1 && previousPosition == position)
            {
                return entry;
            }
        }
        
        // Not found
        return null;
    }

    /**
     * Retrieves a repeater entry corresponding to an entry name.
     * @param entries the entries.
     * @param entryName the entry name.
     * @return the entry found or <code>null</code> otherwise.
     */
    protected RepeaterEntry _getCurrentEntry(List<RepeaterEntry> entries, String entryName)
    {
        int seekPosition = Integer.valueOf(entryName);
        
        for (RepeaterEntry entry : entries)
        {
            int position = entry.getPosition();
            
            if (position != -1 && position == seekPosition)
            {
                return entry;
            }
        }
        
        // Not found
        return null;
    }
    
    /**
     * Synchronize a string metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeStringMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        SimpleField<String> field = form.getStringArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleStringMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleStringMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<String> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            String[] array = metadata.getStringArray(metadataName);
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }
            
            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }

    /**
     * Synchronize a user metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeUserMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<UserIdentity> field = form.getUserArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleUserMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateCompositeMetadataStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleUserMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<UserIdentity> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            UserIdentity[] array = metadata.getUserArray(metadataName);
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }
            
            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }

    /**
     * Synchronize a date metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeDateMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Date> field = form.getDateArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleDateMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleDateMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<Date> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            Date[] array = metadata.getDateArray(metadataName);
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }

            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }
    
    /**
     * Remove a metadata if exists.
     * Be careful ! If externalizable, this method have to be called after setting the current status.
     * @param metadata The parent composite metadata
     * @param metadataName The metadata name
     * @param externalizable <code>true</code> if externalizable
     */
    protected void _removeMetadataIfExists (ModifiableCompositeMetadata metadata, String metadataName, boolean externalizable)
    {
        if (externalizable)
        {
            ExternalizableMetadataHelper.removeLocalMetadataIfExists(metadata, metadataName);
        }
        else
        {
            if (metadata.hasMetadata(metadataName))
            {
                metadata.removeMetadata(metadataName);
            }
        }
    }

    /**
     * Synchronize a long metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeLongMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Long> field = form.getLongArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleLongMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleLongMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<Long> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            Long[] array = ArrayUtils.toObject(metadata.getLongArray(metadataName));
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }
            
            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }
    
    /**
     * Synchronize a geocode metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeGeocodeMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Double> field = form.getDoubleArray(metadataName);
        
        if (field != null && field.getValues() != null && field.getMode() != MODE.REMOVE)
        {
            ModifiableCompositeMetadata geoCode = null;
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                geoCode = ExternalizableMetadataHelper.setLocalCompositeMetadata(metadata, metadataName, status);
            }
            else
            {
                geoCode = ExternalizableMetadataHelper.getCompositeMetadata(metadata, metadataName);
            }
            
            geoCode.setMetadata("longitude", field.getValues()[0]);                       
            geoCode.setMetadata("latitude", field.getValues()[1]);
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateCompositeMetadataStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    /**
     * Synchronize a double metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeDoubleMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Double> field = form.getDoubleArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleDoubleMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleDoubleMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<Double> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            Double[] array = ArrayUtils.toObject(metadata.getDoubleArray(metadataName));
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }
            
            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }

    /**
     * Synchronize a boolean metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeBooleanMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Boolean> field = form.getBooleanArray(metadataName);
        
        if (field != null && field.getValues() != null && (metadataDefinition.isMultiple() || (field.getValues().length > 0 && field.getValues()[0] != null)))
        {
            if (metadataDefinition.isMultiple())
            {
                _synchronizeMultipleBooleanMetadata(metadata, form, externalizable, metadataName, field);
            }
            else 
            {
                if (field.getMode() == MODE.REMOVE)
                {
                    metadata.removeMetadata(metadataName);
                }
                else
                {
                    _setMetadata(metadata, metadataName, form, field.getValues()[0], externalizable);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    private void _synchronizeMultipleBooleanMetadata(ModifiableCompositeMetadata metadata, Form form, boolean externalizable, String metadataName, SimpleField<Boolean> field)
    {
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT && !metadata.hasMetadata(metadataName))
        {
            _setMetadata(metadata, metadataName, form, field.getValues(), externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            Boolean[] array = ArrayUtils.toObject(metadata.getBooleanArray(metadataName));
            if (field.getMode() == MODE.INSERT)
            {
                array = ArrayUtils.addAll(array, field.getValues());
            }
            else
            {
                array = ArrayUtils.removeElements(array, field.getValues());
            }
            
            if (array.length > 0)
            {
                _setMetadata(metadata, metadataName, form, array, externalizable);
            }
            else
            {
                _removeMetadataIfExists(metadata, metadataName, externalizable);
            }
        }
    }

    /**
     * Synchronize a binary metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeBinaryMetadata(ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        BinaryField field = form.getBinaryField(metadataName);
        
        if (field != null && field.getValues() != null)
        {
            String uploadId = field.getValues()[0];
            
            if (field.hasBinaryValue())
            {
                // Set the value from an existing metadata.
                BinaryMetadata binaryValue = field.getBinaryValue();
                
                ModifiableBinaryMetadata binaryMetadata = null;
                if (externalizable)
                {
                    ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                    binaryMetadata = ExternalizableMetadataHelper.setLocalBinaryMetadata(metadata, metadataName, status);
                }
                else
                {
                    binaryMetadata = ExternalizableMetadataHelper.getBinaryMetadata(metadata, metadataName);
                }
                
                binaryMetadata.setFilename(binaryValue.getFilename());
                binaryMetadata.setMimeType(binaryValue.getMimeType());
                binaryMetadata.setEncoding(binaryValue.getEncoding());
                binaryMetadata.setLastModified(binaryValue.getLastModified());
                binaryMetadata.setInputStream(binaryValue.getInputStream());
            }
            else if (!uploadId.equals(UNTOUCHED_BINARY))
            {
                try
                {
                    Upload upload = _uploadManager.getUpload(user, uploadId);
                    ModifiableBinaryMetadata binaryMetadata = null;
                    if (externalizable)
                    {
                        ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                        binaryMetadata = ExternalizableMetadataHelper.setLocalBinaryMetadata(metadata, metadataName, status);
                    }
                    else
                    {
                        binaryMetadata = ExternalizableMetadataHelper.getBinaryMetadata(metadata, metadataName);
                    }
                    
                    binaryMetadata.setFilename(upload.getFilename());
                    binaryMetadata.setMimeType(upload.getMimeType());
                    binaryMetadata.setLastModified(upload.getUploadedDate());
                    binaryMetadata.setInputStream(upload.getInputStream());
                }
                catch (NoSuchElementException e)
                {
                    Errors errors = new Errors();
                    
                    List<String> parameters = new ArrayList<>();
                    parameters.add(uploadId);
                    parameters.add(metadataPath);
                    errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_UPLOAD_MISSING", parameters));
                    allErrors.addError(metadataPath, errors);
                }
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateBinaryMetadataStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }
    
    /**
     * Synchronize a file metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeFileMetadata(ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<String> field = form.getStringArray(metadataName);
        
        if (field != null && field.getValues() != null)
        {
            String fileType = form.getStringArray(metadataName + "#type").getValues()[0];
            String localMetadataName = metadataName;
            if (externalizable)
            {
                localMetadataName = ExternalizableMetadataHelper.getMetadataName(metadata, metadataName, ExternalizableMetadataStatus.LOCAL);
            }
            
            if (METADATA_FILE.equals(fileType))
            {
                try
                {
                    // Remove string metadata if exists
                    metadata.getString(localMetadataName);
                    metadata.removeMetadata(localMetadataName);
                }
                catch (UnknownMetadataException e)
                {
                    // Do nothing
                }
                
                _synchronizeBinaryMetadata(metadata, form, allErrors, user, metadataDefinition, metadataPath, externalizable);
            }
            else if (EXPLORER_FILE.equals(fileType))
            {
                try
                {
                    metadata.getBinaryMetadata(localMetadataName, false);
                    metadata.removeMetadata(localMetadataName);
                }
                catch (UnknownMetadataException e)
                {
                    // Do nothing
                }
                
                _synchronizeStringMetadata(metadata, form, metadataDefinition, externalizable);
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                String localMetadataName = ExternalizableMetadataHelper.getMetadataName(metadata, metadataName, ExternalizableMetadataStatus.LOCAL);
                try
                {
                    metadata.getBinaryMetadata(localMetadataName, false);
                    ExternalizableMetadataHelper.updateBinaryMetadataStatus(metadata, metadataName, status);
                }
                catch (UnknownMetadataException e)
                {
                    // Do nothing
                }
                
                try
                {
                    metadata.getString(localMetadataName);
                    ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
                }
                catch (UnknownMetadataException e)
                {
                    // Do nothing
                }
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }
    
    /**
     * Prepare to synchronize a content reference metadata from a field.
     * @param content the content.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @throws AmetysRepositoryException If an error occurs.
     * @throws WorkflowException if an error occurs.
     */
    protected void _prepareSynchronizeContentReferenceMetadata (Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId) throws AmetysRepositoryException, WorkflowException
    {
        try
        {
            if (_invertRelationEnabled() && StringUtils.isNotEmpty(metadataDefinition.getInvertRelationPath()))
            {
                String metadataName = metadataDefinition.getName();
                SimpleField<Content> field = form.getContentArray(metadataName);
                
                if (field != null && field.getValues() != null)
                {
                    Content[] values = field.getValues();
                    
                    String[] contentIds = new String[values.length];
                    for (int i = 0; i < values.length; i++)
                    {
                        contentIds[i] = values[i].getId();
                    }
                    
                    String[] oldValues = metadata.getStringArray(metadataName, new String[0]);
                    String[] newRefValues = new String[0];
                    String[] toRemoveValues = new String[0];
                    
                    if (field.getMode() == MODE.REPLACE)
                    {
                        newRefValues = ArrayUtils.removeElements(contentIds, oldValues);
                        toRemoveValues = ArrayUtils.removeElements(oldValues, contentIds);
                    }
                    else if (field.getMode() == MODE.INSERT)
                    {
                        newRefValues = ArrayUtils.removeElements(contentIds, oldValues);
                        
                        if (!metadataDefinition.isMultiple())
                        {
                            toRemoveValues = oldValues; // the old value should be removed
                        }
                    }
                    else // (field.getMode() == MODE.REMOVE)
                    {
                        toRemoveValues = contentIds;
                    }
                    
                    // New mutual references which will be added
                    _lockNewReferencedContent(content, allErrors, user, metadataDefinition, metadataPath, invertEditActionId, newRefValues);
                    
                    // Old mutual references which will be removed
                    _lockOldReferencedThatWillBeRemovedContent(allErrors, user, metadataDefinition, metadataPath, invertEditActionId, toRemoveValues);
                }
                else if (metadata.hasMetadata(metadataName))
                {
                    _lockOldReferencedContent(metadata, allErrors, user, metadataDefinition, metadataPath, invertEditActionId, metadataName);
                }
            }
        }
        catch (RepositoryException e)
        {
            throw new WorkflowException("Error preparing to synchronize content references for content " + content.getId() + " and metadata at path '" + metadataPath + "'.", e);
        }
    }

    private void _lockNewReferencedContent(Content content, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String[] newValues) throws RepositoryException
    {
        for (String refContentId : newValues)
        {
            Content refContent = _resolver.resolveById(refContentId);
            if (_needTriggerEditWorkflowAction((ModifiableContent) refContent, metadataDefinition.getContentType(), metadataDefinition.getInvertRelationPath(), content.getId()))
            {
                // Check if edit action in available on referenced contents
                if (_isEditRefContentAvailable(invertEditActionId, refContent, metadataDefinition.getForceInvert(), metadataPath, user, allErrors))
                {
                    if (refContent instanceof LockableAmetysObject && !((LockableAmetysObject) refContent).isLocked())
                    {
                        // Get lock on referenced content
                        ((LockableAmetysObject) refContent).lock();
                    }
                }
            }
        }
    }

    private void _lockOldReferencedThatWillBeRemovedContent(AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String[] toRemove)
    {
        for (String refContentId : toRemove)
        {
            try
            {
                Content refContent = _resolver.resolveById(refContentId);
                if (_isEditRefContentAvailable(invertEditActionId, refContent, metadataDefinition.getForceInvert(), metadataPath, user, allErrors))
                {
                    if (refContent instanceof LockableAmetysObject && !((LockableAmetysObject) refContent).isLocked())
                    {
                        // Get lock on old referenced content
                        ((LockableAmetysObject) refContent).lock();
                    }
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                // The old referenced content does not exist anymore. Ignore it.
            }
        }
    }

    private void _lockOldReferencedContent(ModifiableCompositeMetadata metadata, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String metadataName)
    {
        String[] oldValues = metadata.getStringArray(metadataName, new String[0]);
        for (String refContentId : oldValues)
        {
            try
            {
                Content refContent = _resolver.resolveById(refContentId);
                if (_isEditRefContentAvailable(invertEditActionId, refContent, metadataDefinition.getForceInvert(), metadataPath, user, allErrors))
                {
                    if (refContent instanceof LockableAmetysObject && !((LockableAmetysObject) refContent).isLocked())
                    {
                        // Get lock on old referenced content
                        ((LockableAmetysObject) refContent).lock();
                    }
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                // The old referenced content does not exist anymore. Ignore it.
            }
        }
    }
    
    /**
     * Synchronize a content reference metadata from a field.
     * @param content the content.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param invertEditActionId The action id for editing invert relation
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeContentReferenceMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        SimpleField<Content> field = form.getContentArray(metadataName);
        String contentTypeId = metadataDefinition.getContentType();
        String invert = metadataDefinition.getInvertRelationPath();
        
        try
        {
            if (field != null && field.getValues() != null)
            {
                Content[] values = field.getValues();
                
                if (metadataDefinition.isMultiple())
                {
                    _synchronizeMultipleContentReferenceMetadata(content, metadata, form, allErrors, field, metadataDefinition, metadataPath, invertEditActionId, contentTypeId, invert, externalizable);
                }
                else if (values.length > 0)
                {
                    _synchronizeSingleContentReferenceMetadata(content, metadata, form, allErrors, field, metadataDefinition, metadataPath, invertEditActionId, contentTypeId, invert, externalizable);
                }
                else
                {
                    if (externalizable)
                    {
                        ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                        
                        // Remove JCR references
                        if (metadataDefinition.isMultiple())
                        {
                            _setJcrContentReferences(metadata, metadataName, new Value[0], externalizable, status);
                        }
                        else
                        {
                            _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) null, externalizable, status);
                        }
                        ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
                    }
                    
                    _removeMetadataIfExists(metadata, metadataName, externalizable);
                }
            }
            else
            {
                ExternalizableMetadataStatus status = null;
                
                String[] oldValues = new String[0];
                if (externalizable)
                {
                    status = form.getExternalizableField(metadataName).getStatus();
                    ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
                    
                    try
                    {
                        oldValues = ExternalizableMetadataHelper.getStringArray(metadata, metadataName, status);
                    }
                    catch (UnknownMetadataException e)
                    {
                        // Nothing
                    }
                }
                else
                {
                    oldValues = metadata.getStringArray(metadataName, new String[0]);
                }
                
                // Remove JCR references
                if (metadataDefinition.isMultiple())
                {
                    _setJcrContentReferences(metadata, metadataName, new Value[0], externalizable, status);
                }
                else
                {
                    _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) null, externalizable, status);
                }
                
                // Remove metadata and JCR references
                _removeMetadataIfExists(metadata, metadataName, externalizable);
                
                if (_invertRelationEnabled() && StringUtils.isNotEmpty(invert) && (!externalizable || ExternalizableMetadataStatus.LOCAL == form.getExternalizableField(metadataName).getStatus()))
                {
                    _removeInvertRelations(content.getId(), metadataDefinition, metadataPath, oldValues, invertEditActionId, allErrors);
                }
            }
        }
        catch (RepositoryException e)
        {
            Errors errors = new Errors();
            
            Map<String, I18nizableText> parameters = Collections.singletonMap("metadataPath", new I18nizableText(metadataPath));
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_CONTENTREFERENCE_MISSING", parameters));
            allErrors.addError(metadataPath, errors);
        }
    }
    
    private void _synchronizeMultipleContentReferenceMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, SimpleField<Content> field, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String contentTypeId, String invert, boolean externalizable) throws WorkflowException, RepositoryException
    {
        String metadataName = metadataDefinition.getName();
        Content[] values = field.getValues();
        
        String[] contentIds = new String[values.length];
        for (int i = 0; i < values.length; i++)
        {
            contentIds[i] = values[i].getId();
        }
        
        String localMetadataName = ExternalizableMetadataHelper.getMetadataName(metadata, metadataName, ExternalizableMetadataStatus.LOCAL);
        String[] oldValues = metadata.getStringArray(localMetadataName, new String[0]);
        String[] newValues;
        
        if (field.getMode() == MODE.REPLACE 
            || field.getMode() == MODE.INSERT &&  !metadata.hasMetadata(metadataName))
        {
            newValues = contentIds;
            
            // Set JCR content references from the Content objects (to avoid resolving them).
            ExternalizableMetadataStatus status = externalizable ? form.getExternalizableField(metadataName).getStatus() : null;
            _setJcrContentReferences(metadata, metadataName, values, externalizable, status);
            
            // Set content ID values.
            _setMetadata(metadata, metadataName, form, contentIds, externalizable);
        }
        else if (field.getMode() != MODE.REMOVE || metadata.hasMetadata(metadataName))
        {
            Set<String> newMetadataValues = new LinkedHashSet<>();
            newMetadataValues.addAll(Arrays.asList(oldValues));
            if (field.getMode() == MODE.INSERT)
            {
                newMetadataValues.addAll(Arrays.asList(contentIds));
            }
            else
            {
                newMetadataValues.removeAll(Arrays.asList(contentIds));
            }
            
            newValues = newMetadataValues.toArray(new String[0]);
            
            // Set JCR content references from the Content identifiers.
            ExternalizableMetadataStatus status = externalizable ? form.getExternalizableField(metadataName).getStatus() : null;
            _setJcrContentReferences(metadata, metadataName, newValues, externalizable, status);
            
            // Set content ID values.
            if (newValues.length > 0)
            {
                _setMetadata(metadata, metadataName, form, newValues, externalizable);
            }
            else
            {
                metadata.removeMetadata(metadataName);
            }
        }
        else
        {
            newValues = new String[0];
        }
        
        _synchronizeRelationOfMultipleContentReferenceMetadata(content, form, allErrors, metadataDefinition, metadataPath, invertEditActionId, contentTypeId, invert, externalizable, metadataName, values, oldValues, newValues);
    }

    private void _synchronizeRelationOfMultipleContentReferenceMetadata(Content content, Form form, AllErrors allErrors, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String contentTypeId, String invert, boolean externalizable, String metadataName, Content[] values, String[] oldValues, String[] newValues) throws WorkflowException
    {
        if (_invertRelationEnabled() && StringUtils.isNotEmpty(invert) && (!externalizable || ExternalizableMetadataStatus.LOCAL == form.getExternalizableField(metadataName).getStatus()))
        {
            // Remove old mutual references.
            String[] toRemove = ArrayUtils.removeElements(oldValues, newValues);
            _removeInvertRelations(content.getId(), metadataDefinition, metadataPath, toRemove, invertEditActionId, allErrors);
            
            // Content ID?
            for (Content refContent : values)
            {
                if (ArrayUtils.contains(newValues, refContent.getId()))
                {
                    _setInvertRelation(content, metadataPath, refContent, contentTypeId, invert, invertEditActionId, allErrors);
                }
            }
        }
    }
    
    private void _synchronizeSingleContentReferenceMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, SimpleField<Content> field, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String contentTypeId, String invert, boolean externalizable) throws WorkflowException, RepositoryException
    {
        String metadataName = metadataDefinition.getName();
        Content[] values = field.getValues();
        
        String oldValue = null;
        try
        {
            oldValue = externalizable ? ExternalizableMetadataHelper.getString(metadata, metadataName, ExternalizableMetadataStatus.LOCAL) : metadata.getString(metadataName, null);
        }
        catch (UnknownMetadataException e)
        {
            // nothing
        }
        
        Content refContent = values[0];
        boolean invertRequired = true;
        
        if (field.getMode() == MODE.REMOVE)
        {
            if (StringUtils.equals(refContent.getId(), oldValue))
            {
                ExternalizableMetadataStatus status = externalizable ? form.getExternalizableField(metadataName).getStatus() : null;
                
                _removeMetadataIfExists(metadata, metadataName, externalizable);
                // Remove JCR references.
                _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) null, externalizable, status);
                
                if (externalizable)
                {
                    ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
                }
            }
            else
            {
                invertRequired = false;
                if (_logger.isWarnEnabled())
                {
                    _logger.warn("Cannot remove reference to content '" + refContent.getId() + "' on content '" + content.getId() + "' metadata '" + metadataDefinition.getId() + "' because it is not a current value");
                }
            }
        }
        else
        {
            if (StringUtils.equals(refContent.getId(), oldValue))
            {
                invertRequired = false;
                if (externalizable)
                {
                    ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                    _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) refContent, externalizable, status);
                    ExternalizableMetadataHelper.updateStatus(metadata, metadataName, status);
                }
            }
            else
            {
                if (refContent instanceof JCRAmetysObject)
                {
                    ExternalizableMetadataStatus status = externalizable ? form.getExternalizableField(metadataName).getStatus() : null;
                    _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) refContent, externalizable, status);
                }
                _setMetadata(metadata, metadataName, form, refContent.getId(), externalizable);
            }
            
        }
        
        // Do not edit the invert relation if the externalizable status is external
        invertRequired = invertRequired && (!externalizable || ExternalizableMetadataStatus.LOCAL == form.getExternalizableField(metadataName).getStatus());
        _synchronizeRelationOfSingleContentReferenceMetadata(content, allErrors, field, metadataDefinition, metadataPath, invertEditActionId, contentTypeId, invert, oldValue, refContent, invertRequired);
    }

    private void _synchronizeRelationOfSingleContentReferenceMetadata(Content content, AllErrors allErrors, SimpleField<Content> field, MetadataDefinition metadataDefinition, String metadataPath, int invertEditActionId, String contentTypeId, String invert, String oldValue, Content refContent, boolean invertRequired) throws WorkflowException
    {
        if (_invertRelationEnabled() && invertRequired && StringUtils.isNotEmpty(invert))
        {
            if (oldValue != null)
            {
                _removeInvertRelation(content.getId(), metadataDefinition, metadataPath, oldValue, invertEditActionId, allErrors);
            }
        
            if (field.getMode() != MODE.REMOVE)
            {
                _setInvertRelation(content, metadataPath, refContent, contentTypeId, invert, invertEditActionId, allErrors);
            }
        }
    }
    
    /**
     * Synchronize a sub-content metadata from a field.
     * @param content The Content.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeSubContentMetadata(Content content, ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        
        SubContentField subContentField = form.getSubContentField(metadataName);
        
        String[] values = subContentField.getContentNamesOrIds();
        String[] contentTypes = subContentField.getContentTypes();
        Boolean[] isNew = subContentField.getIsNew();
        
        String contentLanguage = subContentField.getContentLanguage();
        int initWorkflowActionId = subContentField.getWorkflowActionId();
        String workflowName = subContentField.getWorkflowName();
        
        // TODO Handle ordering.
        TraversableAmetysObject objectCollection = null;
        if (externalizable)
        {
            ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
            objectCollection = ExternalizableMetadataHelper.getObjectCollection(metadata, metadataName, status);
        }
        else
        {
            objectCollection = ExternalizableMetadataHelper.getObjectCollection(metadata, metadataName);
        }
        
        
        Map<String, ModifiableContent> contentsToDelete = new HashMap<>();
        
        if (subContentField.getMode() == MODE.REPLACE)
        {
            try (AmetysObjectIterable<Content> subContents = objectCollection.getChildren())
            {
                for (Content subContent : subContents)
                {
                    if (subContent instanceof ModifiableContent)
                    {
                        contentsToDelete.put(subContent.getId(), (ModifiableContent) subContent);
                    }
                }
            }
        }
        else if (subContentField.getMode() == MODE.REMOVE)
        {
            for (String value : values)
            {
                ModifiableContent contentToRemove = _resolver.resolveById(value);
                contentsToDelete.put(contentToRemove.getId(), contentToRemove);
            }            
        }
        
        if (values != null  && (metadataDefinition.isMultiple() || values[0] != null) && subContentField.getMode() != MODE.REMOVE)
        {
            try
            {
                for (int i = 0; i < values.length; i++)
                {
                    if (isNew[i])
                    {
                        // New content: create it.
                        AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow();
                        Map<String, Object> inputs = _getInputsForSubContentCreation(content, metadata, form, user, metadataDefinition, metadataPath, values[i], new String[] {contentTypes[i]}, contentLanguage);
                        workflow.initialize(workflowName, initWorkflowActionId, inputs);
                    }
                    else
                    {
                        // The content is still there: remove it from the list of contents to delete.
                        String contentId = values[i];
                        contentsToDelete.remove(contentId);
                    }
                }
                
            }
            catch (WorkflowException e)
            {
                Errors errors = new Errors();
                
                List<String> parameters = new ArrayList<>();
                parameters.add(metadataPath);
                parameters.add(content.getId());
                errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_SUBCONTENT_CREATION", parameters));
                allErrors.addError(metadataPath, errors);
            }
        }
        
        // Delete contents.
        for (ModifiableContent contentToDelete : contentsToDelete.values())
        {
            contentToDelete.remove();
        }
    }
    

    /**
     * Provide the inputs to use for the creation of a subcontent.
     * @param content The parent content
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param name The name of the subcontent to create
     * @param cTypes Content types array of the subcontent to create
     * @param language The language of the subcontent to create
     * @return the map of inputs
     */
    protected Map<String, Object> _getInputsForSubContentCreation(Content content, ModifiableCompositeMetadata metadata, Form form, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, String name, String[] cTypes, String language)
    {
        Map<String, Object> inputs = new HashMap<>();
        Map<String, Object> result = new HashMap<>();
        
        inputs.put(CreateContentFunction.CONTENT_NAME_KEY, name);
        inputs.put(CreateContentFunction.CONTENT_TITLE_KEY, name);
        inputs.put(CreateContentFunction.CONTENT_TYPES_KEY, cTypes);
        inputs.put(CreateContentFunction.CONTENT_LANGUAGE_KEY, language);
        inputs.put(CreateContentFunction.PARENT_CONTENT_ID_KEY, content.getId());
        inputs.put(CreateContentFunction.PARENT_CONTENT_METADATA_PATH_KEY, metadataPath);
        
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, result);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
        
        return inputs;
    }
    
    
    /**
     * Synchronize a sub-content metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param metadataDefinition the metadata definition.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     */
    protected void _synchronizeReferenceMetadata(ModifiableCompositeMetadata metadata, Form form, MetadataDefinition metadataDefinition, boolean externalizable)
    {
        String metadataName = metadataDefinition.getName();
        ReferenceField field = form.getReferenceField(metadataName);
        
        if (field != null && field.getValue() != null && field.getMode() != MODE.REMOVE)
        {
            ModifiableCompositeMetadata refMetadata = null;
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                refMetadata = ExternalizableMetadataHelper.getCompositeMetadata(metadata, metadataName, status, true);
            }
            else
            {
                refMetadata = ExternalizableMetadataHelper.getCompositeMetadata(metadata, metadataName);          
            }
            refMetadata.setMetadata("value", field.getValue());   
            refMetadata.setMetadata("type", field.getType());
        }
        else
        {
            if (metadata.hasMetadata(metadataName))
            {
                metadata.removeMetadata(metadataName);
            }
        }
    }
    
    /**
     * Synchronize a rich text metadata from a field.
     * @param metadata the metadata.
     * @param form the form containing the field.
     * @param allErrors the errors.
     * @param user the user.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the current metadata path.
     * @param externalizable <code>true</code> if the metadata is externalizable (local and external value)
     * @throws WorkflowException if an error occurs.
     */
    protected void _synchronizeRichTextMetadata(ModifiableCompositeMetadata metadata, Form form, AllErrors allErrors, UserIdentity user, MetadataDefinition metadataDefinition, String metadataPath, boolean externalizable) throws WorkflowException
    {
        String metadataName = metadataDefinition.getName();
        RichTextField richTextField = form.getRichTextField(metadataName);
        
        if (richTextField != null && richTextField.getContent() != null)
        {
            String format = richTextField.getFormat();
            
            ModifiableCompositeMetadata metadataHolder = _getMetadataHolder(metadata, metadataName);
            ModifiableRichText richText = null;
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                richText = ExternalizableMetadataHelper.setLocalRichTextMetadata(metadataHolder, metadataName, status);
            }
            else
            {
                richText = ExternalizableMetadataHelper.getRichTextMetadata(metadataHolder, metadataName);
            }
            
            if ("docbook".equals(format))
            {
                _copyRichText(richTextField, richText, metadataDefinition, metadataPath, allErrors);
            }
            else
            {
                _transformRichText(richTextField, richText, metadataDefinition, metadataPath, allErrors);
            }
        }
        else
        {
            if (externalizable)
            {
                ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
                ExternalizableMetadataHelper.updateRichTextMetadataStatus(metadata, metadataName, status);
            }
            
            _removeMetadataIfExists(metadata, metadataName, externalizable);
        }
    }

    /**
     * Set the rich text metadata from a source that is not docbook.
     * @param field the RichText form field. 
     * @param richText the rich text metadata to populate.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param allErrors the error list.
     */
    protected void _transformRichText(RichTextField field, ModifiableRichText richText, MetadataDefinition metadataDefinition, String metadataPath, AllErrors allErrors)
    {
        try
        {
            RichTextTransformer richTextTransformer = metadataDefinition.getRichTextTransformer();
            String content = field.getContent();
            
            richTextTransformer.transform(content, richText);
        }
        catch (IOException e)
        {
            if (_logger.isErrorEnabled())
            {
                _logger.error("Unable to transform rich text", e);
            }
            
            Errors errors = new Errors();
            List<String> parameters = new ArrayList<>();
            parameters.add(e.getMessage());
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_RICHTEXT_TRANSFORM", parameters));
            allErrors.addError(metadataPath, errors);
        }
    }

    /**
     * Set a rich text metadata from an existing rich text metadata.
     * @param field the RichText form field. 
     * @param richText the rich text metadata to populate.
     * @param metadataDefinition the metadata definition.
     * @param metadataPath the metadata path.
     * @param allErrors the error list.
     */
    protected void _copyRichText(RichTextField field, ModifiableRichText richText, MetadataDefinition metadataDefinition, String metadataPath, AllErrors allErrors)
    {
        try
        {
            String content = field.getContent();
            
            ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes("UTF-8"));
            richText.setEncoding("UTF-8");
            richText.setMimeType("application/xml");
            richText.setLastModified(new Date());
            richText.setInputStream(is);
            
            ModifiableFolder dataFolder = richText.getAdditionalDataFolder();
            Map<String, Resource> dataToCopy = field.getAdditionalData();
            if (dataToCopy != null)
            {
                for (String fileName : dataToCopy.keySet())
                {
                    Resource sourceFile = dataToCopy.get(fileName);
                    
                    if (dataFolder.hasFile(fileName))
                    {
                        dataFolder.remove(fileName);
                    }
                    
                    ModifiableResource destFile = dataFolder.addFile(fileName).getResource();
                    destFile.setEncoding(sourceFile.getEncoding());
                    destFile.setMimeType(sourceFile.getMimeType());
                    destFile.setLastModified(sourceFile.getLastModified());
                    destFile.setInputStream(sourceFile.getInputStream());
                }
            }
        }
        catch (UnsupportedEncodingException e)
        {
            // Ignore
        }
    }
        
    /**
     * Store a content metadata as a JCR reference.
     * @param metadata the parent composite metadata.
     * @param metadataName the metatada name.
     * @param contentId the target JCR content identifier.
     * @param externalizable true if the metadata is externalizable
     * @param status The new status
     * @throws WorkflowException if an error occurs.
     * @throws RepositoryException if an error occurs.
     */
    protected void _setJcrContentReference(ModifiableCompositeMetadata metadata, String metadataName, String contentId, boolean externalizable, ExternalizableMetadataStatus status) throws WorkflowException, RepositoryException
    {
        Content content = _resolver.resolveById(contentId);
        
        if (content instanceof JCRAmetysObject)
        {
            _setJcrContentReference(metadata, metadataName, (JCRAmetysObject) content, externalizable, status);
        }
    }
    
    /**
     * Store a multiple content metadata as a JCR reference array.
     * @param metadata the parent composite metadata.
     * @param metadataName the metatada name.
     * @param contents the target JCR contents (metadata values).
     * @param externalizable true if the metadata is externalizable
     * @param status The new status
     * @throws WorkflowException if an error occurs.
     * @throws RepositoryException if an error occurs.
     */
    protected void _setJcrContentReferences(ModifiableCompositeMetadata metadata, String metadataName, Content[] contents, boolean externalizable, ExternalizableMetadataStatus status) throws WorkflowException, RepositoryException
    {
        if (!(metadata instanceof JCRCompositeMetadata))
        {
            throw new WorkflowException("Unable to manage non JCR composite metadata: " + metadata);
        }
        
        Node metaNode = ((JCRCompositeMetadata) metadata).getNode();
        
        ValueFactory valueFactory = metaNode.getSession().getValueFactory();
        
        Value[] jcrValues = new Value[contents.length];
        for (int i = 0; i < contents.length; i++)
        {
            if (contents[i] instanceof JCRAmetysObject)
            {
                jcrValues[i] = valueFactory.createValue(((JCRAmetysObject) contents[i]).getNode());
            }
        }
        
        _setJcrContentReferences(metadata, metadataName, jcrValues, externalizable, status);
    }
    
    /**
     * Store a multiple content metadata as a JCR reference array.
     * @param metadata the parent composite metadata.
     * @param metadataName the metatada name.
     * @param contentIds the target JCR content node identifiers.
     * @param externalizable true if the metadata is externalizable
     * @param status The new status
     * @throws WorkflowException if an error occurs.
     * @throws RepositoryException if an error occurs.
     */
    protected void _setJcrContentReferences(ModifiableCompositeMetadata metadata, String metadataName, String[] contentIds, boolean externalizable, ExternalizableMetadataStatus status) throws WorkflowException, RepositoryException
    {
        if (!(metadata instanceof JCRCompositeMetadata))
        {
            throw new WorkflowException("Unable to manage non JCR composite metadata: " + metadata);
        }
        
        
        Node metaNode = ((JCRCompositeMetadata) metadata).getNode();
        ValueFactory valueFactory = metaNode.getSession().getValueFactory();
        
        Value[] jcrValues = new Value[contentIds.length];
        for (int i = 0; i < contentIds.length; i++)
        {
            Content content = _resolver.resolveById(contentIds[i]);
            if (content instanceof JCRAmetysObject)
            {
                Node contentNode = ((JCRAmetysObject) content).getNode();
                jcrValues[i] = valueFactory.createValue(contentNode);
            }
        }
        
        _setJcrContentReferences(metadata, metadataName, jcrValues, externalizable, status);
    }
    
    /**
     * Store a multiple content metadata as a JCR reference array.
     * @param metadata the parent composite metadata.
     * @param metadataName the metatada name.
     * @param jcrValues the JCR values to set
     * @param externalizable true if the metadata is externalizable
     * @param status the new status
     * @return true if changes were made
     * @throws WorkflowException if an error occurs.
     * @throws RepositoryException if an error occurs.
     */
    protected boolean _setJcrContentReferences(ModifiableCompositeMetadata metadata, String metadataName, Value[] jcrValues, boolean externalizable, ExternalizableMetadataStatus status) throws WorkflowException, RepositoryException
    {
        if (!(metadata instanceof JCRCompositeMetadata))
        {
            throw new WorkflowException("Unable to manage non JCR composite metadata: " + metadata);
        }
        
        String jcrRefName = JCR_REFERENCE_PREFIX + metadataName;
        
        Node metaNode = ((JCRCompositeMetadata) metadata).getNode();
        
        _checkLock(metaNode);
        
        boolean hasChanges = false;
        
        if (externalizable)
        {
            String oldStatus = metadata.getString(metadataName + ExternalizableMetadataHelper.STATUS_SUFFIX, null);
            switch (status)
            {
                case EXTERNAL:
                    if (oldStatus == null && metaNode.hasProperty(jcrRefName))
                    {
                        // The property has not externalizable until now, remove the real value
                        metaNode.getProperty(jcrRefName).remove();
                        hasChanges = true;
                    }
                    else if (ExternalizableMetadataStatus.LOCAL.name().toLowerCase().equals(oldStatus))
                    {
                        // If status has changed, move alternative value to real value
                        hasChanges = _copyJcrContentReferences((JCRCompositeMetadata) metadata, jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX, jcrRefName, true);
                    }
                    
                    jcrRefName = jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX;
                    break;
                case LOCAL:
                    if (ExternalizableMetadataStatus.EXTERNAL.name().toLowerCase().equals(oldStatus))
                    {
                        // If status has changed, move real value to alternative value
                        hasChanges = _copyJcrContentReferences((JCRCompositeMetadata) metadata, jcrRefName, jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX, true);
                    }
                    break;
                default:
                    break;
            }
        }
        else if (metaNode.hasProperty(jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX))
        {
            metaNode.getProperty(jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX).remove();
            hasChanges = true;
        }
        
        if (jcrValues.length > 0)
        {
            metaNode.setProperty(jcrRefName, jcrValues);
            hasChanges = true;
        }
        else
        {
            if (metaNode.hasProperty(jcrRefName))
            {
                metaNode.getProperty(jcrRefName).remove();
                hasChanges = true;
            }
        }
        return hasChanges;
    }
    
    /**
     * Store a single content metadata as a JCR reference.
     * Be careful ! This method do NOT set the status. If externalizable, this method have to called before setting the new status
     * @param metadata the parent composite metadata.
     * @param metadataName the metatada name.
     * @param ao the Ametys object
     * @param externalizable true if the metadata is externalizable
     * @param status The new status
     * @return true if changes was made
     * @throws WorkflowException if an error occurs.
     * @throws RepositoryException if an error occurs.
     */
    protected boolean _setJcrContentReference(ModifiableCompositeMetadata metadata, String metadataName, JCRAmetysObject ao, boolean externalizable, ExternalizableMetadataStatus status) throws WorkflowException, RepositoryException
    {
        if (!(metadata instanceof JCRCompositeMetadata))
        {
            throw new WorkflowException("Unable to manage non JCR composite metadata: " + metadata);
        }
        
        String jcrRefName = JCR_REFERENCE_PREFIX + metadataName;
        
        Node metaNode = ((JCRCompositeMetadata) metadata).getNode();
        
        _checkLock(metaNode);
        
        boolean hasChanges = false;
        
        if (externalizable)
        {
            String oldStatus = metadata.getString(metadataName + ExternalizableMetadataHelper.STATUS_SUFFIX, null);
            switch (status)
            {
                case EXTERNAL:
                    if (oldStatus == null && metaNode.hasProperty(jcrRefName))
                    {
                        // The property has not externalizable until now, remove the real value
                        metaNode.getProperty(jcrRefName).remove();
                        hasChanges = true;
                    }
                    else if (ExternalizableMetadataStatus.LOCAL.name().toLowerCase().equals(oldStatus))
                    {
                        // If status has changed, move alternative value to real value
                        hasChanges = _copyJcrContentReferences((JCRCompositeMetadata) metadata, jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX, jcrRefName, false);
                    }
                    
                    jcrRefName = jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX;
                    break;
                case LOCAL:
                    if (ExternalizableMetadataStatus.EXTERNAL.name().toLowerCase().equals(oldStatus))
                    {
                        // If status has changed, move real value to alternative value
                        hasChanges = _copyJcrContentReferences((JCRCompositeMetadata) metadata, jcrRefName, jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX, false);
                    }
                    break;
                default:
                    break;
            }
        }
        else if (metaNode.hasProperty(jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX))
        {
            metaNode.getProperty(jcrRefName + ExternalizableMetadataHelper.ALTERNATIVE_SUFFIX).remove();
            hasChanges = true;
        }
        
        if (ao != null)
        {
            metaNode.setProperty(jcrRefName, ao.getNode());
            hasChanges = true;
        }
        else
        {
            if (metaNode.hasProperty(jcrRefName))
            {
                metaNode.getProperty(jcrRefName).remove();
                hasChanges = true;
            }
        }
        
        return hasChanges;
    }
    
    private static boolean _copyJcrContentReferences (JCRCompositeMetadata metadataHolder, String srcPropertyName, String destPropertyName, boolean multiple) throws AccessDeniedException, ValueFormatException, VersionException, LockException, ConstraintViolationException, PathNotFoundException, RepositoryException
    {
        if (metadataHolder.getNode().hasProperty(srcPropertyName))
        {
            if (multiple)
            {
                metadataHolder.getNode().setProperty(destPropertyName, metadataHolder.getNode().getProperty(srcPropertyName).getValues());
                return true;
            }
            else
            {
                metadataHolder.getNode().setProperty(destPropertyName, metadataHolder.getNode().getProperty(srcPropertyName).getValue());
                return true;
            }
        }
        else if (metadataHolder.getNode().hasProperty(destPropertyName))
        {
            metadataHolder.getNode().getProperty(destPropertyName).remove();
            return true;
        }
        
        return false;
    }
    
    /**
     * Determines if the edit workflow action will be trigger on this referenced content
     * @param refContent The referenced content
     * @param refContentTypeId The content type
     * @param invertRelationPath The path of invert relationship
     * @param currentContentId The content being editing
     * @return true if the edit workflow action will occur
     * @throws RepositoryException if an error occurred
     */
    protected boolean _needTriggerEditWorkflowAction (ModifiableContent refContent, String refContentTypeId, String invertRelationPath, String currentContentId) throws RepositoryException
    {
        ContentType refContentType = _contentTypeExtensionPoint.getExtension(refContentTypeId);
        MetadataDefinition invertMetadataDef = refContentType.getMetadataDefinitionByPath(invertRelationPath);
        
        ModifiableCompositeMetadata refContentMeta = _getRelationMetaHolder(refContent, refContentType, invertRelationPath, currentContentId, false);
        if (refContentMeta == null)
        {
            return true;
        }
        
        int lastSlashIndex = invertRelationPath.lastIndexOf(ContentConstants.METADATA_PATH_SEPARATOR);
        String metaName = lastSlashIndex > -1 ? invertRelationPath.substring(lastSlashIndex + 1) : invertRelationPath;
        
        if (invertMetadataDef.isMultiple())
        {
            String[] values = refContentMeta.getStringArray(metaName, new String[0]);
            if (!ArrayUtils.contains(values, currentContentId))
            {
                return true;
            }
            return false;
        }
        else
        {
            return !currentContentId.equals(refContentMeta.getString(metaName, null));
        }
    }
    
    /**
     * Set a mutual relation.
     * @param content the content being modified.
     * @param currentMetadataPath the metadata path on the content being modified.
     * @param refContent the content being referenced.
     * @param refContentTypeId the content type of the content being referenced.
     * @param invertRelationPath the path of the metadata to set on the content being referenced, separated by '/'
     * @param editActionId The current 'edit content' action ID.
     * @param allErrors the errors.
     * @throws WorkflowException if a fatal error occurs.
     */
    protected void _setInvertRelation(Content content, String currentMetadataPath, Content refContent, String refContentTypeId, String invertRelationPath, int editActionId, AllErrors allErrors) throws WorkflowException
    {
        try
        {
            boolean needSave = false;
            if (content instanceof ModifiableContent && invertRelationPath != null)
            {
                String currentContentId = content.getId();
                ModifiableContent modifiableRefContent = (ModifiableContent) refContent;
                
                ContentType refContentType = _contentTypeExtensionPoint.getExtension(refContentTypeId);
                MetadataDefinition invertMetadataDef = refContentType.getMetadataDefinitionByPath(invertRelationPath);
                
                Set<String> refExternalAndLocalMetadata = _externalizableMetadataProviderEP.getExternalAndLocalMetadata(modifiableRefContent);
                boolean externalizable = refExternalAndLocalMetadata.contains(invertRelationPath);
                        
                ModifiableCompositeMetadata refContentMeta = _getRelationMetaHolder(modifiableRefContent, refContentType, invertRelationPath, currentContentId, true);
                
                int lastSlashIndex = invertRelationPath.lastIndexOf(ContentConstants.METADATA_PATH_SEPARATOR);
                String metaName = lastSlashIndex > -1 ? invertRelationPath.substring(lastSlashIndex + 1) : invertRelationPath;
                
                if (invertMetadataDef.isMultiple())
                {
                    // Get the current values and add this one.
                    String[] values = refContentMeta.getStringArray(metaName, new String[0]);
                    if (!ArrayUtils.contains(values, currentContentId))
                    {
                        String[] newValues = ArrayUtils.add(values, currentContentId);
                        
                        _setJcrContentReferences(refContentMeta, metaName, newValues, externalizable, ExternalizableMetadataStatus.LOCAL);
                        
                        if (externalizable)
                        {
                            // Force status to local
                            ExternalizableMetadataHelper.setLocalMetadata(refContentMeta, metaName, newValues, ExternalizableMetadataStatus.LOCAL);
                        }
                        else
                        {
                            ExternalizableMetadataHelper.setMetadata(refContentMeta, metaName, newValues);
                        }
                        needSave = true;
                    }
                }
                else
                {
                    // Remove the invert relation if it exists.
                    String oldContentId = refContentMeta.getString(metaName, null);
                    if (oldContentId != null && !currentContentId.equals(oldContentId))
                    {
                        _removeInvertRelation(refContent.getId(), invertMetadataDef, invertRelationPath, oldContentId, editActionId, allErrors);
                    }
                    
                    _setJcrContentReference(refContentMeta, metaName, currentContentId, externalizable, ExternalizableMetadataStatus.LOCAL);
                    if (externalizable)
                    {
                        // Force status to local
                        ExternalizableMetadataHelper.setLocalMetadata(refContentMeta, metaName, currentContentId, ExternalizableMetadataStatus.LOCAL);
                    }
                    else
                    {
                        ExternalizableMetadataHelper.setMetadata(refContentMeta, metaName, currentContentId);
                    }
                    needSave = true;
                }
                
                if (needSave)
                {
                    modifiableRefContent.saveChanges();
                    
                    // Trigger edit workflow action on the referenced content if needed.
                    _triggerEditWorkflowAction(modifiableRefContent, editActionId);
                }
            }
        }
        catch (RepositoryException e)
        {
            _logger.error(String.format("Content reference validation error for content '%s', id '%s'", refContent.getTitle(), refContent.getId()), e);
            
            Errors errors = new Errors();
            Map<String, I18nizableText> params = new HashMap<>();
            params.put("content", new I18nizableText(refContent.getTitle()));
            params.put("error", new I18nizableText(e.getLocalizedMessage()));
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_CREATE", params));
            allErrors.addError(currentMetadataPath, errors);
        }
    }
    
    /**
     * Check the lock status of the node
     * @param node The node
     * @throws RepositoryException If an error occurred while manipulating the node
     */
    protected void _checkLock(Node node) throws RepositoryException
    {
        if (!_lockAlreadyChecked.contains(node.getIdentifier()) && node.isLocked())
        {
            LockManager lockManager = node.getSession().getWorkspace().getLockManager();
            
            Lock lock = lockManager.getLock(node.getPath());
            Node lockHolder = lock.getNode();
            
            lockManager.addLockToken(lockHolder.getProperty(RepositoryConstants.METADATA_LOCKTOKEN).getString());
            _lockAlreadyChecked.add(node.getIdentifier());
        }
    }
    
    /**
     * Checks if the "edit content" workflow action is available on a referenced content
     * @param editActionId The id of edit workflow action
     * @param refContent the referenced content to edit
     * @param forceInvert Force the invert edition regardless of the user's rights
     * @param currentMetadataPath the path of the metadata responsible for the invert relation
     * @param user the current user
     * @param allErrors the errors
     * @return <code>true</code> if the edit action is avalailable
     */
    protected boolean _isEditRefContentAvailable (int editActionId, Content refContent, boolean forceInvert, String currentMetadataPath, UserIdentity user, AllErrors allErrors)
    {
        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))
            {
                Errors errors = new Errors();
                Map<String, I18nizableText> 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(refContent.getTitle()));
                        params.put("lockOwner", new I18nizableText(lockOwner != null ? lockOwner.getFullName() + " (" + lockOwner.getIdentity().getLogin() + ")" : lockableContent.getLockOwner().getLogin()));
                        errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_REFERENCED_CONTENT_LOCKED", params));
                        allErrors.addError(currentMetadataPath, errors);
                        
                        return false;
                    }
                }
                
                // Action in unavailable
                params.put("content", new I18nizableText(refContent.getTitle()));
                errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_UNAVAILABLE_ACTION", params));
                allErrors.addError(currentMetadataPath, errors);
                
                return false;
            }
            else
            {
                return true;
            }
        }
        else
        {
            Errors errors = new Errors();
            Map<String, I18nizableText> params = new HashMap<>();
            params.put("content", new I18nizableText(refContent.getTitle()));
            errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_NOWORKFLOWAWARE_CONTENT", params));
            allErrors.addError(currentMetadataPath, errors);
            return false;
        }
        
    }
    
    /**
     * Remove a mutual relation.
     * @param currentContentId the ID of the content being modified.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param refContentId the ID of the content being referenced.
     * @param editActionId The current 'edit content' action ID.
     * @param allErrors the errors.
     * @throws WorkflowException if a fatal error occurs.
     */
    protected void _removeInvertRelation(String currentContentId, MetadataDefinition metaDef, String metaPath, String refContentId, int editActionId, AllErrors allErrors) throws WorkflowException
    {
        try
        {
            String refContentTypeId = metaDef.getContentType();
            String refMetadataPath = metaDef.getInvertRelationPath();
            
            Content refContent = _resolver.resolveById(refContentId);
            
            if (refContent instanceof ModifiableContent && refMetadataPath != null)
            {
                ModifiableContent refModifiableContent = (ModifiableContent) refContent;
                
                ContentType refContentType = _contentTypeExtensionPoint.getExtension(refContentTypeId);
                MetadataDefinition refMetadataDef = refContentType.getMetadataDefinitionByPath(refMetadataPath);
                
                int lastSlashIndex = refMetadataPath.lastIndexOf(ContentConstants.METADATA_PATH_SEPARATOR);
                String refMetaName = lastSlashIndex > -1 ? refMetadataPath.substring(lastSlashIndex + 1) : refMetadataPath;
                
                try
                {
                    boolean needSave = true;
                    ModifiableCompositeMetadata refContentMeta = _getRelationMetaHolder(refModifiableContent, refContentType, refMetadataPath, currentContentId, false);
                    
                    if (refContentMeta != null)
                    {
                        Set<String> refExternalAndLocalMetadata = _externalizableMetadataProviderEP.getExternalAndLocalMetadata(refModifiableContent);
                        boolean externalizable = refExternalAndLocalMetadata.contains(refMetadataPath);
                        
                        if (refMetadataDef.isMultiple())
                        {
                            String[] values = refContentMeta.getStringArray(refMetaName, new String[0]);
                            int index = ArrayUtils.indexOf(values, currentContentId);
                            if (index > -1)
                            {
                                String[] newValues = ArrayUtils.remove(values, index);
                                _setJcrContentReferences(refContentMeta, refMetaName, newValues, externalizable, ExternalizableMetadataStatus.LOCAL);
                                
                                if (externalizable)
                                {
                                    ExternalizableMetadataHelper.setLocalMetadata(refContentMeta, refMetaName, newValues, ExternalizableMetadataStatus.LOCAL);
                                }
                                else
                                {
                                    ExternalizableMetadataHelper.setMetadata(refContentMeta, refMetaName, newValues);
                                }
                                needSave = true;
                            }
                        }
                        else
                        {
                            if (ExternalizableMetadataHelper.removeLocalMetadataIfExists(refContentMeta, refMetaName))
                            {
                                needSave = true;
                            }
                            
                            // Remove JCR reference
                            if (metaDef.isMultiple())
                            {
                                needSave = needSave || _setJcrContentReferences(refContentMeta, refMetaName, new Value[0], externalizable, ExternalizableMetadataStatus.LOCAL);
                            }
                            else
                            {
                                needSave = needSave || _setJcrContentReference(refContentMeta, refMetaName, (JCRAmetysObject) null, externalizable, ExternalizableMetadataStatus.LOCAL);
                            }
                            
                        }
                        
                        if (needSave)
                        {
                            refModifiableContent.saveChanges();
                            
                            // Trigger edit workflow action on the referenced content if needed.
                            _triggerEditWorkflowAction(refModifiableContent, editActionId);
                        }
                    }
                }
                catch (RepositoryException e)
                {
                    Errors errors = new Errors();
                    Map<String, I18nizableText> params = new HashMap<>();
                    params.put("content", new I18nizableText(refContent.getTitle()));
                    params.put("error", new I18nizableText(e.getLocalizedMessage()));
                    errors.addError(new I18nizableText("plugin.cms", "CONTENT_EDITION_VALIDATION_ERRORS_MUTUALRELATION_REMOVE", params));
                    allErrors.addError(metaPath, errors);
                }
            }
        }
        catch (UnknownAmetysObjectException e)
        {
            // Ignore.
        }
    }
    
    /**
     * Remove a mutual relation.
     * @param currentContentId the ID of the content being modified.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param refContentIds the ID of the contents being referenced.
     * @param editActionId The current 'edit content' action ID.
     * @param allErrors the errors.
     * @throws WorkflowException if a fatal error occurs.
     */
    protected void _removeInvertRelations(String currentContentId, MetadataDefinition metaDef, String metaPath, String[] refContentIds, int editActionId, AllErrors allErrors) throws WorkflowException
    {
        for (String refContentId : refContentIds)
        {
            _removeInvertRelation(currentContentId, metaDef, metaPath, refContentId, editActionId, allErrors);
        }
    }
    
    /**
     * Get the metadata holder of the mutual relation.
     * @param refContent the content being referenced.
     * @param refContentType the content type of the content being referenced.
     * @param metadataPath the metadata path on the content being referenced, separated by '/'
     * @param searchContentId the ID of the content being modified.
     * @param create true to create non-existing composites and repeater entries.
     * @return The metadata holder of the relation, on the content being referenced.<br>
     *         Can be null if create is false and the metadata doesn't exist yet.
     * @throws RepositoryException if an error occurs.
     */
    protected ModifiableCompositeMetadata _getRelationMetaHolder(ModifiableContent refContent, ContentType refContentType, String metadataPath, String searchContentId, boolean create) throws RepositoryException
    {
        String[] pathSegments = StringUtils.split(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
        
        if (pathSegments.length == 0)
        {
            return null;
        }
        
        ModifiableCompositeMetadata metadataHolder = refContent.getMetadataHolder();
        
        try
        {
            MetadataDefinition metadataDef = null;
            
            for (int i = 0; i < pathSegments.length - 1 && metadataHolder != null; i++)
            {
                if (i == 0)
                {
                    metadataDef = refContentType.getMetadataDefinition(pathSegments[0]);
                }
                else if (metadataDef != null)
                {
                    metadataDef = metadataDef.getMetadataDefinition(pathSegments[i]);
                }
                
                if (metadataDef != null && metadataDef.getType() == MetadataType.COMPOSITE)
                {
                    if (!create && !ExternalizableMetadataHelper.hasMetadata(metadataHolder, pathSegments[i], ExternalizableMetadataStatus.LOCAL))
                    {
                        return null;
                    }

                    metadataHolder = ExternalizableMetadataHelper.getCompositeMetadata(metadataHolder, pathSegments[i]);
                
                    if (metadataDef instanceof RepeaterDefinition)
                    {
                        String[] repeaterPathSegments = ArrayUtils.subarray(pathSegments, i + 1, pathSegments.length);
                        RepeaterDefinition repeaterDef = (RepeaterDefinition) metadataDef;
                        
                        // Search the repeater entry referencing the content being modified (by its ID).
                        metadataHolder = _getEntryHolder(refContent, metadataHolder, repeaterDef, repeaterPathSegments, searchContentId, create);
                        if (!create && metadataHolder == null)
                        {
                            return null;
                        }
                    }
                }
            }
            
            return metadataHolder;
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }

    /**
     * On a repeater metadata, search the entry referencing the content being modified.
     * @param refContent the content being referenced.
     * @param repeaterMeta the repeater metadata.
     * @param repeaterDef the repeater definition.
     * @param pathElements the path of the mutual relation from the repeater, as a String array.
     * @param searchContentId the ID of the content being modified.
     * @param create true to create non-existing composites and repeater entries.
     * @return The metadata holder of the relation, on the content being referenced.<br>
     *         Can be null if create is false and the metadata doesn't exist yet.
     * @throws RepositoryException if an error occurs.
     */
    private ModifiableCompositeMetadata _getEntryHolder(ModifiableContent refContent, ModifiableCompositeMetadata repeaterMeta, RepeaterDefinition repeaterDef, String[] pathElements, String searchContentId, boolean create) throws RepositoryException
    {
        int count = 0;
        int max = 0;
        for (String subMetaName : repeaterMeta.getMetadataNames())
        {
            if (repeaterMeta.getType(subMetaName) == org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.COMPOSITE)
            {
                try
                {
                    count++;
                    max = Math.max(max, NumberUtils.toInt(subMetaName));
                    ModifiableCompositeMetadata entryHolder = ExternalizableMetadataHelper.getCompositeMetadata(repeaterMeta, subMetaName);
                    ModifiableCompositeMetadata meta = entryHolder;
                    
                    for (int i = 0; i < pathElements.length - 1 && meta != null; i++)
                    {
                        meta = ExternalizableMetadataHelper.getCompositeMetadata(meta, pathElements[i]);
                    }
                    
                    String[] ids = meta.getStringArray(pathElements[pathElements.length - 1], new String[0]);
                    if (ArrayUtils.contains(ids, searchContentId))
                    {
                        return entryHolder;
                    }
                }
                catch (UnknownMetadataException e)
                {
                    // Ignore.
                }
            }
        }
        
        if (create)
        {
            int maxSize = repeaterDef.getMaxSize();
            if (maxSize > 0 && count >= repeaterDef.getMaxSize())
            {
                throw new RepositoryException("Unable to create repeater entry in content " + refContent + ", max size attained (" + repeaterDef.getMaxSize() + ").");
            }
            
            String newEntryName = Integer.toString(max + 1);
            return ExternalizableMetadataHelper.getCompositeMetadata(repeaterMeta, newEntryName);
        }
        
        return null;
    }
    
    /**
     * Get the composite metadata holding the metadata given by its path
     * @param parentMetadata The parent composite metadata
     * @param metadataPath The metadata path (with /)
     * @return The direct parent metadata
     */
    protected ModifiableCompositeMetadata _getMetadataHolder(ModifiableCompositeMetadata parentMetadata, String metadataPath)
    {
        int pos = metadataPath.indexOf("/");
        if (pos == -1)
        {
            return parentMetadata;
        }
        else
        {
            return _getMetadataHolder(parentMetadata.getCompositeMetadata(metadataPath.substring(0, pos), true), metadataPath.substring(pos + 1));
        }
    }
    
    /**
     * 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 _triggerEditWorkflowAction(Content content, int actionId) throws WorkflowException
    {
        if (content instanceof WorkflowAwareContent)
        {
            Map<String, Object> inputs = new HashMap<>();
            Map<String, Object> parameters = new HashMap<>();
            
            inputs.put(EditContentFunction.EDIT_MUTUAL_RELATIONSHIP, true);
            inputs.put(AbstractWorkflowComponent.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);
            
            parameters.put(FORM_RAW_VALUES, Collections.EMPTY_MAP); // No values
            parameters.put(QUIT, true);
            
            _workflowHelper.doAction((WorkflowAwareContent) content, actionId, inputs);
        }
    }
    
    private ExternalizableMetadataStatus _getExternalizableStatus (String rawValue)
    {
        Map<String, Object> externalizableValue = _jsonUtils.convertJsonToMap(rawValue);
        return ExternalizableMetadataStatus.valueOf(((String) externalizableValue.get("status")).toUpperCase());
    }
    
    private void _setMetadata(ModifiableCompositeMetadata metadata, String metadataName, Form form, Object value, boolean externalizable)
    {
        if (externalizable)
        {
            ExternalizableMetadataStatus status = form.getExternalizableField(metadataName).getStatus();
            ExternalizableMetadataHelper.setLocalMetadata(metadata, metadataName, value, status);
        }
        else
        {
            ExternalizableMetadataHelper.setMetadata(metadata, metadataName, value);
        }
    }
}