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

import java.util.Collection;
import java.util.Map;
import java.util.Optional;

import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.plugins.repository.data.UnknownDataException;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.holder.group.ModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.Repeater;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.data.holder.values.SynchronizationContext;
import org.ametys.plugins.repository.data.type.ModelItemTypeExtensionPoint;
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.ViewHelper;
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.NotUniqueTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.exception.UnknownTypeException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemType;

/**
 * Interface for data containers with models
 */
public interface ModelAwareDataHolder extends DataHolder
{
    /** Suffix used for the alternative value */
    public static final String ALTERNATIVE_SUFFIX = "__alt";
    /** Suffix used for the status value */
    public static final String STATUS_SUFFIX = "__status";
    
    @Override
    public ModelAwareComposite getComposite(String compositePath) throws IllegalArgumentException, UnknownTypeException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the local composite at the given path
     * @param compositePath path of the externalizable composite to retrieve
     * @return the composite or <code>null</code> if not exists or is empty
     * @throws IllegalArgumentException if the given composite path is null or empty
     * @throws BadItemTypeException if the stored value at the given path is not a composite
     * @throws UndefinedItemPathException if the given composite 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
     */
    public ModelAwareComposite getLocalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the external composite at the given path
     * @param compositePath path of the externalizable composite to retrieve
     * @return the composite or <code>null</code> if not exists or is empty
     * @throws IllegalArgumentException if the given composite path is null or empty
     * @throws BadItemTypeException if the stored value at the given path is not a composite
     * @throws UndefinedItemPathException if the given composite 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
     */
    public ModelAwareComposite getExternalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the repeater at the given path
     * @param repeaterPath path of the repeater to retrieve
     * @return the repeater or <code>null</code> if not exists or is empty
     * @throws IllegalArgumentException if the given repeater path is null or empty
     * @throws BadItemTypeException if the stored value at the given path is not a repeater
     * @throws UndefinedItemPathException if the given repeater 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
     */
    public Repeater getRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the local repeater at the given path
     * @param repeaterPath path of the externalizable repeater to retrieve
     * @return the repeater or <code>null</code> if not exists or is empty
     * @throws IllegalArgumentException if the given repeater path is null or empty
     * @throws BadItemTypeException if the stored value at the given path is not a repeater
     * @throws UndefinedItemPathException if the given repeater 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
     */
    public Repeater getLocalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the external repeater at the given path
     * @param repeaterPath path of the externalizable repeater to retrieve
     * @return the repeater or <code>null</code> if not exists or is empty
     * @throws IllegalArgumentException if the given repeater path is null or empty
     * @throws BadItemTypeException if the stored value at the given path is not a repeater
     * @throws UndefinedItemPathException if the given repeater 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
     */
    public Repeater getExternalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Checks if there is a non empty local value for the data at the given path
     * @param dataPath path of the externalizable data
     * @return <code>true</code> if the data at the given path is defined by the model, if there is a non empty local value for the data and if the type of this value matches the type of the definition. <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    public boolean hasLocalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException;
    
    /**
     * Checks if there is a non empty external value for the data at the given path
     * @param dataPath path of the externalizable data
     * @return <code>true</code> if the data at the given path is defined by the model, if there is a non empty external value for the data and if the type of this value matches the type of the definition. <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    public boolean hasExternalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException;
    
    @Override
    public default boolean hasValue(String dataPath, String dataTypeId) throws IllegalArgumentException, UnknownTypeException, BadDataPathCardinalityException
    {
        return hasValue(dataPath);
    }
    
    /**
     * Checks if there is a local value for the data at the given path
     * @param dataPath path of the externalizable data
     * @return <code>true</code> if the data at the given path is defined by the model, if there is a local value for the data, even empty, and if the type of this value matches the type of the definition. <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    public boolean hasLocalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException;
    
    /**
     * Checks if there is an external value for the data at the given path
     * @param dataPath path of the externalizable data
     * @return <code>true</code> if the data at the given path is defined by the model, if there is an external value for the data, even empty, and if the type of this value matches the type of the definition. <code>false</code> otherwise
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadDataPathCardinalityException if the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    public boolean hasExternalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException;
    
    /**
     * {@inheritDoc}
     * @return the names of the data contained by this data holder and that are defined by the model
     */
    @Override
    public Collection<String> getDataNames();
    
    /**
     * Retrieves the local value of the data at the given path
     * @param <T> type of the value to retrieve. The type of the value is defined by the model.
     * @param dataPath path of the externalizable data
     * @return the local value of the data or <code>null</code> if not exists or is empty. A typed array is returned for multiple empty data, and an empty string is returned for single empty string data
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadItemTypeException if the type defined by the model doesn't match the type of the stored value
     * @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
     */
    public <T> T getLocalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the external value of the data at the given path
     * @param <T> type of the value to retrieve. The type of the value is defined by the model.
     * @param dataPath path of the externalizable data
     * @return the external value of the data or <code>null</code> if not exists or is empty. A typed array is returned for multiple empty data, and an empty string is returned for single empty string data
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadItemTypeException if the type defined by the model doesn't match the type of the stored value
     * @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
     */
    public <T> T getExternalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the value of the data at the given path if exists and is not empty, or the default value from the model
     * @param <T> type of the value to retrieve. The type of the value is defined by the model.
     * @param dataPath path of the data
     * @return the value of the data, or the default value from the model if the value does not exist or is empty
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadItemTypeException if the type defined by the model doesn't match the type of the stored value
     * @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
     */
    public <T> T getValueOrDefault(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * {@inheritDoc}
     * @param <T> type of the value to retrieve. The type of the value is defined by the model.
     */
    @Override
    public default <T> T getValueOfType(String dataPath, String dataTypeId) throws IllegalArgumentException, UnknownTypeException, NotUniqueTypeException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getValue(dataPath);
    }
    
    /**
     * {@inheritDoc}
     * @param <T> type of the value to retrieve. The type of the value is defined by the model.
     */
    @Override
    public default <T> T getValueOfTypeOrDefault(String dataPath, String dataTypeId, T defaultValue) throws IllegalArgumentException, UnknownTypeException, NotUniqueTypeException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getValueOrDefault(dataPath, defaultValue);
    }
    
    /**
     * Retrieves the value of the data at the given path, allowing multi-valued segments in the path (not necessarily at the last segment)
     * if there is no indicated entry for a repeater, the values of all the entries are retrieved
     * if there are multiple values, all data are retrieved in one array
     * @param <T> type of the value to retrieve
     * @param dataPath path of the data
     * @return the value of the data
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadItemTypeException if the type defined by the model doesn't match the type of the stored value
     * @throws UndefinedItemPathException if the given data path is not defined by the model
     * @throws BadDataPathCardinalityException if the managesMultiples boolean is <code>false</code> and the definition of a part of the data path is multiple. Only the last part can be multiple
     */
    public <T> T getValueWithMultiValuedPathSegments(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Retrieves the status of the externalizable data at the given path
     * Warning: This method won't check that your data is externalizable. But there is no sense to call it with a non externalizable data
     * @param dataPath path of the externalizable data
     * @return the status of the externalizable data at the given path
     * @throws IllegalArgumentException if the given data path is null or empty
     * @throws BadItemTypeException if the given data path is composed of an item  with type defined by the model that doesn't match the type of the stored value
     * @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
     */
    public ExternalizableDataStatus getStatus(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException;
    
    /**
     * Checks if the definition of the element at the given path is multiple<br/>
     * {@inheritDoc}
     * @param dataPath path of the element. No matter if it is a definition or data path (with repeater entry positions)
     * @return <code>true</code> if the element is multiple, <code>false</code> otherwise
     */
    @Override
    public default boolean isMultiple(String dataPath) throws IllegalArgumentException, UnknownDataException, UnknownTypeException, NotUniqueTypeException, BadItemTypeException, UndefinedItemPathException
    {
        ModelItem item = getDefinition(dataPath);
        if (item instanceof ElementDefinition)
        {
            return ((ElementDefinition) item).isMultiple();
        }
        else if (item instanceof RepeaterDefinition)
        {
            // If the given path represents a repeater , but with no specified entry, consider the data as multiple
            return !DataHolderHelper.isRepeaterEntryPath(dataPath);
        }
        else
        {
            // Composites are not multiples
            return false;
        }
    }
    
    /**
     * Checks if the definition of the element at the given path is multiple<br/>
     * {@inheritDoc}
     * @param dataPath path of the element. No matter if it is a definition or data path (with repeater entry positions)
     * @return <code>true</code> if the element is multiple, <code>false</code> otherwise
     */
    @Override
    public default boolean isMultiple(String dataPath, String dataTypeId) throws IllegalArgumentException, UnknownDataException, UnknownTypeException, BadItemTypeException, UndefinedItemPathException
    {
        return isMultiple(dataPath);
    }
    
    /**
     * {@inheritDoc}
     * @param dataPath path of the data. No matter if it is a definition or data path (with repeater entry positions)
     */
    @SuppressWarnings("unchecked")
    @Override
    public default <X extends ModelItemType> X getType(String dataPath) throws IllegalArgumentException, UnknownDataException, UnknownTypeException, NotUniqueTypeException, UndefinedItemPathException
    {
        return (X) getDefinition(dataPath).getType();
    }

    @Override
    public default ModelItemTypeExtensionPoint getModelItemTypeExtensionPoint()
    {
        throw new UnsupportedOperationException("ModelAwareDataHolder does not need an extension point for managed types. The model itself defines the types of the data.");
    }
    
    /**
     * Retrieves the data holder's model
     * @return the data holder's model
     */
    public Collection<? extends ModelItemContainer> getModel();
    
    /**
     * Retrieves the definition of the data at the given path
     * @param path path of the data. No matter if it is a definition or data path (with repeater entry positions)
     * @return the definition of the data
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if the given path is not defined by the model
     */
    public default ModelItem getDefinition(String path) throws IllegalArgumentException, UndefinedItemPathException
    {
        return ModelHelper.getModelItem(path, getModel());
    }
    
    /**
     * Checks if there is a definition at the given path
     * @param path path of the data. No matter if it is a definition or data path (with repeater entry positions)
     * @return <code>true</code> if there is definition at the given path, <code>false</code> otherwise
     * @throws IllegalArgumentException if the given path is null or empty
     */
    public default boolean hasDefinition(String path) throws IllegalArgumentException
    {
        try
        {
            getDefinition(path);
            return true;
        }
        catch (UndefinedItemPathException e)
        {
            return false;
        }
    }
    
    /**
     * {@inheritDoc}
     * <br />Generates SAX events only for the data in the model
     */
    @Override
    public default void dataToSAX(ContentHandler contentHandler) throws SAXException, UnknownTypeException, NotUniqueTypeException, BadItemTypeException
    {
        DataHolder.super.dataToSAX(contentHandler);
    }
    
    /**
     * {@inheritDoc}
     * <br />Generates SAX events only for the data in the model
     */
    @Override
    public default void dataToSAX(ContentHandler contentHandler, DataContext context) throws SAXException, UnknownTypeException, NotUniqueTypeException, BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = ViewHelper.createViewItemAccessor(getModel());
        dataToSAX(contentHandler, viewItemAccessor, context);
    }
    
    /**
     * Generates SAX events for the data in the given view in the current {@link DataHolder}
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items for which generate SAX events
     * @throws SAXException if an error occurs during the SAX events generation
     * @throws BadItemTypeException if the saxed value's type does not matches the stored data
     */
    public default void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor) throws SAXException, BadItemTypeException
    {
        dataToSAX(contentHandler, viewItemAccessor, DataContext.newInstance());
    }
    
    /**
     * Generates SAX events for the data in the given view in the current {@link DataHolder}
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items for which generate SAX events
     * @param context The context of the data to SAX
     * @throws SAXException if an error occurs during the SAX events generation
     * @throws BadItemTypeException if the saxed value's type does not matches the stored data
     */
    public void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException;
    
    /**
     * Generates SAX events for the data in the given view in edition mode in the current {@link DataHolder}
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items for which generate SAX events
     * @param context The context of the data to SAX
     * @throws SAXException if an error occurs during the SAX events generation
     * @throws BadItemTypeException if the saxed value's type does not matches the stored data
     */
    public void dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException;
    
    /**
     * Convert the data in the model of the current {@link DataHolder}
     * @return The data of the current {@link DataHolder} as JSON
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    
    /**
     * {@inheritDoc}
     * <br />Only converts the data in the model
     */
    public default Map<String, Object> dataToJSON() throws BadItemTypeException
    {
        return DataHolder.super.dataToJSON();
    }
    
    /**
     * {@inheritDoc}
     * <br />Only converts the data in the model
     */
    public default Map<String, Object> dataToJSON(DataContext context) throws BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = ViewHelper.createViewItemAccessor(getModel());
        return dataToJSON(viewItemAccessor, context);
    }
    
    /**
     * Convert the data in the given view of the current {@link DataHolder}
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items to convert
     * @return The data of the given view as JSON
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public default Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor) throws BadItemTypeException
    {
        return dataToJSON(viewItemAccessor, DataContext.newInstance());
    }
    
    /**
     * Convert the data in the given view of the current {@link DataHolder}
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items to convert
     * @param context The context of the data to convert
     * @return The data of the given view as JSON
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException;
    
    /**
     * Convert the data in the given view in edition mode in the current {@link DataHolder}
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items to convert
     * @param context The context of the data to convert
     * @return The data of the given view as JSON
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public Map<String, Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException;
    
    /**
     * Retrieves all data of this DataHolder as a typed-values Map.
     * @return a Map containing all data.
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public default Map<String, Object> dataToMap() throws BadItemTypeException
    {
        return dataToMap(DataContext.newInstance());
    }
    
    /**
     * Retrieves all data of this DataHolder as a typed-values Map.
     * @param context The context of the data
     * @return  a Map containing all data.
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public default Map<String, Object> dataToMap(DataContext context) throws BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = ViewHelper.createViewItemAccessor(getModel());
        return dataToMap(viewItemAccessor, context);
    }
    
    /**
     * Retrieves data of this DataHolder as a typed-values Map.
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items to include in the resulting Map
     * @return a Map containing all data.
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public default Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor) throws BadItemTypeException
    {
        return dataToMap(viewItemAccessor, DataContext.newInstance());
    }
    
    /**
     * Retrieves data of this DataHolder as a typed-values Map.
     * @param viewItemAccessor the {@link ViewItemAccessor} referencing the items to include in the resulting Map
     * @param context The context of the data
     * @return a Map containing all data.
     * @throws BadItemTypeException if the value's type does not matches the stored data
     */
    public Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException;
    
    /**
     * {@inheritDoc}
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    @Override
    public default boolean hasDifferences(Map<String, Object> values) throws UnknownTypeException, NotUniqueTypeException, BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = DataHolderHelper.createViewItemAccessorFromValues(getModel(), values);
        return hasDifferences(viewItemAccessor, values);
    }
    
    /**
     * Check if there are differences between the given values and the current ones
     * @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 BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public default boolean hasDifferences(Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = DataHolderHelper.createViewItemAccessorFromValues(getModel(), values);
        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
     * @return <code>true</code> if there are differences, <code>false</code> otherwise
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException;
    
    /**
     * 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 BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException;

    /**
     * Get the collection of model items where there are differences between the given values and the current ones
     * @param values the values to check
     * @return a collection of model items with differences
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public default Collection<ModelItem> getDifferences(Map<String, Object> values) throws BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = DataHolderHelper.createViewItemAccessorFromValues(getModel(), values);
        return getDifferences(viewItemAccessor, values);
    }
    
    /**
     * Get the collection of model items where there are differences between the given values and the current ones
     * @param values the values to check
     * @param context the context of the synchronization
     * @return a collection of model items with differences
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public default Collection<ModelItem> getDifferences(Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        ViewItemAccessor viewItemAccessor = DataHolderHelper.createViewItemAccessorFromValues(getModel(), values);
        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
     * @return a collection of model items with differences
     * @throws BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException;

    /**
     * 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 BadItemTypeException if the type defined by the model of one of the Map's key doesn't match the corresponding value
     */
    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException;
    
    @Override
    public Optional<? extends ModelAwareDataHolder> getParentDataHolder();
    
    @Override
    public ModelAwareDataHolder getRootDataHolder();
}