/*
 *  Copyright 2022 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.data.holder.impl;

import java.lang.reflect.Array;
import java.time.ZonedDateTime;
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.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.ametysobject.ModelAwareDataAwareAmetysObject;
import org.ametys.cms.data.holder.IndexableDataHolder;
import org.ametys.cms.data.holder.group.IndexableComposite;
import org.ametys.cms.data.holder.group.IndexableRepeater;
import org.ametys.cms.data.holder.group.impl.DefaultModelAwareComposite;
import org.ametys.cms.data.holder.group.impl.DefaultModelAwareRepeater;
import org.ametys.cms.model.ContentElementDefinition;
import org.ametys.cms.model.properties.Property;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.data.DataComment;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.holder.DataHolder;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.ModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeaterEntry;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;
import org.ametys.plugins.repository.data.type.RepositoryElementType;
import org.ametys.plugins.repository.data.type.RepositoryModelItemGroupType;
import org.ametys.plugins.repository.data.type.RepositoryModelItemType;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.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.ViewItemAccessor;
import org.ametys.runtime.model.exception.BadDataPathCardinalityException;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemType;

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

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

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

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

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

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

        return defaultValue;
    }
    
    /**
     * Retrieves the composite with the given name
     * @param name name of the composite to retrieve
     * @param compositeDefinition the definition of the composite to retrieve
     * @return the composite
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a composite
     */
    protected ModelAwareComposite _getComposite(String name, CompositeDefinition compositeDefinition) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) compositeDefinition.getType();
        RepositoryData compositeRepositoryData = type.read(_repositoryData, name);
        
        if (compositeRepositoryData != null)
        {
            return new DefaultModelAwareComposite(compositeRepositoryData, this, _root, compositeDefinition);
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Retrieves the repeater with the given name
     * @param name name of the repeater to retrieve
     * @param repeaterDefinition the definition of the repeater to retrieve
     * @return the repeater
     * @throws BadItemTypeException if the value stored in the repository with the given name is not a repeater
     */
    protected ModelAwareRepeater _getRepeater(String name, RepeaterDefinition repeaterDefinition) throws BadItemTypeException
    {
        RepositoryModelItemGroupType type = (RepositoryModelItemGroupType) repeaterDefinition.getType();
        RepositoryData repeaterRepositoryData = type.read(_repositoryData, name);
        
        if (repeaterRepositoryData != null)
        {
            return new DefaultModelAwareRepeater(repeaterRepositoryData, this, _root, repeaterDefinition);
        }
        else
        {
            return null;
        }
    }
    
    public List<DataComment> getComments(String dataName) throws IllegalArgumentException, UndefinedItemPathException
    {
        _checkDefinition(dataName, "Unable to retrieve the comments of the data named '" + dataName + "'.");
        
        List<DataComment> comments = new ArrayList<>();
        
        RepositoryData commentsRepositoryData = _repositoryData.getRepositoryData(dataName + COMMENTS_SUFFIX, RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
        
        for (String commentId : commentsRepositoryData.getDataNames(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL))
        {
            RepositoryData commentRepositoryData = commentsRepositoryData.getRepositoryData(commentId, RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
            
            String content = commentRepositoryData.getString("comment");
            String author = commentRepositoryData.getString("author");
            ZonedDateTime date = DateUtils.asZonedDateTime(commentRepositoryData.getDate("date"));
            
            DataComment comment = new DataComment(content, date, author);
            comments.add(comment);
        }
        
        return comments;
    }

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

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

    public Collection<String> getDataNames()
    {
        return ModelHelper.getModelItems(getModel())
                          .stream()
                          .map(ModelItem::getName)
                          .filter(this::hasValueOrEmpty)
                          .toList();
    }
    
    @SuppressWarnings("unchecked")
    public void dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context) throws SAXException
    {
        _checkDefinition(dataPath, "Unable to generate SAX events for the data at path '" + dataPath + "'.");
        
        ModelAwareDataHolder root = getRootDataHolder();
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        if (hasValue(dataPath)
            || newContext.renderEmptyValues() && hasValueOrEmpty(dataPath))
        {
            ModelItem modelItem = getDefinition(dataPath);
            if (modelItem instanceof Property property)
            {
                ModelAwareDataAwareAmetysObject ametysObject = _getPropertysAmetysObject(dataPath);
                property.valueToSAX(contentHandler, ametysObject, newContext);
            }
            else
            {
                ModelItemType type = modelItem.getType();
                Object value = getValue(dataPath);
                
                type.valueToSAX(contentHandler, modelItem.getName(), value, newContext.cloneContext().withDataPath(dataPath));
            }
        }
    }
    
    public void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        IndexableDataHolderHelper.dataToSAX(this, contentHandler, viewItemAccessor, newContext, false);
    }
    
    public void dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        IndexableDataHolderHelper.dataToSAX(this, contentHandler, viewItemAccessor, newContext, true);
    }
    
    @SuppressWarnings("unchecked")
    public Object dataToJSON(String dataPath, DataContext context)
    {
        _checkDefinition(dataPath, "Unable to convert the data at path '" + dataPath + "' to JSON.");
        
        ModelAwareDataHolder root = getRootDataHolder();
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        if (hasValue(dataPath)
            || newContext.renderEmptyValues() && hasValueOrEmpty(dataPath))
        {
            ModelItem modelItem = getDefinition(dataPath);
            if (modelItem instanceof Property property)
            {
                ModelAwareDataAwareAmetysObject ametysObject = _getPropertysAmetysObject(dataPath);
                return property.valueToJSON(ametysObject, newContext);
            }
            else
            {
                ModelItemType type = modelItem.getType();
                Object value = getValue(dataPath);
                
                return type.valueToJSONForClient(value, newContext.cloneContext().withDataPath(dataPath));
            }
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Retrieves the ametys object containing the property at the given path
     * @param dataPath the path of the property
     * @return the ametys object containing the property
     * @throws UndefinedItemPathException if the given path does not represent a property
     */
    protected ModelAwareDataAwareAmetysObject _getPropertysAmetysObject(String dataPath) throws UndefinedItemPathException
    {
        if (StringUtils.contains(dataPath, ModelItem.ITEM_PATH_SEPARATOR))
        {
            String parentDataPath = StringUtils.substringBeforeLast(dataPath, ModelItem.ITEM_PATH_SEPARATOR);
            ContentValue value = getValue(parentDataPath);
            return value.getContent();
        }
        else if (getRootDataHolder() instanceof ModelAwareDataAwareAmetysObject ametysObject)
        {
            return ametysObject;
        }
        else
        {
            throw new UndefinedItemPathException("There is no property at path '" + dataPath + "'");
        }
    }
    
    public Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        return IndexableDataHolderHelper.dataToJSON(this, viewItemAccessor, newContext, false);
    }
    
    public Map<String, Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject ametysObject)
        {
            newContext.withObjectId(ametysObject.getId());
        }
        
        return IndexableDataHolderHelper.dataToJSON(this, viewItemAccessor, newContext, true);
    }
    
    public Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor, DataContext context)
    {
        ModelAwareDataHolder root = getRootDataHolder();
        
        DataContext newContext = context.cloneContext();
        if (root instanceof AmetysObject)
        {
            newContext.withObjectId(((AmetysObject) root).getId());
        }
        
        return IndexableDataHolderHelper.dataToMap(this, viewItemAccessor, newContext);
    }
    
    public RepositoryData getRepositoryData()
    {
        return _repositoryData;
    }
    
    public Optional<? extends IndexableDataHolder> getParentDataHolder()
    {
        return _parent;
    }
    
    public IndexableDataHolder getRootDataHolder()
    {
        return _root;
    }
    
    /**
     * Check definition for data path
     * @param dataPath the data path
     * @param errorMsg the error message to throw
     */
    protected void _checkDefinition(String dataPath, String errorMsg)
    {
        _checkDefinition(dataPath, false, errorMsg);
    }
    
    /**
     * Check definition for data path
     * @param dataPath the data path
     * @param checkStatusAvailable <code>true</code> to check if the definition supports externalizable data status
     * @param errorMsg the error message to throw
     */
    protected void _checkDefinition(String dataPath, boolean checkStatusAvailable, String errorMsg)
    {
        // Check if the model exists
        if (_itemContainers.isEmpty())
        {
            throw new UndefinedItemPathException(errorMsg + " No model is defined for this object [" + getRootDataHolder() + "]");
        }
        
        // Check that there is an item at the given path
        if (!hasDefinition(dataPath))
        {
            throw new UndefinedItemPathException(errorMsg + " There is no such item defined by the model.");
        }
        
        // Externalizable data status is not available for properties
        if (checkStatusAvailable && getDefinition(dataPath) instanceof Property)
        {
            throw new UndefinedItemPathException(errorMsg + " A property can't have an externalizable status.");
        }
    }
}