/*
 *  Copyright 2019 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.data;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.collections4.SetUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.contenttype.ContentAttributeDefinition;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.holder.DataHolder;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.ModifiableModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeaterEntry;
import org.ametys.plugins.repository.data.holder.group.ModifiableModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.ModifiableModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.ModifiableModelAwareRepeaterEntry;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.data.holder.values.SynchronizableRepeater;
import org.ametys.plugins.repository.data.holder.values.SynchronizableValue;
import org.ametys.plugins.repository.data.holder.values.SynchronizationContext;
import org.ametys.plugins.repository.data.holder.values.UntouchedValue;
import org.ametys.plugins.repository.data.holder.values.ValueContext;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.repository.model.ViewHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.BadItemTypeException;

/**
 * Helper for data of type 'content'
 */
public class ContentDataHelper implements Serviceable, Component
{
    /** Avalon role */
    public static final String ROLE = ContentDataHelper.class.getName();
    
    private AmetysObjectResolver _resolver;
    private ContentTypeExtensionPoint _cTypeExtensionPoint;
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _cTypeExtensionPoint = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
    }
    
    /**
     * Retrieves the content identifier of a content data
     * @param dataHolder data holder that contains the content data
     * @param dataPath path to the content data
     * @param defaultValue The default value to return
     * @return the content identifier
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static String getContentIdFromContentData(ModelAwareDataHolder dataHolder, String dataPath, String defaultValue) throws BadItemTypeException
    {
        ContentValue value = dataHolder.getValue(dataPath);
        return Optional.ofNullable(value)
                       .map(ContentValue::getContentId)
                       .orElse(defaultValue);
    }
    
    /**
     * Retrieves the content identifier of a content data
     * @param dataHolder data holder that contains the content data
     * @param dataPath path to the content data
     * @return the content identifier, empty string if it is invalid
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static String getContentIdFromContentData(ModelAwareDataHolder dataHolder, String dataPath) throws BadItemTypeException
    {
        return getContentIdFromContentData(dataHolder, dataPath, StringUtils.EMPTY);
    }
    
    /**
     * Retrieves the content identifiers in an array from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @return an array containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static boolean isMultipleContentDataEmpty(ModelAwareDataHolder dataHolder, String dataPath) throws BadItemTypeException
    {
        return isMultipleContentDataEmpty(dataHolder, dataPath, ValueContext.newInstance());
    }
    
    /**
     * Retrieves the content identifiers in an array from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @param context the context of the value to retrieve
     * @return an array containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static boolean isMultipleContentDataEmpty(ModelAwareDataHolder dataHolder, String dataPath, ValueContext context) throws BadItemTypeException
    {
        return getContentIdsStreamFromMultipleContentData(dataHolder, dataPath, context).count() <= 0;
    }
    
    /**
     * Retrieves the content identifiers in a {@link List} from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @return a {@link List} containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static List<String> getContentIdsListFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath) throws BadItemTypeException
    {
        return getContentIdsListFromMultipleContentData(dataHolder, dataPath, ValueContext.newInstance());
    }
    
    /**
     * Retrieves the content identifiers in a {@link List} from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @param context the context of the value to retrieve
     * @return a {@link List} containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static List<String> getContentIdsListFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath, ValueContext context) throws BadItemTypeException
    {
        return getContentIdsStreamFromMultipleContentData(dataHolder, dataPath, context).collect(Collectors.toList());
    }
    
    /**
     * Retrieves the content identifiers in an array from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @return an array containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static String[] getContentIdsArrayFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath) throws BadItemTypeException
    {
        return getContentIdsArrayFromMultipleContentData(dataHolder, dataPath, ValueContext.newInstance());
    }
    
    /**
     * Retrieves the content identifiers in an array from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @param context the context of the value to retrieve
     * @return an array containing the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static String[] getContentIdsArrayFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath, ValueContext context) throws BadItemTypeException
    {
        return getContentIdsStreamFromMultipleContentData(dataHolder, dataPath, context).toArray(String[]::new);
    }
    
    /**
     * Retrieves a {@link Stream} of the content identifiers from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @return a {@link Stream} of the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static Stream<String> getContentIdsStreamFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath) throws BadItemTypeException
    {
        return getContentIdsStreamFromMultipleContentData(dataHolder, dataPath, ValueContext.newInstance());
    }
    
    /**
     * Retrieves a {@link Stream} of the content identifiers from a multiple content data
     * @param dataHolder data holder that contains the multiple content data
     * @param dataPath path to the multiple content data
     * @param context the context of the value to retrieve
     * @return a {@link Stream} of the content identifiers
     * @throws BadItemTypeException if the data at the given path is not a content data
     */
    public static Stream<String> getContentIdsStreamFromMultipleContentData(ModelAwareDataHolder dataHolder, String dataPath, ValueContext context) throws BadItemTypeException
    {
        ContentValue[] value = DataHolderHelper.getValue(dataHolder, dataPath, context);
        return Optional.ofNullable(value)
                       .map(v -> Arrays.stream(v))
                       .orElse(Stream.empty())
                       .map(ContentValue::getContentId);
    }
    
    /**
     * Prepares a write operation in the given {@link ModelAwareDataHolder} by traversing a {@link ViewItemAccessor} with the values to be written.<br>
     * The goal is to find content attributes and to extract added and removed values.
     * @param viewItemAccessor the view item accessor to walk through
     * @param content the source {@link ModifiableContent}
     * @param values the new values
     * @param context the synchronization context
     * @return the contents to-be-added and to-be-removed
     */
    public Collection<ReferencedContents> collectReferencedContents(ViewItemAccessor viewItemAccessor, ModifiableContent content, Map<String, Object> values, SynchronizationContext context)
    {
        // content ids, grouped by invert attribute paths, instead of definition paths, so that if several attributes share the same invert attribute, they are handled together
        // data structure is <definition> mapped <previous contents mapped with their data paths, new contents mapped with their data paths>
        Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references = new HashMap<>();

        _collectReferencedContents(content, viewItemAccessor, Optional.of(content), StringUtils.EMPTY, Optional.of(StringUtils.EMPTY), Optional.of(values), false, context, references);
        
        Collection<ReferencedContents> contents = new ArrayList<>();
        for (ContentAttributeDefinition definition : references.keySet())
        {
            Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>> allValues = references.get(definition);
            Map<ContentValue, List<String>> previousValues = allValues.getLeft();
            Map<ContentValue, List<String>> newValues = allValues.getRight();
            
            Map<ContentValue, List<String>> addedValues = new HashMap<>();
            Map<ContentValue, List<String>> removedValues = new HashMap<>();
            
            newValues.forEach((value, list) -> {
                if (!previousValues.containsKey(value))
                {
                    addedValues.put(value, list);
                }
            });
            
            previousValues.forEach((value, list) -> {
                if (!newValues.containsKey(value))
                {
                    removedValues.put(value, list);
                }
            });
            
            String invert = definition.getInvertRelationPath();
            ContentType invertType = _cTypeExtensionPoint.getExtension(definition.getContentTypeId());
            ContentAttributeDefinition invertDefinition = (ContentAttributeDefinition) invertType.getModelItem(invert);

            Map<ContentValue, ContentValue> thirdPartyContents = new HashMap<>();
            if (!DataHolderHelper.isMultiple(invertDefinition.getModel(), invertDefinition.getPath()))
            {
                List<ModifiableContent> refContents = addedValues.keySet().stream().map(v -> v.getContentIfExists()).flatMap(Optional::stream).collect(Collectors.toList());
                
                for (ModifiableContent refContent : refContents)
                {
                    ContentValue previousValue = refContent.getValue(invert);
                    if (previousValue != null)
                    {
                        String previousContentId = previousValue.getContentId();
                        if (!content.getId().equals(previousContentId))
                        {
                            // the single-valued content attribute is about to change, we should store the 3rd party content involved in the invert relation
                            thirdPartyContents.put(new ContentValue(refContent), previousValue);
                        }
                    }
                }
            }
            
            if (!addedValues.isEmpty() || !removedValues.isEmpty() || !thirdPartyContents.isEmpty())
            {
                contents.add(new ReferencedContents(definition, addedValues, removedValues, thirdPartyContents));
            }
        }
        
        return contents;
    }
    
    private void _collectReferencedContents(Content content,
                                            ViewItemAccessor viewItemAccessor, 
                                            Optional<ModelAwareDataHolder> currentDataHolder, 
                                            String dataPathPrefix,
                                            Optional<String> oldDataPathPrefix, 
                                            Optional<Map<String, Object>> values, 
                                            boolean insideKeptDataHolder,
                                            SynchronizationContext context,
                                            Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references)
    {
        ViewHelper.visitView(viewItemAccessor, 
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                
                if (definition instanceof ContentAttributeDefinition)
                {
                    ContentAttributeDefinition contentDefinition = (ContentAttributeDefinition) definition;
                    String invert = contentDefinition.getInvertRelationPath();
                    if (invert != null)
                    {
                        _collectInvertRelation(content, currentDataHolder, dataPathPrefix, oldDataPathPrefix, values, insideKeptDataHolder, name, contentDefinition, context, references);
                    }
                }
            }, 
            (group, definition) -> {
                // composite
                String name = definition.getName();
                _collectComposite(content, group, currentDataHolder, dataPathPrefix, oldDataPathPrefix, values, insideKeptDataHolder, context, name, references);
            }, 
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                _collectRepeater(content, group, currentDataHolder, dataPathPrefix, oldDataPathPrefix, values, insideKeptDataHolder, context, name, references);
            }, 
            group -> _collectReferencedContents(content, group, currentDataHolder, dataPathPrefix, oldDataPathPrefix, values, insideKeptDataHolder, context, references));
    }
    
    private void _collectInvertRelation(Content content,
                                        Optional<ModelAwareDataHolder> currentDataHolder, 
                                        String dataPathPrefix,
                                        Optional<String> oldDataPathPrefix,
                                        Optional<Map<String, Object>> values, 
                                        boolean insideKeptDataHolder,
                                        String name,
                                        ContentAttributeDefinition definition,
                                        SynchronizationContext context,
                                        Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references)
    {
        String dataPath = dataPathPrefix + name;

        Set<ContentValue> previousContents = currentDataHolder
                .map(dh -> dh.getValue(name))
                .map(this::_getContentRefs)
                .orElseGet(Collections::emptySet);
        Set<ContentValue> newContents;
        
        if (insideKeptDataHolder)
        {
            newContents = previousContents;
        }
        else
        {
            Optional<Object> rawValue = values.map(v -> v.get(name));
            
            Optional<String> oldDataPath = oldDataPathPrefix.map(p -> p + name);
            rawValue = rawValue.map(v -> DataHolderHelper.getValueFromSynchronizableValue(v, content, definition, oldDataPath, context));
            
            // If the current value is an untouched value, don't edit the invert relation
            if (rawValue.filter(UntouchedValue.class::isInstance).isPresent())
            {
                return;
            }
            
            newContents = rawValue.map(this::_getContentRefs)
                                  .orElseGet(Collections::emptySet);
            
            SynchronizableValue.Mode mode = values.map(v -> v.get(name))
                                                  .filter(SynchronizableValue.class::isInstance)
                                                  .map(SynchronizableValue.class::cast)
                                                  .map(v -> v.getMode())
                                                  .orElse(SynchronizableValue.Mode.REPLACE);
            
            if (mode == SynchronizableValue.Mode.REMOVE)
            {
                newContents = SetUtils.difference(previousContents, newContents);
            }
            else if (mode == SynchronizableValue.Mode.APPEND)
            {
                newContents = SetUtils.union(previousContents, newContents);
            }
        }

        _addReferences(references, definition, dataPath, previousContents, newContents);
    }
    
    private Set<ContentValue> _getContentRefs(Object value)
    {
        if (value instanceof ContentValue)
        {
            return Set.of((ContentValue) value);
        }
        else if (value instanceof ContentValue[])
        {
            return Set.copyOf(Arrays.asList((ContentValue[]) value));
        }
        else if (value instanceof String)
        {
            return Set.of(new ContentValue(_resolver, (String) value));
        }
        else if (value instanceof String[])
        {
            return Arrays.stream((String[]) value).map(id -> new ContentValue(_resolver, id)).collect(Collectors.toSet());
        }
        else if (value instanceof ModifiableContent)
        {
            return Set.of(new ContentValue((ModifiableContent) value));
        }
        else if (value instanceof ModifiableContent[])
        {
            return Arrays.stream((ModifiableContent[]) value).map(ContentValue::new).collect(Collectors.toSet());
        }
        
        return Collections.emptySet();
    }
    
    private void _addReferences(Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references, ContentAttributeDefinition definition, String dataPath, Set<ContentValue> previousContents, Set<ContentValue> newContents)
    {
        Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>> values = references.get(definition);
        Map<ContentValue, List<String>> previousValues = values == null ? new HashMap<>() : values.getLeft();
        Map<ContentValue, List<String>> newValues = values == null ? new HashMap<>() : values.getRight();
        
        previousContents.forEach(c -> previousValues.computeIfAbsent(c, __ -> new ArrayList<>()).add(dataPath));
        newContents.forEach(c -> newValues.computeIfAbsent(c, __ -> new ArrayList<>()).add(dataPath));
        
        references.put(definition, Pair.of(previousValues, newValues));
    }
    
    @SuppressWarnings("unchecked")
    private void _collectComposite(Content content,
                                  ModelViewItemGroup group, 
                                  Optional<ModelAwareDataHolder> currentDataHolder, 
                                  String dataPathPrefix,
                                  Optional<String> oldDataPathPrefix,
                                  Optional<Map<String, Object>> values, 
                                  boolean insideKeptDataHolder,
                                  SynchronizationContext context,
                                  String name,
                                  Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references)
    {
        Optional<?> value = values.map(v -> v.get(name));
        
        if (value.isPresent() && value.orElse(null) instanceof UntouchedValue)
        {
            return;
        }
        else
        {
            String updatedPrefix = dataPathPrefix + name + ModelItem.ITEM_PATH_SEPARATOR;
            Optional<String> updatedOldPrefix = oldDataPathPrefix.map(p -> p + name + ModelItem.ITEM_PATH_SEPARATOR);
            _collectReferencedContents(content, group, currentDataHolder.map(v -> v.getComposite(name)), updatedPrefix, updatedOldPrefix, (Optional<Map<String, Object>>) value, insideKeptDataHolder, context, references);
        }
    }
    
    @SuppressWarnings("unchecked")
    private void _collectRepeater(Content content,
                                  ModelViewItemGroup group, 
                                  Optional<ModelAwareDataHolder> currentDataHolder, 
                                  String dataPathPrefix,
                                  Optional<String> oldDataPathPrefix,
                                  Optional<Map<String, Object>> values, 
                                  boolean insideKeptDataHolder,
                                  SynchronizationContext context,
                                  String name,
                                  Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references)
    {
        Object value = values.map(v -> v.get(name)).orElse(null);
        List<Map<String, Object>> newEntries = null;
        Map<Integer, Integer> mapping = null;
        SynchronizableRepeater.Mode mode = SynchronizableRepeater.Mode.REPLACE_ALL;
        
        if (value instanceof UntouchedValue)
        {
            // If the current repeater value is an untouched value, don't look after invert relations in its entries
            return;
        }
        else if (value instanceof List)
        {
            newEntries = (List<Map<String, Object>>) value;
            mapping = IntStream.rangeClosed(1, newEntries.size()).boxed().collect(Collectors.toMap(Function.identity(), Function.identity()));
        }
        else if (value instanceof SynchronizableRepeater)
        {
            newEntries = ((SynchronizableRepeater) value).getEntries();
            mapping = ((SynchronizableRepeater) value).getPositionsMapping();
            mode = ((SynchronizableRepeater) value).getMode();
        }
        
        // first collect data for actually existing entries
        Set<Integer> alreadyHandledValues = _collectExistingRepeaterEntries(content, group, currentDataHolder, dataPathPrefix, oldDataPathPrefix, value, newEntries, mapping, mode, insideKeptDataHolder, context, name, references);
        
        // then collect data for newly created entries
        if (newEntries != null)
        {
            for (int i = 1; i <= newEntries.size(); i++)
            {
                if (!alreadyHandledValues.contains(i))
                {
                    String updatedPrefix = dataPathPrefix + name + "[" + i + "]" + ModelItem.ITEM_PATH_SEPARATOR;
                    _collectReferencedContents(content, group, Optional.empty(), updatedPrefix, Optional.empty(), Optional.of(newEntries.get(i - 1)), insideKeptDataHolder, context, references);
                }
            }
        }
    }

    private Set<Integer> _collectExistingRepeaterEntries(Content content,
                                                         ModelViewItemGroup group,
                                                         Optional<ModelAwareDataHolder> currentDataHolder,
                                                         String dataPathPrefix,
                                                         Optional<String> oldDataPathPrefix,
                                                         Object value,
                                                         List<Map<String, Object>> newEntries,
                                                         Map<Integer, Integer> mapping,
                                                         SynchronizableRepeater.Mode mode,
                                                         boolean insideKeptDataHolder,
                                                         SynchronizationContext context,
                                                         String name,
                                                         Map<ContentAttributeDefinition, Pair<Map<ContentValue, List<String>>, Map<ContentValue, List<String>>>> references)
    {
        Set<Integer> alreadyHandledValues = new HashSet<>();
        ModelAwareRepeater repeater = currentDataHolder.map(v -> v.getRepeater(name)).orElse(null);
        
        if (repeater != null)
        {
            for (ModelAwareRepeaterEntry entry : repeater.getEntries())
            {
                int position = entry.getPosition();
                
                Optional<Map<String, Object>> newValues = Optional.empty();
                String newPositionSuffix = "";
                boolean newKeptValue = insideKeptDataHolder;
                
                if (!insideKeptDataHolder)
                {
                    if (mode == SynchronizableRepeater.Mode.REPLACE_ALL)
                    {
                        Integer newPosition = mapping != null ? mapping.get(position) : null;
                        
                        if (newPosition != null)
                        {
                            // not removed entry
                            newValues = newEntries != null ? Optional.ofNullable(newEntries.get(newPosition - 1)) : Optional.empty();
                            newPositionSuffix = "[" + newPosition + "]";
                            alreadyHandledValues.add(newPosition);
                        }
                    }
                    else if (mode == SynchronizableRepeater.Mode.REPLACE)
                    {
                        List<Integer> replacePositions = ((SynchronizableRepeater) value).getReplacePositions();
                        int index = replacePositions.indexOf(position);
                        
                        if (index >= 0)
                        {
                            assert newEntries != null;
                            newValues = Optional.ofNullable(newEntries.get(index));
                            newPositionSuffix = "[" + position + "]";
                            alreadyHandledValues.add(position);
                        }
                        else
                        {
                            // entry kept as is
                            newKeptValue = true;
                        }
                    }
                    else
                    {
                        Set<Integer> removedEntries = ((SynchronizableRepeater) value).getRemovedEntries();
                        newKeptValue = !removedEntries.contains(position);
                    }
                }
                
                String updatePrefix = dataPathPrefix + name + newPositionSuffix + ModelItem.ITEM_PATH_SEPARATOR;
                Optional<String> updatedOldPrefix = oldDataPathPrefix.map(p -> dataPathPrefix + name + "[" + position + "]" + ModelItem.ITEM_PATH_SEPARATOR);
                _collectReferencedContents(content, group, Optional.of(entry), updatePrefix, updatedOldPrefix, newValues, newKeptValue, context, references);
            }
        }
        
        return alreadyHandledValues;
    }
    
    /**
     * Find any broken reference in data holder's content attributes.
     * A reference is considered as broken if the referenced content does not exist
     * @param dataHolder the {@link ModelAwareDataHolder} to inspect.
     * @param fix if <code>true</code>, and the dataHolder is modifiable, broken references will be removed
     * Warning: if modifications are made on the given data holder, the modifications won't be saved and the workflow won't change 
     * @return all broken references, by attribute path
     */
    public static Map<String, List<String>> checkBrokenReferences(ModelAwareDataHolder dataHolder, boolean fix)
    {
        Map<String, List<String>> result = new HashMap<>();
        Map<String, Object> contentAttributes = DataHolderHelper.findEditableItemsByType(dataHolder, ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID);
        for (Map.Entry<String, Object> entry : contentAttributes.entrySet())
        {
            String dataPath = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof ContentValue)
            {
                ContentValue contentValue = (ContentValue) value;
                if (contentValue.getContentIfExists().isEmpty())
                {
                    result.computeIfAbsent(dataPath, __ -> new ArrayList<>()).add(contentValue.getContentId());
                    if (fix && dataHolder instanceof ModifiableModelAwareDataHolder)
                    {
                        ((ModifiableModelAwareDataHolder) dataHolder).setValue(dataPath, null);
                    }
                }
            }
            else if (value instanceof ContentValue[])
            {
                List<ContentValue> newValues = new ArrayList<>();
                for (ContentValue contentValue : (ContentValue[]) value)
                {
                    if (contentValue.getContentIfExists().isEmpty())
                    {
                        result.computeIfAbsent(dataPath, __ -> new ArrayList<>()).add(contentValue.getContentId());
                    }
                    else if (fix)
                    {
                        newValues.add(contentValue);
                    }
                }
                if (fix && dataHolder instanceof ModifiableModelAwareDataHolder)
                {
                    ((ModifiableModelAwareDataHolder) dataHolder).setValue(dataPath, newValues.toArray(ContentValue[]::new));
                }
            }
        }
        return result;
    }
    
    /**
     * Find any broken invert relation in a content attributes.
     * The invert relation is considered as broken if the referenced content does not reference the first one by the attribute with the invert relation path
     * This check does not take nonexistent referenced contents into account. First call the {@link ContentDataHelper#checkBrokenReferences(ModelAwareDataHolder, boolean)} method
     * @param content the content to inspect.
     * @param fix if <code>true</code>, and the referenced contents are modifiable, broken invert relations will be fixed by adding the relation on the referenced content
     * if the referenced content is referencing another content and the attribute is single (and not in a repeater), the third content will be modified too, to remove the relation to the second content.
     * Warning: if modifications are made on some contents, the modifications won't be saved and the workflows won't change 
     * @return All broken invert relations in a collection of {@link ReferencedContents}.
     * Call {@link ReferencedContents#getAddedContents()} to get all contents referenced by the given content that does not reference it in return
     * Call {@link ReferencedContents#getThirdPartyContents()} to get contents referenced by content in added contents that reference it in return
     */
    public static Collection<ReferencedContents> checkBrokenInvertRelations(Content content, boolean fix)
    {
        // Search for all content attribute's values
        Map<String, Object> contentAttributes = DataHolderHelper.findEditableItemsByType(content, ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID);

        // Collect broken invert relations
        Collection<ReferencedContents> brokenInvertRelations = new ArrayList<>();
        for (Map.Entry<String, Object> entry : contentAttributes.entrySet())
        {
            String dataPath = entry.getKey();
            Object value = entry.getValue();
            ContentAttributeDefinition definition = (ContentAttributeDefinition) content.getDefinition(dataPath);
            
            // Continue check only on content attributes with an invert relation path
            if (StringUtils.isNotBlank(definition.getInvertRelationPath()))
            {
                Map<ContentValue, List<String>> contentsToAdd = new HashMap<>();
                Map<ContentValue, ContentValue> thirdPartyContents = new HashMap<>();
                
                if (value instanceof ContentValue)
                {
                    Pair<Boolean, Optional<ContentValue>> isBroken = _isInvertRelationBroken(content, (ContentValue) value, definition);
                    if (isBroken.getLeft())
                    {
                        contentsToAdd.put((ContentValue) value, List.of(dataPath));
                        isBroken.getRight()
                                .ifPresent(v -> thirdPartyContents.put((ContentValue) value, v));
                    }
                }
                else if (value instanceof ContentValue[])
                {
                    for (ContentValue contentValue : (ContentValue[]) value)
                    {
                        Pair<Boolean, Optional<ContentValue>> isBroken = _isInvertRelationBroken(content, contentValue, definition);
                        if (isBroken.getLeft())
                        {
                            contentsToAdd.computeIfAbsent(contentValue, __ -> new ArrayList<>()).add(dataPath);
                            isBroken.getRight()
                                    .ifPresent(v -> thirdPartyContents.put(contentValue, v));
                        }
                    }
                }
                
                // Add a ReferencedContents object if there is at least one broken relation
                // No need to check the third part content, this map can't have entries if the first one is empty
                if (!contentsToAdd.isEmpty())
                {
                    ReferencedContents brokenInvertRelation = new ReferencedContents(definition, contentsToAdd, Map.of(), thirdPartyContents);
                    brokenInvertRelations.add(brokenInvertRelation);
                }
            }
        }
        
        if (fix)
        {
            Map<String, ModifiableContent> modifiedContents = new HashMap<>();
            
            for (ReferencedContents brokenInvertRelation : brokenInvertRelations)
            {
                // Add relation on contents referenced by the given one
                String invertRelationPath = brokenInvertRelation.getDefinition().getInvertRelationPath();
                modifiedContents.putAll(manageInvertRelations(invertRelationPath, brokenInvertRelation.getAddedContents(), content.getId(), ContentDataHelper::addInvertRelation, modifiedContents, Map.of()));
                
                // Remove relations on third party contents
                Map<ContentValue, Collection<String>> thirdPartyContents = new HashMap<>();
                for (Map.Entry<ContentValue, ContentValue> thirdPartyContent : brokenInvertRelation.getThirdPartyContents().entrySet())
                {
                    thirdPartyContents.computeIfAbsent(thirdPartyContent.getValue(), __ -> new ArrayList<>()).add(thirdPartyContent.getKey().getContentId());
                }
                modifiedContents.putAll(manageInvertRelations(brokenInvertRelation.getDefinition().getPath(), thirdPartyContents, ContentDataHelper::removeInvertRelation, modifiedContents, Map.of()));
            }
        }

        return brokenInvertRelations;
    }
    
    /**
     * Check if the invert relation between the given contents is broken
     * @param source the source content of the invert relation
     * @param destinationValue the destination content of the invert relation
     * @param definition the definition concerned by the checked invert relation
     * @return a {@link Pair} containing the result of the check ({@link Boolean} part left) and an optional third part content, if the relation is broken and the destination content references another content in a single attribute that should be modified
     */
    private static Pair<Boolean, Optional<ContentValue>> _isInvertRelationBroken(Content source, ContentValue destinationValue, ContentAttributeDefinition definition)
    {
        Boolean isBroken = Boolean.FALSE;
        Optional<ContentValue> thirdPartContent = Optional.empty();

        // Get the target content - ignore nonexistent contents, the checkBrokenReferences dealt with it
        Optional<? extends Content> optDestination = destinationValue.getContentIfExists();
        if (optDestination.isPresent())
        {
            // Get the value of the target content's attribute
            Content destination = optDestination.get();
            Object value = destination.getValue(definition.getInvertRelationPath(), true);
            if (value == null)
            {
                isBroken = true;
            }
            else if (value instanceof ContentValue)
            {
                // If the value does not correspond to the current data holder
                if (!((ContentValue) value).getContentId().equals(source.getId()))
                {
                    isBroken = true;
                    
                    // If the value of the destination is in relation to the destination too, this third part content will have to be modified
                    Object thirdPartValue = ((ContentValue) value).getValue(definition.getPath(), true);
                    if (thirdPartValue instanceof ContentValue)
                    {
                        if (((ContentValue) thirdPartValue).getContentId().equals(destination.getId()))
                        {
                            thirdPartContent = Optional.of((ContentValue) value);
                        }
                    }
                    else if (thirdPartValue instanceof ContentValue[])
                    {
                        for (ContentValue thridPartSingleValue : (ContentValue[]) thirdPartValue)
                        {
                            if (thridPartSingleValue.getContentId().equals(destination.getId()))
                            {
                                thirdPartContent = Optional.of((ContentValue) value);
                                break;
                            }
                        }
                    }
                }
            }
            else if (value instanceof ContentValue[])
            {
                // Search for the source content in the values of the destination
                boolean foundSource = false;
                for (ContentValue contentValue : (ContentValue[]) value)
                {
                    if (contentValue.getContentId().equals(source.getId()))
                    {
                        foundSource = true;
                        break;
                    }
                }
                
                isBroken = Boolean.valueOf(!foundSource);
            }
        }
        
        return new ImmutablePair<>(isBroken, thirdPartContent);
    }
    
    /**
     * Manages the invert relations concerned by the given path, through the given {@link InvertRelationManager} 
     * @param invertRelationPath the concerned invert relation path
     * @param referencedContents a {@link Set} containing the referenced contents to manage (add or remove the relation)
     * @param referencingContentId the id of the content referencing the given contents
     * @param invertRelationManager the {@link InvertRelationManager} to use (to add or remove the invert relations)
     * @param alreadyModifiedContents a {@link Map} of contents (indexed by their identifiers) that have already been modified. 
     *      This map will be used to initialize the returned map and to search for contents that have already been resolved (to resolve each content only once, even if there are several modifications on a same content)
     * @param externalizableDataContext the context {@link Map} that is used to determine if a data is externalizable
     * @return a {@link Map} containing the contents (indexed by their identifiers) that have been modified by this call and the ones that have already been modified
     */
    public static Map<String, ModifiableContent> manageInvertRelations(String invertRelationPath, Set<ContentValue> referencedContents, String referencingContentId, InvertRelationManager invertRelationManager, Map<String, ModifiableContent> alreadyModifiedContents, Map<String, Object> externalizableDataContext)
    {
        Map<ContentValue, Collection<String>> referencedContentsWithReferencing = referencedContents.stream()
                .collect(Collectors.toMap(value -> value, value -> Set.of(referencingContentId)));
        
        return manageInvertRelations(invertRelationPath, referencedContentsWithReferencing, invertRelationManager, alreadyModifiedContents, externalizableDataContext);
    }
    
    /**
     * Manages the invert relations concerned by the given path, through the given {@link InvertRelationManager} 
     * @param invertRelationPath the concerned invert relation path
     * @param referencedContents a {@link Map} containing the referenced contents to manage (add or remove the relation) and the id of the content referencing this content
     * @param invertRelationManager the {@link InvertRelationManager} to use (to add or remove the invert relations)
     * @param alreadyModifiedContents a {@link Map} of contents (indexed by their identifiers) that have already been modified. 
     *      This map will be used to initialize the returned map and to search for contents that have already been resolved (to resolve each content only once, even if there are several modifications on a same content)
     * @param externalizableDataContext the context {@link Map} that is used to determine if a data is externalizable
     * @return a {@link Map} containing the contents (indexed by their identifiers) that have been modified by this call and the ones that have already been modified
     */
    public static Map<String, ModifiableContent> manageInvertRelations(String invertRelationPath, Map<ContentValue, Collection<String>> referencedContents, InvertRelationManager invertRelationManager, Map<String, ModifiableContent> alreadyModifiedContents, Map<String, Object> externalizableDataContext)
    {
        Map<String, ModifiableContent> allModifiedContents = new HashMap<>(alreadyModifiedContents);
        
        for (ContentValue referencedContent : referencedContents.keySet())
        {
            String contentId = referencedContent.getContentId();
            Optional<ModifiableContent> optContent = allModifiedContents.containsKey(contentId)
                    ? Optional.of(allModifiedContents.get(contentId))
                            : referencedContent.getContentIfExists();
            
            if (optContent.isPresent())
            {
                ModifiableContent content = optContent.get();
                
                ModelItem modelItem = content.getDefinition(invertRelationPath);
                ValueContext valueContext = ValueContext.newInstance();
                if (DataHolderHelper.getExternalizableDataProviderExtensionPoint().isDataExternalizable(content, modelItem))
                {
                    if (ExternalizableDataStatus.EXTERNAL.equals(content.getStatus(invertRelationPath)))
                    {
                        throw new IllegalStateException("Unable to manage the invert relation on distant content '" + content + "', the data at path '" + invertRelationPath + "' is external.");
                    }
                    else
                    {
                        valueContext.withStatus(ExternalizableDataStatus.LOCAL);
                    }
                }
                
                if (invertRelationManager.manageInvertRelation(content, invertRelationPath, referencedContents.get(referencedContent), valueContext))
                {
                    allModifiedContents.put(contentId, content);
                }
            }
        }
        
        return allModifiedContents;
    }
    
    /**
     * Adds the invert relation to the given {@link DataHolder}
     * @param dataHolder the data holder where to add the invert relation
     * @param invertRelationPath the path of the invert relation
     * @param referencingContentIds the id of the contents that reference the data holder
     * @param context the value's context
     * @return <code>true</code> if the given data holder has been modified, <code>false</code> otherwise
     */
    public static boolean addInvertRelation(ModifiableModelAwareDataHolder dataHolder, String invertRelationPath, Collection<String> referencingContentIds, ValueContext context)
    {
        String[] pathSegments = StringUtils.split(invertRelationPath, ModelItem.ITEM_PATH_SEPARATOR);
        String dataName = pathSegments[0];
        
        if (pathSegments.length == 1)
        {
            ContentAttributeDefinition invertRelationDefinition = (ContentAttributeDefinition) dataHolder.getDefinition(invertRelationPath);
            if (invertRelationDefinition.isMultiple())
            {
                List<String> newValues = new ArrayList<>();
                
                if (DataHolderHelper.hasValue(dataHolder, invertRelationPath, context))
                {
                    ContentValue[] oldValues = DataHolderHelper.getValue(dataHolder, invertRelationPath, context);
                    
                    newValues = Arrays.stream(oldValues)
                            .map(ContentValue::getContentId)
                            .collect(Collectors.toList());
                }

                newValues.addAll(referencingContentIds);
                DataHolderHelper.setValue(dataHolder, invertRelationPath, newValues.toArray(new String[newValues.size()]), context);
                return true;
            }
            else
            {
                assert referencingContentIds.size() == 1;
                DataHolderHelper.setValue(dataHolder, invertRelationPath, referencingContentIds.iterator().next(), context);
                return true;
            }
        }
        else
        {
            ModelItem modelItem = dataHolder.getDefinition(dataName);
            String subInvertRelationPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
            if (modelItem instanceof RepeaterDefinition)
            {
                ModifiableModelAwareRepeaterEntry repeaterEntry = dataHolder.getRepeater(dataName, true).addEntry();
                return addInvertRelation(repeaterEntry, subInvertRelationPath, referencingContentIds, context); 
            }
            else
            {
                ModifiableModelAwareComposite composite = dataHolder.getComposite(dataName, true);
                return addInvertRelation(composite, subInvertRelationPath, referencingContentIds, context);
            }
        }
    }
    
    /**
     * Removes the invert relation to the given {@link DataHolder}
     * @param referencedContent the content where to remove the invert relation
     * @param invertRelationPath the path of the invert relation
     * @param referencingContentIds the id of the contents that do not reference the given content anymore
     * @param context the value's context
     * @return <code>true</code> if the referenced content has been modified, <code>false</code> otherwise
     */
    public static boolean removeInvertRelation(ModifiableContent referencedContent, String invertRelationPath, Collection<String> referencingContentIds, ValueContext context)
    {
        ContentAttributeDefinition invertRelationDefinition = (ContentAttributeDefinition) referencedContent.getDefinition(invertRelationPath);
        if (invertRelationDefinition.isMultiple())
        {
            if (DataHolderHelper.hasValue(referencedContent, invertRelationPath, context))
            {
                ContentValue[] oldValues = DataHolderHelper.getValue(referencedContent, invertRelationPath, context);
                
                String[] newValues = Arrays.stream(oldValues)
                        .map(ContentValue::getContentId)
                        .filter(id -> !referencingContentIds.contains(id))
                        .toArray(size -> new String[size]);

                DataHolderHelper.setValue(referencedContent, invertRelationPath, newValues, context);
                return oldValues.length > newValues.length;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return _removeSingleInvertRelation(referencedContent, invertRelationPath, referencingContentIds, context);
        }
    }
    
    private static boolean _removeSingleInvertRelation(ModifiableModelAwareDataHolder dataHolder, String invertRelationPath, Collection<String> referencingContentIds, ValueContext context)
    {
        String[] pathSegments = StringUtils.split(invertRelationPath, ModelItem.ITEM_PATH_SEPARATOR);
        String dataName = pathSegments[0];
        
        if (pathSegments.length == 1)
        {
            ContentValue value = DataHolderHelper.getValue(dataHolder, dataName, context);
            if (value != null && referencingContentIds.contains(value.getContentId()))
            {
                DataHolderHelper.removeValue(dataHolder, dataName, context);
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            ModelItem modelItem = dataHolder.getDefinition(dataName);
            String subInvertRelationPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
            if (modelItem instanceof RepeaterDefinition)
            {
                boolean modified  = false;

                ModifiableModelAwareRepeater repeater = dataHolder.getRepeater(dataName);
                if (repeater != null)
                {
                    for (ModifiableModelAwareRepeaterEntry repeaterEntry : repeater.getEntries())
                    {
                        modified = _removeSingleInvertRelation(repeaterEntry, subInvertRelationPath, referencingContentIds, context) || modified; 
                    }
                }
                
                return modified;
            }
            else
            {
                ModifiableModelAwareComposite composite = dataHolder.getComposite(dataName);
                return _removeSingleInvertRelation(composite, subInvertRelationPath, referencingContentIds, context);
            }
        }
    }
    
    /**
     * Invert relation manager (to add or remove a relation on a content
     */
    @FunctionalInterface
    public interface InvertRelationManager
    {
        /**
         * Manages the invert relation to the given {@link DataHolder}
         * @param referencedContent the content where to manage the invert relation
         * @param invertRelationPath the path of the invert relation
         * @param referencingContentIds the id of the contents that reference.d the given content
         * @param context the value's context
         * @return <code>true</code> if the referenced content has been modified, <code>false</code> otherwise
         */
        public boolean manageInvertRelation(ModifiableContent referencedContent, String invertRelationPath, Collection<String> referencingContentIds, ValueContext context);
    }
}