/*
 *  Copyright 2022 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.holder.impl;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.ametysobject.ModelAwareDataAwareAmetysObject;
import org.ametys.cms.data.holder.IndexableDataHolder;
import org.ametys.cms.data.holder.group.IndexableComposite;
import org.ametys.cms.data.holder.group.IndexableRepeater;
import org.ametys.cms.data.holder.group.impl.DefaultModelAwareComposite;
import org.ametys.cms.data.holder.group.impl.DefaultModelAwareRepeater;
import org.ametys.cms.model.ContentElementDefinition;
import org.ametys.cms.model.properties.Property;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.plugins.repository.data.ametysobject.DataAwareAmetysObject;
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.group.ModelAwareComposite;
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.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.data.repositorydata.RepositoryData;
import org.ametys.plugins.repository.data.type.RepositoryElementType;
import org.ametys.plugins.repository.data.type.RepositoryModelItemGroupType;
import org.ametys.plugins.repository.data.type.RepositoryModelItemType;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.repository.model.RepositoryDataContext;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewHelper;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.BadDataPathCardinalityException;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemType;

/**
 * Default implementation for data holder with model
 */
public class DefaultModelAwareDataHolder implements IndexableDataHolder
{
    private static final Logger __LOGGER = LoggerFactory.getLogger(ModelAwareDataHolder.class);
    
    /** Repository data to use to store data in the repository */
    protected RepositoryData _repositoryData;
    
    /** Parent of the current {@link DataHolder} */
    protected Optional<? extends IndexableDataHolder> _parent;
    
    /** Root {@link DataHolder} */
    protected IndexableDataHolder _root;
    
    /** Model containers to use to get information about definitions */
    protected Collection<? extends ModelItemContainer> _itemContainers;
    
    /**
     * Creates a default model aware data holder
     * @param repositoryData the repository data to use
     * @param itemContainer the model container to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.
     */
    public DefaultModelAwareDataHolder(RepositoryData repositoryData, ModelItemContainer itemContainer)
    {
        this(repositoryData, itemContainer, Optional.empty(), Optional.empty());
    }
    
    /**
     * Creates a default model aware data holder
     * @param repositoryData the repository data to use
     * @param itemContainer the model container to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.
     * @param parent the optional parent of the created {@link DataHolder}, empty if the created {@link DataHolder} is the root {@link DataHolder}
     * @param root the root {@link DataHolder}
     */
    public DefaultModelAwareDataHolder(RepositoryData repositoryData, ModelItemContainer itemContainer, Optional<? extends IndexableDataHolder> parent, Optional<? extends IndexableDataHolder> root)
    {
        this(repositoryData, List.of(itemContainer), parent, root);
    }
    
    /**
     * Creates a default model aware data holder
     * @param repositoryData the repository data to use
     * @param itemContainers the model containers to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.
     * @param parent the parent of the created {@link DataHolder}, empty if the created {@link DataHolder} is the root {@link DataHolder}
     * @param root the root {@link DataHolder}
     */
    public DefaultModelAwareDataHolder(RepositoryData repositoryData, Collection<? extends ModelItemContainer> itemContainers, Optional<? extends IndexableDataHolder> parent, Optional<? extends IndexableDataHolder> root)
    {
        _repositoryData = repositoryData;
        _itemContainers = itemContainers;
        _ensureNonNullItemContainers();
        
        _parent = parent;
        _root = root.map(IndexableDataHolder.class::cast)
                    .or(() -> _parent.map(IndexableDataHolder::getRootDataHolder)) // if no root is specified but a parent, the root is the parent's root
                    .orElse(this); // if no root or parent is specified, the root is the current DataHolder
    }
    
    private void _ensureNonNullItemContainers()
    {
        for (ModelItemContainer itemContainer : _itemContainers)
        {
            if (itemContainer == null)
            {
                throw new NullPointerException(String.format("Invalid item containers for creating DefaultModelAwareDataHolder, one of them is null: %s", _itemContainers));
            }
        }
    }
    
    public IndexableComposite getComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getValue(compositePath);
        return _getCompositeFromValue(value, compositePath);
    }
    
    public IndexableComposite getLocalComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getLocalValue(compositePath);
        return _getCompositeFromValue(value, compositePath);
    }
    
    public IndexableComposite getExternalComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getExternalValue(compositePath);
        return _getCompositeFromValue(value, compositePath);
    }
    
    private IndexableComposite _getCompositeFromValue(Object value, String compositePath)
    {
        if (value == null)
        {
            return null;
        }
        else if (value instanceof IndexableComposite composite)
        {
            return composite;
        }
        else
        {
            throw new BadItemTypeException("The item at path '" + compositePath + "' is not a composite.");
        }
    }

    public IndexableRepeater getRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getValue(repeaterPath);
        return _getRepeaterFromValue(value, repeaterPath);
    }
    
    public IndexableRepeater getLocalRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getLocalValue(repeaterPath);
        return _getRepeaterFromValue(value, repeaterPath);
    }
    
    public IndexableRepeater getExternalRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        Object value = getExternalValue(repeaterPath);
        return _getRepeaterFromValue(value, repeaterPath);
    }
    
    private IndexableRepeater _getRepeaterFromValue(Object value, String repeaterPath)
    {
        if (value == null)
        {
            return null;
        }
        else if (value instanceof IndexableRepeater repeater)
        {
            return repeater;
        }
        else
        {
            throw new BadItemTypeException("The data at path '" + repeaterPath + "' is not a repeater.");
        }
    }
    
    public <T> T getValue(String dataPath, boolean allowMultiValuedPathSegments) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getValue(dataPath, allowMultiValuedPathSegments, Optional.empty());
    }
    
    public <T> T getLocalValue(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getValue(dataPath, false, Optional.of(ExternalizableDataStatus.LOCAL));
    }
    
    public <T> T getExternalValue(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getValue(dataPath, false, Optional.of(ExternalizableDataStatus.EXTERNAL));
    }
    
    private <T> T _getValue(String dataPath, boolean allowMultiValuedPathSegments, Optional<ExternalizableDataStatus> status) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _checkDefinition(dataPath, status.isPresent(), "Unable to retrieve the value at path '" + dataPath + "'.");
    
        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the data at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            // Simple path => get the value
            ModelItem modelItem = getDefinition(dataPath);
            String dataName = _getFinalDataName(dataPath, status);
            
            if (modelItem instanceof Property property)
            {
                return _getPropertyValue(property);
            }
            else if (modelItem instanceof ElementDefinition elementDefinition)
            {
                return _getElementValue(elementDefinition, dataName);
            }
            else
            {
                return _getGroupValue(modelItem, dataName);
            }
        }
        else
        {
            if (isMultiple(pathSegments[0]))
            {
                if (allowMultiValuedPathSegments)
                {
                    return _getMultipleValues(dataPath);
                }
                else
                {
                    // Multiple items are allowed only at the last segment of the data path
                    throw new BadDataPathCardinalityException("Unable to retrieve the value at path '" + dataPath + "'. The segment '" + pathSegments[0] + "' refers to a multiple data and can not be used inside the data path.");
                }
            }
            else
            {
                // Path where first part is a data holder
                ModelAwareDataHolder dataHolder = getValue(pathSegments[0]);
                if (dataHolder == null)
                {
                    return null;
                }
                else
                {
                    String subDataPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
                    return status.isPresent()
                            ? ExternalizableDataStatus.EXTERNAL.equals(status.get())
                                    ? dataHolder.getExternalValue(subDataPath)
                                    : dataHolder.getLocalValue(subDataPath)
                            : dataHolder.getValue(subDataPath, allowMultiValuedPathSegments);
                }
            }
        }
    }
    
    public ExternalizableDataStatus getStatus(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        _checkDefinition(dataPath, true, "Unable to retrieve the value at path '" + dataPath + "'.");
        
        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the data at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            if (_repositoryData.hasValue(dataPath + STATUS_SUFFIX))
            {
                String status = _repositoryData.getString(dataPath + STATUS_SUFFIX);
                return ExternalizableDataStatus.valueOf(status.toUpperCase());
            }
            else
            {
                return ExternalizableDataStatus.LOCAL;
            }
        }
        else
        {
            if (isMultiple(pathSegments[0]))
            {
                // Multiple items are allowed only at the last segment of the data path
                throw new BadDataPathCardinalityException("Unable to retrieve the value at path '" + dataPath + "'. The segment '" + pathSegments[0] + "' refers to a multiple data and can not be used inside the data path.");
            }
            else
            {
                // Path where first part is a data holder
                ModelAwareDataHolder dataHolder = getValue(pathSegments[0]);
                if (dataHolder == null)
                {
                    return null;
                }
                else
                {
                    String subDataPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
                    return dataHolder.getStatus(subDataPath);
                }
            }
        }
    }
    
    @SuppressWarnings("unchecked")
    private <T> T _getPropertyValue(Property property)
    {
        return getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametyObject ? (T) property.getValue(ametyObject) : null;
    }
    
    @SuppressWarnings("unchecked")
    private <T> T _getElementValue(ElementDefinition definition, String dataName)
    {
        RepositoryElementType type = (RepositoryElementType) definition.getType();
        Object value = type.read(_repositoryData, dataName);

        if (definition.isMultiple() && type.getManagedClass().isInstance(value))
        {
            // The value is single but should be an array. Create the array with the single value
            T arrayValue = (T) Array.newInstance(type.getManagedClass(), 1);
            Array.set(arrayValue, 0, value);
            return arrayValue;
        }
        else if (!definition.isMultiple() && type.getManagedClassArray().isInstance(value))
        {
            // The value is multiple but should be single. Retrieve the first value of the array
            return Array.getLength(value) > 0 ? (T) Array.get(value, 0) : null;
        }
        else
        {
            return (T) value;
        }
    }
    
    @SuppressWarnings("unchecked")
    private <T> T _getGroupValue(ModelItem modelItem, String dataName)
    {
        if (modelItem instanceof RepeaterDefinition)
        {
            Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(dataName);
            if (repeaterNameAndEntryPosition != null)
            {
                return (T) DataHolderHelper.getRepeaterEntry(this, repeaterNameAndEntryPosition.getLeft(), repeaterNameAndEntryPosition.getRight());
            }
            else
            {
                return (T) _getRepeater(dataName, (RepeaterDefinition) modelItem);
            }
        }
        else
        {
            return (T) _getComposite(dataName, (CompositeDefinition) modelItem);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T _getMultipleValues(String dataPath)
    {
        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        String subDataPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
        Class managedClass = _getManagedClass(this, dataPath);
        
        Object segmentValue = getValue(pathSegments[0]);
        if (segmentValue == null)
        {
            return (T) Array.newInstance(managedClass, 0);
        }

        if (segmentValue instanceof ModelAwareRepeater)
        {
            ModelAwareRepeater repeater = (ModelAwareRepeater) segmentValue;
            return DataHolderHelper.aggregateMultipleValues(repeater.getEntries(), subDataPath, managedClass);
        }
        else
        {
            ModelAwareDataHolder[] dataHolders = (ModelAwareDataHolder[]) segmentValue;
            return DataHolderHelper.aggregateMultipleValues(Arrays.asList(dataHolders), subDataPath, managedClass);
        }
    }

    private Class _getManagedClass(ModelAwareDataHolder dataHolder, String dataPath)
    {
        Class managedClass;
        ModelItem modelItem = dataHolder.getDefinition(dataPath);
        if (modelItem instanceof ElementDefinition)
        {
            managedClass = ((ElementDefinition) modelItem).getType().getManagedClass();
        }
        else
        {
            if (modelItem instanceof RepeaterDefinition)
            {
                Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(dataPath);
                managedClass = repeaterNameAndEntryPosition != null ? _getRepeaterEntryClass() : _getRepeaterClass();
            }
            else
            {
                managedClass = _getCompositeClass();
            }
        }
        return managedClass;
    }
    
    /**
     * Retrieves the class of the managed repeater entries
     * @return the class of the managed repeater entries
     */
    protected Class _getRepeaterEntryClass()
    {
        return ModelAwareRepeaterEntry.class;
    }
    
    /**
     * Retrieves the class of the managed repeaters
     * @return the class of the managed repeaters
     */
    protected Class _getRepeaterClass()
    {
        return ModelAwareRepeater.class;
    }
    
    /**
     * Retrieves the class of the managed composites
     * @return the class of the managed composites
     */
    protected Class _getCompositeClass()
    {
        return ModelAwareComposite.class;
    }
    
    public <T> T getValue(String dataPath, boolean useDefaultFromModel, T defaultValue) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _checkDefinition(dataPath, "Unable to retrieve the value at path '" + dataPath + "'.");
        
        if (hasValue(dataPath))
        {
            return  getValue(dataPath);
        }
        
        if (useDefaultFromModel)
        {
            ModelItem modelItem = getDefinition(dataPath);
     
            if (modelItem instanceof ElementDefinition)
            {
                @SuppressWarnings("unchecked")
                T defaultFromModel = (T) ((ElementDefinition) modelItem).getDefaultValue();
                if (defaultFromModel != null)
                {
                    return defaultFromModel;
                }
            }
        }

        return defaultValue;
    }
    
    /**
     * Retrieves the composite with the given name
     * @param name name of the composite to retrieve
     * @param compositeDefinition the definition of the composite to retrieve
     * @return the composite
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a composite
     */
    protected ModelAwareComposite _getComposite(String name, CompositeDefinition compositeDefinition) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) compositeDefinition.getType();
        RepositoryData compositeRepositoryData = type.read(_repositoryData, name);
        
        if (compositeRepositoryData != null)
        {
            return new DefaultModelAwareComposite(compositeRepositoryData, compositeDefinition, this, _root);
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Retrieves the repeater with the given name
     * @param name name of the repeater to retrieve
     * @param repeaterDefinition the definition of the repeater to retrieve
     * @return the repeater
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a repeater
     */
    protected ModelAwareRepeater _getRepeater(String name, RepeaterDefinition repeaterDefinition) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) repeaterDefinition.getType();
        RepositoryData repeaterRepositoryData = type.read(_repositoryData, name);
        
        if (repeaterRepositoryData != null)
        {
            return new DefaultModelAwareRepeater(repeaterRepositoryData, repeaterDefinition, this, _root);
        }
        else
        {
            return null;
        }
    }
    
    public boolean hasValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValue(dataPath, Optional.empty());
    }
    
    public boolean hasLocalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValue(dataPath, Optional.of(ExternalizableDataStatus.LOCAL));
    }
    
    public boolean hasExternalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValue(dataPath, Optional.of(ExternalizableDataStatus.EXTERNAL));
    }
    
    @SuppressWarnings("unchecked")
    private boolean _hasValue(String dataPath, Optional<ExternalizableDataStatus> status) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        if (!hasDefinition(dataPath))
        {
            return false;
        }
        
        if (StringUtils.isEmpty(dataPath))
        {
            throw new IllegalArgumentException("Unable to check if there is a non empty value at the given path. This path is empty.");
        }
        else if (!dataPath.contains(ModelItem.ITEM_PATH_SEPARATOR))
        {
            if (DataHolderHelper.isRepeaterEntryPath(dataPath))
            {
                Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(dataPath);
                return DataHolderHelper.hasNonEmptyRepeaterEntry(this, repeaterNameAndEntryPosition.getLeft(), repeaterNameAndEntryPosition.getRight());
            }
            else
            {
                if (getDefinition(dataPath) instanceof Property property)
                {
                    if (getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametysObject)
                    {
                        return property.getValue(ametysObject) != null;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    RepositoryModelItemType type = getType(dataPath);
                    String dataName = _getFinalDataName(dataPath, status);
                        
                    try
                    {
                        return type.hasNonEmptyValue(_repositoryData, dataName);
                    }
                    catch (BadItemTypeException e)
                    {
                        return false;
                    }
                }
            }
        }
        else
        {
            String parentPath = StringUtils.substringBeforeLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to check if there is a value at path '" + dataPath + "'. The segment '" + parentPath + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            try
            {
                ModelAwareDataHolder parent = getValue(parentPath);
                if (parent == null)
                {
                    return false;
                }
                else
                {
                    String childName = StringUtils.substringAfterLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
                    return status.isPresent()
                            ? ExternalizableDataStatus.EXTERNAL.equals(status.get())
                                    ? parent.hasExternalValue(childName)
                                    : parent.hasLocalValue(childName)
                            : parent.hasValue(childName);
                }
            }
            catch (BadItemTypeException e)
            {
                return false;
            }
        }
    }

    public boolean hasValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValueOrEmpty(dataPath, Optional.empty());
    }
    
    public boolean hasLocalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValueOrEmpty(dataPath, Optional.of(ExternalizableDataStatus.LOCAL));
    }
    
    public boolean hasExternalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _hasValueOrEmpty(dataPath, Optional.of(ExternalizableDataStatus.EXTERNAL));
    }
    
    @SuppressWarnings("unchecked")
    private boolean _hasValueOrEmpty(String dataPath, Optional<ExternalizableDataStatus> status) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        if (!hasDefinition(dataPath))
        {
            return false;
        }
        
        if (StringUtils.isEmpty(dataPath))
        {
            throw new IllegalArgumentException("Unable to check if there is a value at the given path. This path is empty.");
        }
        else if (!dataPath.contains(ModelItem.ITEM_PATH_SEPARATOR))
        {
            if (DataHolderHelper.isRepeaterEntryPath(dataPath))
            {
                Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(dataPath);
                return DataHolderHelper.hasRepeaterEntry(this, repeaterNameAndEntryPosition.getLeft(), repeaterNameAndEntryPosition.getRight());
            }
            else
            {
                if (getDefinition(dataPath) instanceof Property property)
                {
                    if (getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametysObject)
                    {
                        return property.getValue(ametysObject) != null;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    RepositoryModelItemType type = getType(dataPath);
                    String dataName = _getFinalDataName(dataPath, status);
                    return type.hasValue(_repositoryData, dataName);
                }
            }
        }
        else
        {
            String parentPath = StringUtils.substringBeforeLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to check if there is a value at path '" + dataPath + "'. The segment '" + parentPath + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            try
            {
                ModelAwareDataHolder parent = getValue(parentPath);
                if (parent == null)
                {
                    return false;
                }
                else
                {
                    String childName = StringUtils.substringAfterLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
                    return status.isPresent()
                            ? ExternalizableDataStatus.EXTERNAL.equals(status.get())
                                    ? parent.hasExternalValueOrEmpty(childName)
                                    : parent.hasLocalValueOrEmpty(childName)
                            : parent.hasValueOrEmpty(childName);
                }
            }
            catch (BadItemTypeException e)
            {
                return false;
            }
        }
    }
    
    /**
     * Retrieves the name of the data according to the given status
     * @param dataName the name of the data
     * @param status the status
     * @return the final name of the data
     */
    protected String _getFinalDataName(String dataName, Optional<ExternalizableDataStatus> status)
    {
        if (status.isPresent() && getStatus(dataName) != status.get())
        {
            return dataName + ALTERNATIVE_SUFFIX;
        }
        
        return dataName;
    }
    
    public Collection< ? extends ModelItemContainer> getModel()
    {
        return _itemContainers;
    }
    
    public ModelItem getDefinition(String path) throws IllegalArgumentException, UndefinedItemPathException
    {
        try
        {
            ModelItem definition = IndexableDataHolder.super.getDefinition(path);
            
            // A definition has been found, ok
            return definition;
        }
        catch (UndefinedItemPathException e)
        {
            // Look for system properties
            if (StringUtils.contains(path, ModelItem.ITEM_PATH_SEPARATOR))
            {
                String parentDataPath = StringUtils.substringBeforeLast(path, ModelItem.ITEM_PATH_SEPARATOR);
                ModelItem modelItem = getDefinition(parentDataPath);
                if (modelItem instanceof ContentElementDefinition)
                {
                    SystemPropertyExtensionPoint contentSystemPropertyExtensionPoint = IndexableDataHolderHelper.getContentSystemPropertyExtensionPoint();
                    String propertyName = StringUtils.substringAfterLast(path, ModelItem.ITEM_PATH_SEPARATOR);
                    if (contentSystemPropertyExtensionPoint.hasExtension(propertyName))
                    {
                        return contentSystemPropertyExtensionPoint.getExtension(propertyName);
                    }
                }
            }
            else if (getParentDataHolder().isEmpty()
                    && getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametysObject
                    && ametysObject.getSystemPropertyExtensionPoint().isPresent())
            {
                SystemPropertyExtensionPoint systemPropertyExtensionPoint = ametysObject.getSystemPropertyExtensionPoint().get();
                if (systemPropertyExtensionPoint.hasExtension(path))
                {
                    return systemPropertyExtensionPoint.getExtension(path);
                }
            }
            
            // No system property has been found, throw the UndefinedItemPathException
            throw e;
        }
    }

    public Collection<String> getDataNames()
    {
        return ModelHelper.getModelItems(getModel())
                          .stream()
                          .map(ModelItem::getName)
                          .filter(this::hasValueOrEmpty)
                          .toList();
    }
    
    @SuppressWarnings("unchecked")
    public void dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context) throws SAXException
    {
        _checkDefinition(dataPath, "Unable to generate SAX events for the data at path '" + dataPath + "'.");
        
        DataContext newContext = _addObjectInfoToContext(context);
        if (StringUtils.isBlank(newContext.getDataPath()))
        {
            newContext.withDataPath(dataPath);
        }
        
        if (IndexableDataHolderHelper.renderValue(this, dataPath, newContext, false) && IndexableDataHolderHelper.hasValue(this, dataPath, newContext))
        {
            ModelItem modelItem = getDefinition(dataPath);
            if (modelItem instanceof Property property)
            {
                ModelAwareDataAwareAmetysObject ametysObject = _getPropertysAmetysObject(dataPath);
                property.valueToSAX(contentHandler, ametysObject, newContext);
            }
            else
            {
                ModelItemType type = modelItem.getType();
                Object value = getValue(dataPath);
                
                type.valueToSAX(contentHandler, modelItem.getName(), value, newContext);
            }
        }
    }
    
    public void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        DataContext newContext = _addObjectInfoToContext(context);
        IndexableDataHolderHelper.dataToSAX(this, contentHandler, viewItemAccessor, newContext, false);
    }
    
    public void dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        DataContext newContext = _addObjectInfoToContext(context);
        IndexableDataHolderHelper.dataToSAX(this, contentHandler, viewItemAccessor, newContext, true);
    }
    
    @SuppressWarnings("unchecked")
    public Object dataToJSON(String dataPath, DataContext context)
    {
        _checkDefinition(dataPath, "Unable to convert the data at path '" + dataPath + "' to JSON.");
        
        DataContext newContext = _addObjectInfoToContext(context)
                                .withDataPath(dataPath);
        
        if (IndexableDataHolderHelper.renderValue(this, dataPath, newContext, false) && IndexableDataHolderHelper.hasValue(this, dataPath, newContext))
        {
            ModelItem modelItem = getDefinition(dataPath);
            if (modelItem instanceof Property property)
            {
                ModelAwareDataAwareAmetysObject ametysObject = _getPropertysAmetysObject(dataPath);
                return property.valueToJSON(ametysObject, newContext);
            }
            else
            {
                ModelItemType type = modelItem.getType();
                Object value = getValue(dataPath);
                
                return type.valueToJSONForClient(value, newContext);
            }
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Retrieves the ametys object containing the property at the given path
     * @param dataPath the path of the property
     * @return the ametys object containing the property
     * @throws UndefinedItemPathException if the given path does not represent a property
     */
    protected ModelAwareDataAwareAmetysObject _getPropertysAmetysObject(String dataPath) throws UndefinedItemPathException
    {
        if (StringUtils.contains(dataPath, ModelItem.ITEM_PATH_SEPARATOR))
        {
            String parentDataPath = StringUtils.substringBeforeLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
            ContentValue value = getValue(parentDataPath);
            return value.getContent();
        }
        else if (getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametysObject)
        {
            return ametysObject;
        }
        else
        {
            throw new UndefinedItemPathException("There is no property at path '" + dataPath + "'");
        }
    }
    
    public Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        DataContext newContext = _addObjectInfoToContext(context);
        return IndexableDataHolderHelper.dataToJSON(this, viewItemAccessor, newContext, false);
    }
    
    public Map<String, Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        DataContext newContext = _addObjectInfoToContext(context);
        return IndexableDataHolderHelper.dataToJSON(this, viewItemAccessor, newContext, true);
    }
    
    public Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor, DataContext context)
    {
        DataContext newContext = _addObjectInfoToContext(context);
        return IndexableDataHolderHelper.dataToMap(this, viewItemAccessor, newContext);
    }
    
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws UndefinedItemPathException, BadItemTypeException
    {
        return hasDifferences(viewItemAccessor, values, _createSynchronizationContextInstance());
    }
    
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException
    {
        return _hasDifferences(viewItemAccessor, values, context);
    }
    
    /**
     * Check if there are differences between the given values and the current ones
     * @param viewItemAccessor The {@link ViewItemAccessor} for all items to check
     * @param values the values to check
     * @param context the context of the synchronization
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws UndefinedItemPathException if a key in the given Map refers to a data that is not defined by the model
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    protected boolean _hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException
    {
        for (ViewItem viewItem : viewItemAccessor.getViewItems())
        {
            if (viewItem instanceof ModelViewItem)
            {
                if (viewItem instanceof ModelViewItemGroup group && _hasDifferencesInGroup(group, values, context)
                    || viewItem instanceof ViewElement element && _hasDifferencesInElement(element, values, context))
                {
                    return true;
                }
            }
            else if (viewItem instanceof ViewItemAccessor accessor && _hasDifferences(accessor, values, context))
            {
                return true;
            }
        }
        
        // No difference has been found
        return false;
    }

    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws UndefinedItemPathException, BadItemTypeException
    {
        return getDifferences(viewItemAccessor, values, _createSynchronizationContextInstance());
    }
    
    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException
    {
        return _getDifferences(viewItemAccessor, values, context);
    }
    
    /**
     * Get the collection of model items where there are differences between the given values and the current ones
     * @param viewItemAccessor The {@link ViewItemAccessor} for all items to check
     * @param values the values to check
     * @param context the context of the synchronization
     * @return a collection of model items with differences
     * @throws UndefinedItemPathException if a key in the given Map refers to a data that is not defined by the model
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    protected Collection<ModelItem> _getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException
    {
        Set<ModelItem> modelItems = new HashSet<>();
        
        for (ViewItem viewItem : viewItemAccessor.getViewItems())
        {
            if (viewItem instanceof ModelViewItem)
            {
                if (viewItem instanceof ModelViewItemGroup group)
                {
                    modelItems.addAll(_getDifferencesInGroup(group, values, context));
                }
                else if (viewItem instanceof ViewElement element)
                {
                    if (_hasDifferencesInElement(element, values, context))
                    {
                        modelItems.add(element.getDefinition());
                    }
                }
            }
            else if (viewItem instanceof ViewItemAccessor accessor)
            {
                modelItems.addAll(_getDifferences(accessor, values, context));
            }
        }
        
        return modelItems;
    }
    
    /**
     * Check if there are differences between the given values and the given group's ones
     * @param modelViewItemGroup the group
     * @param values the values to check
     * @param synchronizationContext the context of the synchronization
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws UndefinedItemPathException if a key in the given Map refers to a data that is not defined by the model
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    @SuppressWarnings("unchecked")
    protected boolean _hasDifferencesInGroup(ModelViewItemGroup modelViewItemGroup, Map<String, Object> values, SynchronizationContext synchronizationContext) throws UndefinedItemPathException, BadItemTypeException
    {
        ModelItem modelItem = modelViewItemGroup.getDefinition();
        String dataName = modelItem.getName();
        Object value = values.get(dataName);
        if (value instanceof UntouchedValue)
        {
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(modelViewItemGroup);
                __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
            }
            return false;
        }
        else if (value == null)
        {
            ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
            return DataHolderHelper.hasValueOrEmpty(this, dataName, valueContext);
        }
        else if (modelItem instanceof RepeaterDefinition)
        {
            if (value instanceof SynchronizableRepeater || value instanceof List)
            {
                ModelAwareRepeater repeater = getRepeater(dataName);
                SynchronizableRepeater repeaterValues = value instanceof SynchronizableRepeater ? (SynchronizableRepeater) value : SynchronizableRepeater.replaceAll((List<Map<String, Object>>) value, null);

                if (repeater == null)
                {
                    if (__LOGGER.isDebugEnabled())
                    {
                        String viewItemPath = ViewHelper.getModelViewItemPath(modelViewItemGroup);
                        __LOGGER.debug("#hasDifferences[{}] differences detected: repeater will be created", viewItemPath);
                    }
                    return true;
                }
                else
                {
                    return repeater.hasDifferences(modelViewItemGroup, repeaterValues, synchronizationContext);
                }
            }
            else
            {
                throw new BadItemTypeException("Unable to check differences for the repeater named '" + dataName + "': the given value should be a list containing its entries");
            }
        }
        else
        {
            if (value instanceof Map)
            {
                ModelAwareComposite composite = getComposite(dataName);
                if (composite == null)
                {
                    if (__LOGGER.isDebugEnabled())
                    {
                        String viewItemPath = ViewHelper.getModelViewItemPath(modelViewItemGroup);
                        __LOGGER.debug("#hasDifferences[{}] differences detected: composite will be created", viewItemPath);
                    }
                    return true;
                }
                else
                {
                    return composite.hasDifferences(modelViewItemGroup, (Map<String, Object>) value, synchronizationContext);
                }
            }
            else
            {
                throw new BadItemTypeException("Unable to synchronize the composite named '" + dataName + "': the given value should be a map containing values of all of its items");
            }
        }
    }
    
    /**
     * Get the collection of model items where there are differences between the given values and the given group's ones
     * @param modelViewItemGroup the group
     * @param values the values to check
     * @param synchronizationContext the context of the synchronization
     * @return a collection of model items with differences
     * @throws UndefinedItemPathException if a key in the given Map refers to a data that is not defined by the model
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    @SuppressWarnings("unchecked")
    protected Collection<ModelItem> _getDifferencesInGroup(ModelViewItemGroup modelViewItemGroup, Map<String, Object> values, SynchronizationContext synchronizationContext) throws UndefinedItemPathException, BadItemTypeException
    {
        Set<ModelItem> modelItems = new HashSet<>();
        
        ModelItem modelItem = modelViewItemGroup.getDefinition();
        String dataName = modelItem.getName();
        Object value = values.get(dataName);
        if (value instanceof UntouchedValue)
        {
            return modelItems;
        }
        else if (value == null)
        {
            ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
            if (DataHolderHelper.hasValueOrEmpty(this, dataName, valueContext))
            {
                modelItems.addAll(ViewHelper.getModelItems(modelViewItemGroup));
            }
        }
        else if (modelItem instanceof RepeaterDefinition)
        {
            if (value instanceof SynchronizableRepeater || value instanceof List)
            {
                ModelAwareRepeater repeater = getRepeater(dataName);
                SynchronizableRepeater repeaterValues = value instanceof SynchronizableRepeater ? (SynchronizableRepeater) value : SynchronizableRepeater.replaceAll((List<Map<String, Object>>) value, null);

                if (repeater == null)
                {
                    modelItems.addAll(ViewHelper.getModelItems(modelViewItemGroup));
                }
                else
                {
                    modelItems.addAll(repeater.getDifferences(modelViewItemGroup, repeaterValues, synchronizationContext));
                }
            }
            else
            {
                throw new BadItemTypeException("Unable to check differences for the repeater named '" + dataName + "': the given value should be a list containing its entries");
            }
        }
        else
        {
            if (value instanceof Map)
            {
                ModelAwareComposite composite = getComposite(dataName);
                if (composite == null)
                {
                    modelItems.addAll(ViewHelper.getModelItems(modelViewItemGroup));
                }
                else
                {
                    modelItems.addAll(composite.getDifferences(modelViewItemGroup, (Map<String, Object>) value, synchronizationContext));
                }
            }
            else
            {
                throw new BadItemTypeException("Unable to synchronize the composite named '" + dataName + "': the given value should be a map containing values of all of its items");
            }
        }
        
        return modelItems;
    }
    
    /**
     * Check if there are differences between the given values and the given element's ones
     * @param viewElement the element
     * @param values the values to check
     * @param synchronizationContext the context of the synchronization
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws UndefinedItemPathException if a key in the given Map refers to a data that is not defined by the model
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    protected boolean _hasDifferencesInElement(ViewElement viewElement, Map<String, Object> values, SynchronizationContext synchronizationContext) throws UndefinedItemPathException, BadItemTypeException
    {
        ElementDefinition definition = viewElement.getDefinition();
        String dataName = definition.getName();
        
        Object valueFromMap = values.get(dataName);
        ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
        
        SynchronizableValue syncValue = valueFromMap instanceof SynchronizableValue ? (SynchronizableValue) valueFromMap : new SynchronizableValue(valueFromMap, valueContext.getStatus().orElse(null));
        Object value = syncValue.getValue(valueContext.getStatus());

        if (!(value instanceof UntouchedValue))
        {
            Object defaultValue = definition.getDefaultValue();
            if (value == null && synchronizationContext.useDefaultFromModel() && defaultValue != null)
            {
                if (_checkElementDifferences(viewElement, new SynchronizableValue(defaultValue, valueContext.getStatus().orElse(null)), valueContext))
                {
                    return true;
                }
            }
            else
            {
                if (values.containsKey(dataName))
                {
                    if (_checkElementDifferences(viewElement, syncValue, valueContext))
                    {
                        return true;
                    }
                }
                else if (DataHolderHelper.hasValueOrEmpty(this, dataName, valueContext))
                {
                    if (__LOGGER.isDebugEnabled())
                    {
                        String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                        __LOGGER.debug("#hasDifferences[{}] differences detected: value will be removed", viewItemPath);
                    }
                    return true;
                }
            }
        }
        
        if (_checkStatusDifferences(definition, syncValue, synchronizationContext, values.containsKey(dataName)))
        {
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                __LOGGER.debug("#hasDifferences[{}] differences detected: status will change", viewItemPath);
            }
            return true;
        }
        
        // No difference has been found
        if (__LOGGER.isDebugEnabled())
        {
            String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
            __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
        }
        return false;
    }
    
    /**
     * Check if there are differences between the given value and the given view element's value
     * @param viewElement the element
     * @param value the value to check
     * @param context context of the data to check
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data name is null or empty
     * @throws UndefinedItemPathException if the given data name is not defined by the model
     * @throws BadItemTypeException if the type defined by the model doesn't match the given value to set
     */
    protected boolean _checkElementDifferences(ViewElement viewElement, SynchronizableValue value, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException
    {
        ElementDefinition definition = viewElement.getDefinition();
        String dataName = definition.getName();
        
        if (SynchronizableValue.Mode.REMOVE.equals(value.getMode()))
        {
            return _checkElementDifferencesInRemoveMode(viewElement, value, context);
        }
        
        if (SynchronizableValue.Mode.APPEND.equals(value.getMode()) && isMultiple(dataName))
        {
            Object valuesToAppend = DataHolderHelper.getArrayValuesFromSynchronizableValue(value, context);
            boolean hasValuesToAppend = Array.getLength(valuesToAppend) > 0;
            
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                if (hasValuesToAppend)
                {
                    __LOGGER.debug("#hasDifferences[{}] differences detected: values {} will be appended", viewItemPath, valuesToAppend);
                }
                else
                {
                    __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
                }
            }
            
            return hasValuesToAppend;
        }
        
        boolean hasValueOrEmpty = DataHolderHelper.hasValueOrEmpty(this, dataName, context);
        boolean hasEmptyValue = hasValueOrEmpty && !DataHolderHelper.hasValue(this, dataName, context);
        Object newValue = value.getValue(context.getStatus());
        
        if (newValue == null && hasEmptyValue)
        {
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
            }
            
            return false;
        }
        else if (hasValueOrEmpty)
        {
            Object oldValue = DataHolderHelper.getValue(this, dataName, context);
            ElementType type = ((ElementDefinition) getDefinition(dataName)).getType();
            
            // Check if there are differences between old and new value
            boolean hasDiff = type.compareValues(newValue, oldValue).count() > 0;

            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                if (hasDiff)
                {
                    __LOGGER.debug("#hasDifferences[{}] differences detected: {} will replace {}", viewItemPath, newValue, oldValue);
                }
                else
                {
                    __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
                }
            }

            return hasDiff;
        }
        else
        {
            // There was no values at all, one should be set (even empty)

            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                __LOGGER.debug("#hasDifferences[{}] differences detected: {} will replace emty value", viewItemPath, newValue);
            }

            return true;
        }
    }
    
    /**
     * Check if there are differences between the given value and the given view element's value
     * @param viewElement the element
     * @param value the value to check
     * @param context context of the data to check
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data name is null or empty
     * @throws UndefinedItemPathException if the given data name is not defined by the model
     * @throws BadItemTypeException if the type defined by the model doesn't match the given value to set
     */
    protected boolean _checkElementDifferencesInRemoveMode(ViewElement viewElement, SynchronizableValue value, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException
    {
        ElementDefinition definition = viewElement.getDefinition();
        String dataName = definition.getName();
        
        boolean hasValue = DataHolderHelper.hasValueOrEmpty(this, dataName, context);
        
        if (hasValue && isMultiple(dataName))
        {
            Object oldValues = DataHolderHelper.getValue(this, dataName, context);
            Object valuesToRemove = DataHolderHelper.getArrayValuesFromSynchronizableValue(value, context);
            ElementType type = ((ElementDefinition) getDefinition(dataName)).getType();

            // Remove the given values from the existent ones
            Object newValues = DataHolderHelper.removeValuesInArray(oldValues, valuesToRemove, type);

            boolean hasDiff = Array.getLength(oldValues) > Array.getLength(newValues);
            
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                if (hasDiff)
                {
                    __LOGGER.debug("#hasDifferences[{}] differences detected: some values of {} will be removed from {}", viewItemPath, valuesToRemove, oldValues);
                }
                else
                {
                    __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
                }
            }
            
            return hasDiff;
        }
        else
        {
            if (__LOGGER.isDebugEnabled())
            {
                String viewItemPath = ViewHelper.getModelViewItemPath(viewElement);
                if (hasValue)
                {
                    Object oldValue = DataHolderHelper.getValue(this, dataName, context);
                    __LOGGER.debug("#hasDifferences[{}] differences detected: value {} will be removed", viewItemPath, oldValue);
                }
                else
                {
                    __LOGGER.debug("#hasDifferences[{}] no difference detected.", viewItemPath);
                }
            }
            
            return hasValue;
        }
    }
    
    /**
     * Check if the data's status will have to be changed
     * @param definition definition of the data
     * @param value the value
     * @param synchronizationContext the context of the synchronization
     * @param doValuesContainData <code>true</code> if the values contain the data, <code>false</code> otherwise
     * @return <code>true</code> if the status has changed, <code>false</code> otherwise
     */
    protected boolean _checkStatusDifferences(ElementDefinition definition, SynchronizableValue value, SynchronizationContext synchronizationContext, boolean doValuesContainData)
    {
        if (DataHolderHelper.getExternalizableDataProviderExtensionPoint().isDataExternalizable(getRootDataHolder(), definition))
        {
            String dataName = definition.getName();
            ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
        
            ExternalizableDataStatus oldStatus = null;
            if (_repositoryData.hasValue(dataName + STATUS_SUFFIX))
            {
                String status = _repositoryData.getString(dataName + STATUS_SUFFIX);
                oldStatus = ExternalizableDataStatus.valueOf(status.toUpperCase());
            }
            
            ExternalizableDataStatus newStatus = value.getExternalizableStatus();
            
            return synchronizationContext.forceStatusIfNotPresent() && oldStatus == null && newStatus == null && doValuesContainData && valueContext.getStatus().isPresent()
                || newStatus != null && !newStatus.equals(oldStatus);
        }
        else
        {
            return false;
        }
    }
    
    /**
     * Creates an instance of {@link SynchronizationContext}
     * @param <T> the type of the {@link SynchronizationContext}
     * @return the created {@link SynchronizationContext}
     */
    @SuppressWarnings("unchecked")
    protected <T extends SynchronizationContext> T _createSynchronizationContextInstance()
    {
        return (T) SynchronizationContext.newInstance();
    }
    
    private DataContext _addObjectInfoToContext(DataContext context)
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        RepositoryDataContext newContext = RepositoryDataContext.newInstance(context);
        if (root instanceof DataAwareAmetysObject ametysObject)
        {
            newContext.withObject(ametysObject);
        }
        
        return newContext;
    }
    
    public RepositoryData getRepositoryData()
    {
        return _repositoryData;
    }
    
    public Optional<? extends IndexableDataHolder> getParentDataHolder()
    {
        return _parent;
    }
    
    public IndexableDataHolder getRootDataHolder()
    {
        return _root;
    }
    
    /**
     * Check definition for data path
     * @param dataPath the data path
     * @param errorMsg the error message to throw
     */
    protected void _checkDefinition(String dataPath, String errorMsg)
    {
        _checkDefinition(dataPath, false, errorMsg);
    }
    
    /**
     * Check definition for data path
     * @param dataPath the data path
     * @param checkStatusAvailable <code>true</code> to check if the definition supports externalizable data status
     * @param errorMsg the error message to throw
     */
    protected void _checkDefinition(String dataPath, boolean checkStatusAvailable, String errorMsg)
    {
        // Check if the model exists
        if (_itemContainers.isEmpty())
        {
            throw new UndefinedItemPathException(errorMsg + " No model is defined for this object [" + getRootDataHolder() + "]");
        }
        
        // Check that there is an item at the given path
        if (!hasDefinition(dataPath))
        {
            throw new UndefinedItemPathException(errorMsg + " There is no such item defined by the model.");
        }
        
        // Externalizable data status is not available for properties
        if (checkStatusAvailable && getDefinition(dataPath) instanceof Property)
        {
            throw new UndefinedItemPathException(errorMsg + " A property can't have an externalizable status.");
        }
    }
}