/*
 *  Copyright 2018 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.plugins.repository.data.holder.impl;

import java.io.IOException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.data.DataComment;
import org.ametys.plugins.repository.data.UnknownDataException;
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.ModifiableModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.impl.ModifiableModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.impl.ModifiableModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.impl.ModifiableModelAwareRepeaterEntry;
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.SynchronizationResult;
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.ModifiableRepositoryData;
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.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
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.ModelItemGroup;
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.ViewItemContainer;
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.ElementType;

/**
 * Default implementation for modifiable data holder with model
 */
public class DefaultModifiableModelAwareDataHolder extends DefaultModelAwareDataHolder implements ModifiableModelAwareDataHolder
{
    private static final String __TEMP_SUFFIX = "__temp";
    
    /** Repository data to use to store data in the repository */
    protected ModifiableRepositoryData _modifiableRepositoryData;
    
    /** Parent of the current {@link DataHolder} */
    protected Optional<? extends ModifiableModelAwareDataHolder> _modifiableParent;
    
    /** Root {@link DataHolder} */
    protected ModifiableModelAwareDataHolder _modifiableRoot;
    
    /**
     * Creates a modifiable 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.
     */
    public DefaultModifiableModelAwareDataHolder(ModifiableRepositoryData repositoryData, ModelItemContainer... itemContainers)
    {
        this(repositoryData, Optional.empty(), Optional.empty(), Arrays.asList(itemContainers));
    }
    
    /**
     * Creates a modifiable 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.
     */
    public DefaultModifiableModelAwareDataHolder(ModifiableRepositoryData repositoryData, Collection<? extends ModelItemContainer> itemContainers)
    {
        this(repositoryData, Optional.empty(), Optional.empty(), itemContainers);
    }
    
    /**
     * Creates a modifiable default model aware data holder
     * @param repositoryData the repository data to use
     * @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 DataAwareAmetysObject}
     * @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.
     */
    public DefaultModifiableModelAwareDataHolder(ModifiableRepositoryData repositoryData, Optional<? extends ModifiableModelAwareDataHolder> parent, Optional<? extends ModifiableModelAwareDataHolder> root, ModelItemContainer... itemContainers)
    {
        this(repositoryData, parent, root, Arrays.asList(itemContainers));
    }
    
    
    /**
     * Creates a modifiable default model aware data holder
     * @param repositoryData the repository data to use
     * @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 DataAwareAmetysObject}
     * @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.
     */
    public DefaultModifiableModelAwareDataHolder(ModifiableRepositoryData repositoryData, Optional<? extends ModifiableModelAwareDataHolder> parent, Optional<? extends ModifiableModelAwareDataHolder> root, Collection<? extends ModelItemContainer> itemContainers)
    {
        super(repositoryData, parent, root, itemContainers);
        _modifiableRepositoryData = repositoryData;
        
        _modifiableParent = parent;
        _modifiableRoot = root.map(ModifiableModelAwareDataHolder.class::cast)
                .or(() -> _modifiableParent.map(ModifiableModelAwareDataHolder::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
    }
    
    @Override
    public ModifiableModelAwareComposite getComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareComposite) super.getComposite(compositePath);
    }
    
    @Override
    public ModifiableModelAwareComposite getLocalComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareComposite) super.getLocalComposite(compositePath);
    }
    
    @Override
    public ModifiableModelAwareComposite getExternalComposite(String compositePath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareComposite) super.getExternalComposite(compositePath);
    }

    @Override
    protected ModifiableModelAwareComposite _getComposite(String name, CompositeDefinition compositeDefinition) throws BadItemTypeException
    {
        return _getComposite(name, compositeDefinition, false);
    }

    @Override
    public ModifiableModelAwareRepeater getRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareRepeater) super.getRepeater(repeaterPath);
    }
    
    @Override
    public ModifiableModelAwareRepeater getLocalRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareRepeater) super.getLocalRepeater(repeaterPath);
    }
    
    @Override
    public ModifiableModelAwareRepeater getExternalRepeater(String repeaterPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return (ModifiableModelAwareRepeater) super.getExternalRepeater(repeaterPath);
    }
    
    @Override
    protected ModifiableModelAwareRepeater _getRepeater(String name, RepeaterDefinition repeaterDefinition) throws BadItemTypeException
    {
        return _getRepeater(name, repeaterDefinition, false);
    }

    public ModifiableModelAwareComposite getComposite(String compositePath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getComposite(compositePath, createNew, Optional.empty());
    }
    
    public ModifiableModelAwareComposite getLocalComposite(String compositePath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getComposite(compositePath, createNew, Optional.of(ExternalizableDataStatus.LOCAL));
    }
    
    public ModifiableModelAwareComposite getExternalComposite(String compositePath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getComposite(compositePath, createNew, Optional.of(ExternalizableDataStatus.EXTERNAL));
    }

    private ModifiableModelAwareComposite _getComposite(String compositePath, boolean createNew, Optional<ExternalizableDataStatus> status) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        String[] pathSegments = StringUtils.split(compositePath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the composite at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            // Simple path => get composite value
            ModelItem modelItem = getDefinition(compositePath);
            if (modelItem instanceof CompositeDefinition)
            {
                String compositeName = compositePath;
                if (status.isPresent() && getStatus(compositeName) != status.get())
                {
                    compositeName += ALTERNATIVE_SUFFIX;
                }
                return _getComposite(compositeName, (CompositeDefinition) modelItem, createNew);
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + compositePath + "' is not a composite.");
            }
        }
        else
        {
            String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to retrieve the composite at path '" + compositePath + "'. The segment '" + pathSegments[pathSegments.length - 2] + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            Object parentValue = getValue(parentPath);
            String childName = pathSegments[pathSegments.length - 1];
            if (parentValue != null && parentValue instanceof ModifiableModelAwareDataHolder)
            {
                ModifiableModelAwareDataHolder parent = (ModifiableModelAwareDataHolder) parentValue;
                return status.isPresent()
                        ? ExternalizableDataStatus.EXTERNAL.equals(status.get())
                                ? getExternalComposite(compositePath, createNew)
                                : getLocalComposite(compositePath, createNew)
                        : parent.getComposite(childName, createNew);
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + parentPath + "' in the repository doesn't exist or is not a data holder. It can not contain the data named '" + childName + "'.");
            }
        }
    }
    
    /**
     * Retrieves the composite with the given name
     * @param name name of the composite to retrieve
     * @param compositeDefinition the definition of the composite to retrieve
     * @param createNew <code>true</code> to create the repeater if it does not exist, <code>false</code> otherwise
     * @return the composite
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a composite
     */
    protected ModifiableModelAwareComposite _getComposite(String name, CompositeDefinition compositeDefinition, boolean createNew) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) compositeDefinition.getType();
        RepositoryData compositeRepositoryData = type.read(_modifiableRepositoryData, name);
        
        if (compositeRepositoryData != null)
        {
            return new ModifiableModelAwareComposite((ModifiableRepositoryData) compositeRepositoryData, this, _modifiableRoot, compositeDefinition);
        }
        else
        {
            if (createNew)
            {
                ModifiableRepositoryData createdRepositoryData = type.add(_modifiableRepositoryData, name);
                return new ModifiableModelAwareComposite(createdRepositoryData, this, _modifiableRoot, compositeDefinition);
            }
            else
            {
                return null;
            }
        }
    }

    public ModifiableModelAwareRepeater getRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getRepeater(repeaterPath, createNew, Optional.empty());
    }
    
    public ModifiableModelAwareRepeater getLocalRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getRepeater(repeaterPath, createNew, Optional.of(ExternalizableDataStatus.LOCAL));
    }
    
    public ModifiableModelAwareRepeater getExternalRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        return _getRepeater(repeaterPath, createNew, Optional.of(ExternalizableDataStatus.EXTERNAL));
    }

    private ModifiableModelAwareRepeater _getRepeater(String repeaterPath, boolean createNew, Optional<ExternalizableDataStatus> status) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        String[] pathSegments = StringUtils.split(repeaterPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the repeater at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            // Simple path => get composite value
            ModelItem modelItem = getDefinition(repeaterPath);
            if (modelItem instanceof RepeaterDefinition)
            {
                String repeaterName = repeaterPath;
                if (status.isPresent() && getStatus(repeaterName) != status.get())
                {
                    repeaterName += ALTERNATIVE_SUFFIX;
                }
                return _getRepeater(repeaterName, (RepeaterDefinition) modelItem, createNew);
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + repeaterPath + "' is not a repeater.");
            }
        }
        else
        {
            String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to retrieve the repeater at path '" + repeaterPath + "'. The segment '" + pathSegments[pathSegments.length - 2] + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            Object parentValue = getValue(parentPath);
            String childName = pathSegments[pathSegments.length - 1];
            if (parentValue != null && parentValue instanceof ModifiableModelAwareDataHolder)
            {
                ModifiableModelAwareDataHolder parent = (ModifiableModelAwareDataHolder) parentValue;
                return status.isPresent()
                        ? ExternalizableDataStatus.EXTERNAL.equals(status.get())
                                ? parent.getExternalRepeater(repeaterPath, createNew)
                                : parent.getExternalRepeater(repeaterPath, createNew)
                        : parent.getRepeater(childName, createNew);
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + parentPath + "' in the repository doesn't exist or is not a composite or a repeater entry. It can not contain the data named '" + childName + "'.");
            }
        }
    }
    
    /**
     * Retrieves the repeater with the given name
     * @param name name of the repeater to retrieve
     * @param repeaterDefinition the definition of the repeater to retrieve
     * @param createNew <code>true</code> to create the repeater if it does not exist, <code>false</code> otherwise
     * @return the repeater
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a repeater
     */
    protected ModifiableModelAwareRepeater _getRepeater(String name, RepeaterDefinition repeaterDefinition, boolean createNew) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) repeaterDefinition.getType();
        RepositoryData repeaterRepositoryData = type.read(_modifiableRepositoryData, name);
        
        if (repeaterRepositoryData != null)
        {
            return new ModifiableModelAwareRepeater((ModifiableRepositoryData) repeaterRepositoryData, this, _modifiableRoot, repeaterDefinition);
        }
        else
        {
            if (createNew)
            {
                ModifiableRepositoryData createdRepositoryData = type.add(_modifiableRepositoryData, name);
                return new ModifiableModelAwareRepeater(createdRepositoryData, this, _modifiableRoot, repeaterDefinition);
            }
            else
            {
                return null;
            }
        }
    }
    
    @Override
    protected Class _getRepeaterEntryClass()
    {
        return ModifiableModelAwareRepeaterEntry.class;
    }
    
    @Override
    protected Class _getRepeaterClass()
    {
        return ModifiableModelAwareRepeater.class;
    }
    
    @Override
    protected Class _getCompositeClass()
    {
        return ModifiableModelAwareComposite.class;
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(Map<String, Object> values) throws UndefinedItemPathException, BadItemTypeException, IOException
    {
        return synchronizeValues(values, _createSynchronizationContextInstance());
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException, IOException
    {
        ViewItemContainer viewItemContainer = ViewHelper.createEmptyViewItemAccessor(_itemContainers);
        _fillViewItemContainerFromValues(values, viewItemContainer, _itemContainers);
        return synchronizeValues(viewItemContainer, values, context);
    }
    
    private void _fillViewItemContainerFromValues(Map<String, Object> values, ViewItemContainer viewItemContainer, ModelItemContainer modelItemContainer)
    {
        _fillViewItemContainerFromValues(values, viewItemContainer, List.of(modelItemContainer));
    }
    
    @SuppressWarnings("unchecked")
    private void _fillViewItemContainerFromValues(Map<String, Object> values, ViewItemContainer viewItemContainer, Collection<? extends ModelItemContainer> modelItemContainers)
    {
        for (String dataName : values.keySet())
        {
            ModelItem modelItem = ModelHelper.getModelItem(dataName, modelItemContainers);
            if (modelItem instanceof ModelItemGroup)
            {
                Object value = values.get(dataName);
                if (modelItem instanceof RepeaterDefinition)
                {
                    if (value instanceof List)
                    {
                        if (!((List<Map<String, Object>>) value).isEmpty())
                        {
                            Map<String, Object> newValues = ((List<Map<String, Object>>) value).get(0);
                            ModelViewItemGroup modelViewItemGroup = new ModelViewItemGroup();
                            _fillViewItemContainerFromValues(newValues, modelViewItemGroup, (ModelItemGroup) modelItem);
                            modelViewItemGroup.setDefinition((ModelItemGroup) modelItem);
                            viewItemContainer.addViewItem(modelViewItemGroup);
                        }
                    }
                    else
                    {
                        throw new BadItemTypeException("Unable to synchronize the repeater named '" + dataName + "': the given value should be a list containing its entries");
                    }
                }
                else
                {
                    if (value instanceof Map)
                    {
                        Map<String, Object> newValues = (Map<String, Object>) value;
                        ModelViewItemGroup modelViewItemGroup = new ModelViewItemGroup();
                        _fillViewItemContainerFromValues(newValues, modelViewItemGroup, (ModelItemGroup) modelItem);
                        modelViewItemGroup.setDefinition((ModelItemGroup) modelItem);
                        viewItemContainer.addViewItem(modelViewItemGroup);
                    }
                    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");
                    }
                }
            }
            else
            {
                ViewElement viewElement = new ViewElement();
                viewElement.setDefinition((ElementDefinition) modelItem);
                viewItemContainer.addViewItem(viewElement);
            }
            
        }
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(ViewItemContainer viewItemContainer, Map<String, Object> values) throws UndefinedItemPathException, BadItemTypeException, IOException
    {
        return synchronizeValues(viewItemContainer, values, _createSynchronizationContextInstance());
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(ViewItemContainer viewItemContainer, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException, IOException
    {
        return _synchronizeValues(viewItemContainer, values, context);
    }
    
    private <T extends SynchronizationResult> T _synchronizeValues(ViewItemContainer viewItemContainer, Map<String, Object> values, SynchronizationContext context) throws UndefinedItemPathException, BadItemTypeException, IOException
    {
        T result = _createSetValueResultInstance();
        
        for (ViewItem viewItem : viewItemContainer.getViewItems())
        {
            SynchronizationResult itemResult = null;
            if (viewItem instanceof ModelViewItem)
            {
                if (viewItem instanceof ModelViewItemGroup)
                {
                    itemResult = _synchronizeGroup((ModelViewItemGroup) viewItem, values, context);
                }
                else if (viewItem instanceof ViewElement)
                {
                    itemResult = _synchronizeElement((ViewElement) viewItem, values, context);
                }
            }
            else if (viewItem instanceof ViewItemContainer)
            {
                itemResult = _synchronizeValues((ViewItemContainer) viewItem, values, context);
            }
            
            result.aggregateResult(itemResult);
        }
        
        return result;
    }

    @SuppressWarnings("unchecked")
    private <T extends SynchronizationResult> T _synchronizeGroup(ModelViewItemGroup modelViewItemGroup, Map<String, Object> values, SynchronizationContext synchronizationContext) throws IOException
    {
        ModelItem modelItem = modelViewItemGroup.getDefinition();
        String dataName = modelItem.getName();
        Object value = values.get(dataName);
        T result = null;
        
        if (value == null)
        {
            ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
            result = _createSetValueResultInstance();
            if (DataHolderHelper.hasValue(this, dataName, valueContext))
            {
                _removeValueForSynchronize(dataName, valueContext);
                result.setHasChanged(true);
            }
        }
        else if (modelItem instanceof RepeaterDefinition)
        {
            if (value instanceof SynchronizableRepeater || value instanceof List)
            {
                ModifiableModelAwareRepeater repeater = getRepeater(dataName, true);
                SynchronizableRepeater repeaterValues = value instanceof SynchronizableRepeater ? (SynchronizableRepeater) value : SynchronizableRepeater.replaceAll((List<Map<String, Object>>) value, null);
                result = repeater.synchronizeValues(modelViewItemGroup, repeaterValues, synchronizationContext);
            }
            else
            {
                throw new BadItemTypeException("Unable to synchronize the repeater named '" + dataName + "': the given value should be a list containing its entries");
            }
        }
        else
        {
            if (value instanceof Map)
            {
                ModifiableModelAwareComposite composite = getComposite(dataName, true);
                result = composite.synchronizeValues(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");
            }
        }
        
        if (!DataHolderHelper.getExternalizableDataProviderExtensionPoint().isDataExternalizable(getRootDataHolder(), modelItem))
        {
            _removeExternalizableMetadataIfExists(_modifiableRepositoryData, dataName);
        }
        
        return result;
    }
    
    private <T extends SynchronizationResult> T _synchronizeElement(ViewElement viewElement, Map<String, Object> values, SynchronizationContext synchronizationContext) throws IOException
    {
        ElementDefinition definition = viewElement.getDefinition();
        String dataName = definition.getName();
        Object valueFromMap = values.get(dataName);
        SynchronizableValue value = valueFromMap instanceof SynchronizableValue ? (SynchronizableValue) valueFromMap : new SynchronizableValue(valueFromMap);
        ValueContext valueContext = DataHolderHelper.createValueContextFromSynchronizationContext(this, dataName, synchronizationContext);
        T result = null;
        
        if (!(value.getValue() instanceof UntouchedValue))
        {
            
            Object defaultValue = definition.getDefaultValue();
            if (value.getValue() == null && synchronizationContext.useDefaultFromModel() && defaultValue != null)
            {
                result = _setValueForSynchronize(dataName, new SynchronizableValue(defaultValue), valueContext);
            }
            else
            {
                if (values.containsKey(dataName))
                {
                    result = _setValueForSynchronize(dataName, value, valueContext);
                }
                else
                {
                    result = _removeValueForSynchronize(dataName, valueContext);
                }
            }
        }
        else
        {
            result = _createSetValueResultInstance();
        }
        
        boolean isExternalizable = DataHolderHelper.getExternalizableDataProviderExtensionPoint().isDataExternalizable(getRootDataHolder(), definition);
        
        ExternalizableDataStatus newStatus = value.getExternalizableStatus();
        if (isExternalizable && newStatus != null && !newStatus.equals(getStatus(dataName)))
        {
            result.setHasChanged(true);
            setStatus(dataName, newStatus);
        }
        
        List<DataComment> newComments = value.getComments();
        List<DataComment> oldComments = hasComments(dataName) ? getComments(dataName) : List.of();
        if (newComments != null && !newComments.equals(oldComments))
        {
            result.setHasChanged(true);
            setComments(dataName, newComments);
        }
        
        if (!isExternalizable)
        {
            _removeExternalizableMetadataIfExists(_modifiableRepositoryData, dataName);
        }
        
        return result;
    }
    
    /**
     * Sets the value of the data with the given name
     * @param <T> the type of the {@link SynchronizationResult}
     * @param dataName name of the data
     * @param value the value to set. Give <code>null</code> to empty the value.
     * @param context context of the data to set
     * @return the {@link SynchronizationResult}
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws UndefinedItemPathException if the given data path is not defined by the model
     * @throws BadItemTypeException if the type defined by the model doesn't match the given value to set 
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     * @throws IOException if an IO error occurs while comparing values
     */
    protected <T extends SynchronizationResult> T _setValueForSynchronize(String dataName, SynchronizableValue value, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException, IOException
    {
        T result = _createSetValueResultInstance();
        boolean hasValue = DataHolderHelper.hasValue(this, dataName, context);
        
        if (SynchronizableValue.Mode.REMOVE.equals(value.getMode()))
        {
            if (hasValue)
            {
                if (isMultiple(dataName))
                {
                    Object oldValues = DataHolderHelper.getValue(this, dataName, context);
                    Object valuesToRemove = _getValuesInArrayFromSynchronizableValue(value);
                    ElementType type = ((ElementDefinition) getDefinition(dataName)).getType();

                    // Remove the given values from the existent ones
                    Object newValues = _removeArrayValues(oldValues, valuesToRemove, type);
                    
                    if (Array.getLength(oldValues) > Array.getLength(newValues))
                    {
                        result.setHasChanged(true);
                        _setValue(dataName, newValues, context);
                    }
                }
                else
                {
                    result.setHasChanged(true);
                    _removeValue(dataName, context);
                }
            }
        }
        else
        {
            if (hasValue)
            {
                if (SynchronizableValue.Mode.APPEND.equals(value.getMode()) && isMultiple(dataName))
                {
                    Object valuesToAppend = _getValuesInArrayFromSynchronizableValue(value);
                    if (Array.getLength(valuesToAppend) > 0)
                    {
                        Object oldValues = DataHolderHelper.getValue(this, dataName, context);
                        ElementType type = ((ElementDefinition) getDefinition(dataName)).getType();
                        
                        // Append the given values to the existent ones
                        Object newValues = _appendArrayValues(oldValues, valuesToAppend, type);
                        
                        result.setHasChanged(true);
                        _setValue(dataName, newValues, context);
                    }
                }
                else
                {
                    Object oldValue = DataHolderHelper.getValue(this, dataName, context);
                    ElementType type = ((ElementDefinition) getDefinition(dataName)).getType();
                    if (type.compareValues(value.getValue(), oldValue).count() > 0)
                    {
                        // There are differences between old and new value
                        result.setHasChanged(true);
                        _setValue(dataName, value.getValue(), context);
                    }
                }
            }
            else
            {
                // There was no values, set one
                result.setHasChanged(true);
                _setValue(dataName, value.getValue(), context);
            }
        }

        return result;
    }
    
    private Object _getValuesInArrayFromSynchronizableValue(SynchronizableValue value)
    {
        Object values = value.getValue();
        
        if (!values.getClass().isArray())
        {
            // Create an array to put the single given value 
            Object valueToRemove = values;
            values = Array.newInstance(valueToRemove.getClass(), 1);
            Array.set(values, 0, valueToRemove);
        }
        
        return values;
    }
    
    private Object _removeArrayValues(Object originalValues, Object valuesToRemove, ElementType type) throws IOException
    {
        List<Object> valuesAsList = new ArrayList<>();

        for (int i = 0; i < Array.getLength(originalValues); i++)
        {
            // for each original value
            Object originalValue = Array.get(originalValues, i);

            boolean keepOldValue = true;
            for (int j = 0; j < Array.getLength(valuesToRemove); j++)
            {
                Object valueToRemove = Array.get(valuesToRemove, j);
                if (type.compareValues(valueToRemove, originalValue).count() == 0)
                {
                    // If the original value is corresponding to a value to remove, do not keep it in the final values
                    keepOldValue = false;
                    break;
                }
            }
            
            if (keepOldValue)
            {
                valuesAsList.add(originalValue);
            }
        }
        
        Object[] values = (Object[]) Array.newInstance(type.getManagedClass(), valuesAsList.size());
        return valuesAsList.toArray(values);
    }
    
    private Object _appendArrayValues(Object originalValues, Object valuesToAppend, ElementType type)
    {
        // Create a array with the original values with the final size
        Object[] values = Arrays.copyOf((Object[]) originalValues, Array.getLength(originalValues) + Array.getLength(valuesToAppend));
        
        // Append each value from the given array
        for (int i = 0; i < Array.getLength(valuesToAppend); i++)
        {
            Object valueToAppend = type.castValue(Array.get(valuesToAppend, i));
            values[i + Array.getLength(originalValues)] = valueToAppend;
        }
        
        return values;
    }
    
    /**
     * Removes the stored value of the data with the given name
     * @param <T> the type of the {@link SynchronizationResult}
     * @param dataName name of the data
     * @param context context of the data to remove
     * @return the {@link SynchronizationResult}
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws UnknownDataException if the value at the given data path does not exist
     * @throws BadItemTypeException if the value of the parent of the given path is not an item container
     * @throws UndefinedItemPathException if the given data path is not defined by the model
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    protected <T extends SynchronizationResult> T _removeValueForSynchronize(String dataName, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, UnknownDataException, BadDataPathCardinalityException
    {
        T result = _createSetValueResultInstance();
        
        if (DataHolderHelper.hasValue(this, dataName, context))
        {
            _removeValue(dataName, context);
            result.setHasChanged(true);
        }
        
        return result;
    }
    
    public void setValue(String dataPath, Object value) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _setValue(dataPath, value, ValueContext.newInstance());
    }
    
    public void setLocalValue(String dataPath, Object localValue) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _setValue(dataPath, localValue, ValueContext.newInstance().withStatus(ExternalizableDataStatus.LOCAL));
    }
    
    public void setExternalValue(String dataPath, Object externalValue) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _setValue(dataPath, externalValue, ValueContext.newInstance().withStatus(ExternalizableDataStatus.EXTERNAL));
    }
    
    /**
     * Sets the value of the data at the given path
     * @param dataPath path of the data
     * @param value the value to set. Give <code>null</code> to empty the value.
     * @param context context of the data to set
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws UndefinedItemPathException if the given data path is not defined by the model
     * @throws BadItemTypeException if the type defined by the model doesn't match the given value to set 
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    protected void _setValue(String dataPath, Object value, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        // Check that there is an item at the given path
        if (!ModelHelper.hasModelItem(dataPath, _itemContainers))
        {
            throw new UndefinedItemPathException("Unable to set the value '" + value + "' at path '" + dataPath + "'. There is no such item defined by the model.");
        }
        
        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to set the value '" + value + "' at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            ModelItem modelItem = getDefinition(dataPath);
            
            // Simple path => set the value
            if (modelItem instanceof ElementDefinition)
            {
                String dataName = dataPath;
                if (context.getStatus().isPresent() && getStatus(dataName) != context.getStatus().get())
                {
                    dataName += ALTERNATIVE_SUFFIX;
                }
                
                _setElementValue((ElementDefinition) modelItem, dataName, value);
            }
            else
            {
                throw new BadItemTypeException("Unable to set the value '" + value + "' on the data at path '" + dataPath + "' in the repository because it is a group item.");
            }
        }
        else
        {
            String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to set the value '" + value + "' on the data at path '" + dataPath + "'. The segment '" + pathSegments[pathSegments.length - 2] + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            Object parentValue = getValue(parentPath);
            String childName = pathSegments[pathSegments.length - 1];
            if (parentValue != null && parentValue instanceof ModifiableModelAwareDataHolder)
            {
                ModifiableModelAwareDataHolder parent = (ModifiableModelAwareDataHolder) parentValue;
                if (context.getStatus().isPresent())
                {
                    if (ExternalizableDataStatus.EXTERNAL.equals(context.getStatus().get()))
                    {
                        parent.setExternalValue(childName, value);
                    }
                    else
                    {
                        parent.setLocalValue(childName, value);
                    }
                }
                else
                {
                    parent.setValue(childName, value);
                }
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + parentPath + "' in the repository doesn't exist or is not a composite or a repeater entry. It can not contain the data named '" + childName + "'.");
            }
        }
    }

    private void _setElementValue(ElementDefinition defintion, String dataName, Object value)
    {
        RepositoryElementType type = (RepositoryElementType) defintion.getType();
        
        if (defintion.isMultiple())
        {
            if (value == null)
            {
                type.write(_modifiableRepositoryData, dataName, Array.newInstance(type.getManagedClass(), 0));
            }
            else if (!value.getClass().isArray())
            {
                // The value is single but should be an array. Create the array with the single value
                Object arrayValue = Array.newInstance(value.getClass(), 1);
                Array.set(arrayValue, 0, value);
                type.write(_modifiableRepositoryData, dataName, arrayValue);
            }
            else
            {
                type.write(_modifiableRepositoryData, dataName, value);
            }
        }
        else
        {
            if (type.getManagedClassArray().isInstance(value))
            {
                // The value is multiple but should be single.
                if (Array.getLength(value) > 1)
                {
                    throw new IllegalArgumentException("Unable to set the mutilple value '" + value + "' at path '" + dataName + "'. This item is not multiple.");
                }
                else
                {
                    Object singleValue = Array.getLength(value) == 1 ? Array.get(value, 0) : null;
                    type.write(_modifiableRepositoryData, dataName, singleValue);
                }
            }
            else
            {
                type.write(_modifiableRepositoryData, dataName, value);
            }
        }
    }
    
    public void setStatus(String dataPath, ExternalizableDataStatus status) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        // Check that there is an item at the given path
        if (!ModelHelper.hasModelItem(dataPath, _itemContainers))
        {
            throw new UndefinedItemPathException("Unable to set the status at path '" + dataPath + "'. There is no such item defined by the model.");
        }
        
        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);

        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to set the status at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            ExternalizableDataStatus oldStatus = getStatus(dataPath);
            boolean hasStatus = _repositoryData.hasValue(dataPath + STATUS_SUFFIX);
            
            if (!hasStatus || oldStatus != status)
            {
                // Set the status if it has not been set yet or if it is different from the new one
                _modifiableRepositoryData.setValue(dataPath + STATUS_SUFFIX, status.name().toLowerCase());
            }
            
            if (oldStatus != status)
            {
                // Switch value and alternative value if the old status is different from the new one
                ModelItem modelItem = getDefinition(dataPath);
                if (modelItem instanceof CompositeDefinition)
                {
                    _setStatus(dataPath, (CompositeDefinition) modelItem);
                }
                else if (modelItem instanceof RepeaterDefinition)
                {
                    _setStatus(dataPath, (RepeaterDefinition) modelItem);
                }
                else
                {
                    _setStatus(dataPath, (ElementDefinition) modelItem);
                }
            }
        }
        else
        {
            String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);

            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to set the status on the data at path '" + dataPath + "'. The segment '" + pathSegments[pathSegments.length - 2] + "' refers to a multiple data and can not be used inside the data path.");
            }

            Object parentValue = getValue(parentPath);
            String childName = pathSegments[pathSegments.length - 1];
            if (parentValue != null && parentValue instanceof ModifiableModelAwareDataHolder)
            {
                ModifiableModelAwareDataHolder parent = (ModifiableModelAwareDataHolder) parentValue;
                parent.setStatus(childName, status);
            }
            else
            {
                throw new BadItemTypeException("The data at path '" + parentPath + "' in the repository doesn't exist or is not a composite or a repeater entry. It can not contain the data named '" + childName + "'.");
            }
        }
    }

    private void _setStatus(String dataPath, CompositeDefinition compositeDefinition)
    {
        if (_repositoryData.hasValue(dataPath))
        {
            ModifiableModelAwareComposite composite = _getComposite(dataPath, compositeDefinition);
            ModifiableModelAwareComposite tempComposite = _getComposite(dataPath + __TEMP_SUFFIX, compositeDefinition, true);
            composite.copyTo(tempComposite);
            _modifiableRepositoryData.removeValue(dataPath);
        }

        if (_repositoryData.hasValue(dataPath + ALTERNATIVE_SUFFIX))
        {
            ModifiableModelAwareComposite altComposite = _getComposite(dataPath + ALTERNATIVE_SUFFIX, compositeDefinition);
            ModifiableModelAwareComposite composite = _getComposite(dataPath, compositeDefinition, true);
            altComposite.copyTo(composite);
            _modifiableRepositoryData.removeValue(dataPath + ALTERNATIVE_SUFFIX);
        }

        if (_repositoryData.hasValue(dataPath + __TEMP_SUFFIX))
        {
            ModifiableModelAwareComposite tempComposite = _getComposite(dataPath + __TEMP_SUFFIX, compositeDefinition);
            ModifiableModelAwareComposite altComposite = _getComposite(dataPath + ALTERNATIVE_SUFFIX, compositeDefinition, true);
            tempComposite.copyTo(altComposite);
            _modifiableRepositoryData.removeValue(dataPath + __TEMP_SUFFIX);
        }
    }

    private void _setStatus(String dataPath, RepeaterDefinition repeaterDefinition)
    {
        if (_repositoryData.hasValue(dataPath))
        {
            ModifiableModelAwareRepeater repeater = _getRepeater(dataPath, repeaterDefinition);
            ModifiableModelAwareRepeater tempRepeater = _getRepeater(dataPath + __TEMP_SUFFIX, repeaterDefinition, true);
            repeater.copyTo(tempRepeater);
            _modifiableRepositoryData.removeValue(dataPath);
        }

        if (_repositoryData.hasValue(dataPath + ALTERNATIVE_SUFFIX))
        {
            ModifiableModelAwareRepeater altRepeater = _getRepeater(dataPath + ALTERNATIVE_SUFFIX, repeaterDefinition);
            ModifiableModelAwareRepeater repeater = _getRepeater(dataPath, repeaterDefinition, true);
            altRepeater.copyTo(repeater);
            _modifiableRepositoryData.removeValue(dataPath + ALTERNATIVE_SUFFIX);
        }

        if (_repositoryData.hasValue(dataPath + __TEMP_SUFFIX))
        {
            ModifiableModelAwareRepeater tempRepeater = _getRepeater(dataPath + __TEMP_SUFFIX, repeaterDefinition);
            ModifiableModelAwareRepeater altRepeater = _getRepeater(dataPath + ALTERNATIVE_SUFFIX, repeaterDefinition, true);
            tempRepeater.copyTo(altRepeater);
            _modifiableRepositoryData.removeValue(dataPath + __TEMP_SUFFIX);
        }
    }

    private void _setStatus(String dataName, ElementDefinition elementDefinition)
    {
        RepositoryElementType type = (RepositoryElementType) elementDefinition.getType();
        if (type.hasValue(_repositoryData, dataName))
        {
            Object value = type.read(_repositoryData, dataName);
            type.write(_modifiableRepositoryData, dataName + __TEMP_SUFFIX, value);
            type.remove(_modifiableRepositoryData, dataName);
        }
        
        if (type.hasValue(_repositoryData, dataName + ALTERNATIVE_SUFFIX))
        {
            Object altValue = type.read(_repositoryData, dataName + ALTERNATIVE_SUFFIX);
            type.write(_modifiableRepositoryData, dataName, altValue);
            type.remove(_modifiableRepositoryData, dataName + ALTERNATIVE_SUFFIX);
        }

        if (type.hasValue(_repositoryData, dataName + __TEMP_SUFFIX))
        {
            Object tempValue = type.read(_repositoryData, dataName + __TEMP_SUFFIX);
            type.write(_modifiableRepositoryData, dataName + ALTERNATIVE_SUFFIX, tempValue);
            type.remove(_modifiableRepositoryData, dataName + __TEMP_SUFFIX);
        }
    }
    
    public void setComments(String dataName, List<DataComment> comments) throws IllegalArgumentException, UndefinedItemPathException
    {
        // Check that there is an item with the given name
        if (!hasDefinition(dataName))
        {
            throw new UndefinedItemPathException("Unable to retrieve the comments of the data named '" + dataName + "'. There is no such item defined by the model.");
        }
        
        // Remove old comments if needed
        if (hasComments(dataName))
        {
            _modifiableRepositoryData.removeValue(dataName + COMMENTS_SUFFIX, RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
        }
        
        if (!comments.isEmpty())
        {
            ModifiableRepositoryData commentsRepositoryData = _modifiableRepositoryData.addRepositoryData(dataName + COMMENTS_SUFFIX, RepositoryConstants.COMPOSITE_METADTA_NODETYPE, RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
            
            int commentId = 1;
            for (DataComment comment : comments)
            {
                ModifiableRepositoryData commentRepositoryData = commentsRepositoryData.addRepositoryData(String.valueOf(commentId), RepositoryConstants.COMPOSITE_METADTA_NODETYPE, RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
                commentId++;
                
                commentRepositoryData.setValue("comment", comment.getComment());
                commentRepositoryData.setValue("author", comment.getAuthor());
                commentRepositoryData.setValue("date", DateUtils.asCalendar(comment.getDate()));
            }
        }
    }
    
    public void removeValue(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, BadDataPathCardinalityException
    {
        _removeValue(dataPath, ValueContext.newInstance());
    }
    
    public void removeLocalValue(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, UnknownDataException, BadDataPathCardinalityException
    {
        _removeValue(dataPath, ValueContext.newInstance().withStatus(ExternalizableDataStatus.LOCAL));
    }
    
    public void removeExternalValue(String dataPath) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, UnknownDataException, BadDataPathCardinalityException
    {
        _removeValue(dataPath, ValueContext.newInstance().withStatus(ExternalizableDataStatus.EXTERNAL));
    }
    
    /**
     * Removes the stored value of the data at the given path
     * @param dataPath path of the data
     * @param context context of the data to remove
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws UnknownDataException if the value at the given data path does not exist
     * @throws BadItemTypeException if the value of the parent of the given path is not an item container
     * @throws UndefinedItemPathException if the given data path is not defined by the model
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    protected void _removeValue(String dataPath, ValueContext context) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException, UnknownDataException, BadDataPathCardinalityException
    {
        // Check that there is an item at the given path
        if (!ModelHelper.hasModelItem(dataPath, _itemContainers))
        {
            throw new UndefinedItemPathException("Unable to retrieve the value at path '" + dataPath + "'. There is no such item defined by the model.");
        }

        String[] pathSegments = StringUtils.split(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to remove the value at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            _doRemoveValue(dataPath, context);
        }
        else
        {
            String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
            
            // Multiple items are allowed only at the last segment of the data path
            if (isMultiple(parentPath))
            {
                throw new BadDataPathCardinalityException("Unable to remove the value at path '" + dataPath + "'. The segment '" + pathSegments[pathSegments.length - 2] + "' refers to a multiple data and can not be used inside the data path.");
            }
            
            Object parentValue = getValue(parentPath);
            String childName = pathSegments[pathSegments.length - 1];
            if (parentValue != null && parentValue instanceof ModifiableModelAwareDataHolder)
            {
                ModifiableModelAwareDataHolder parent = (ModifiableModelAwareDataHolder) parentValue;
                if (context.getStatus().isPresent())
                {
                    if (ExternalizableDataStatus.EXTERNAL.equals(context.getStatus().get()))
                    {
                        parent.removeExternalValue(childName);
                    }
                    else
                    {
                        parent.removeLocalValue(childName);
                    }
                }
                else
                {
                    parent.removeValue(childName);
                }
            }
            else
            {
                throw new UnknownDataException("The data at path '" + parentPath + "' in the repository doesn't exist or is not a composite or a repeater entry. It can not contain the data named '" + childName + "'.");
            }
        }
    }

    private void _doRemoveValue(String dataName, ValueContext context)
    {
        ModelItem modelItem = getDefinition(dataName);
        
        String finalDataName = dataName;
        if (context.getStatus().isPresent() && getStatus(dataName) != context.getStatus().get())
        {
            finalDataName += ALTERNATIVE_SUFFIX;
        }
        
        boolean removed = false;
        if (modelItem instanceof RepeaterDefinition)
        {
            if (DataHolderHelper.isRepeaterEntryPath(finalDataName))
            {
                Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(finalDataName);
                String repeaterName = repeaterNameAndEntryPosition.getLeft();
                int entryPosition = repeaterNameAndEntryPosition.getRight();
                ModifiableModelAwareRepeater repeater = _getRepeater(repeaterName, (RepeaterDefinition) modelItem);
                repeater.removeEntry(entryPosition);
                removed = true;
            }
        }
        
        if (!removed)
        {
            getType(dataName).remove(_modifiableRepositoryData, finalDataName);
        }
    }
    
    private void _removeExternalizableMetadataIfExists(ModifiableRepositoryData repositoryData, String dataName)
    {
        if (getType(dataName).hasValue(repositoryData, dataName + ALTERNATIVE_SUFFIX))
        {
            getType(dataName).remove(repositoryData, dataName + ALTERNATIVE_SUFFIX);
        }
        
        if (repositoryData.hasValue(dataName + STATUS_SUFFIX))
        {
            repositoryData.removeValue(dataName + STATUS_SUFFIX);
        }
    }
    
    /**
     * 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();
    }
    
    /**
     * Creates an instance of {@link SynchronizationResult}
     * @param <T> the type of the {@link SynchronizationResult}
     * @return the created instance of {@link SynchronizationResult}
     */
    @SuppressWarnings("unchecked")
    protected <T extends SynchronizationResult> T _createSetValueResultInstance()
    {
        return (T) new SynchronizationResult();
    }
    
    @Override
    public ModifiableRepositoryData getRepositoryData()
    {
        return _modifiableRepositoryData;
    }
    
    @Override
    public Optional<? extends ModifiableModelAwareDataHolder> getParentDataHolder()
    {
        return _modifiableParent;
    }
    
    @Override
    public ModifiableModelAwareDataHolder getRootDataHolder()
    {
        return _modifiableRoot;
    }
}