/*
 *  Copyright 2016 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.content;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.ContextHelper;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.references.OutgoingReferencesHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.ContentValidator;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.holder.DataHolderDisableConditionsEvaluator;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.workflow.AbstractContentWorkflowComponent;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.URIUtils;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
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.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.metadata.MultilingualString;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.DefinitionContext;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewHelper;
import org.ametys.runtime.model.disableconditions.DisableConditionsEvaluator;
import org.ametys.runtime.parameter.ValidationResult;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.opensymphony.workflow.WorkflowException;

/**
 * Helper for {@link Content}
 *
 */
public class ContentHelper extends AbstractLogEnabled implements Component, Serviceable, Contextualizable, Initializable
{
    /** The component role. */
    public static final String ROLE = ContentHelper.class.getName();
   
    /** The base URL for the CMS */
    protected String _baseURL;

    /** The Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    
    /** The context */
    protected Context _context;

    private ContentTypesHelper _contentTypesHelper;
    private ContentTypeExtensionPoint _contentTypeEP;
    private ObservationManager _observationManager;
    private WorkflowProvider _workflowProvider;
    private CurrentUserProvider _currentUserProvider;
    private SystemPropertyExtensionPoint _systemPropertyExtensionPoint;
    private DisableConditionsEvaluator<ModelAwareDataHolder> _disableConditionsEvaluator;
    private I18nUtils _i18nUtils;
    
    @SuppressWarnings("unchecked")
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _contentTypesHelper = (ContentTypesHelper) smanager.lookup(ContentTypesHelper.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) smanager.lookup(ContentTypeExtensionPoint.ROLE);
        _workflowProvider = (WorkflowProvider) smanager.lookup(WorkflowProvider.ROLE);
        _observationManager = (ObservationManager) smanager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _systemPropertyExtensionPoint = (SystemPropertyExtensionPoint) smanager.lookup(SystemPropertyExtensionPoint.ROLE);
        _disableConditionsEvaluator = (DisableConditionsEvaluator<ModelAwareDataHolder>) smanager.lookup(DataHolderDisableConditionsEvaluator.ROLE);
        _i18nUtils = (I18nUtils) smanager.lookup(I18nUtils.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _baseURL = StringUtils.stripEnd(StringUtils.removeEndIgnoreCase(Config.getInstance().getValue("cms.url"), "index.html"), "/");
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Add a content type to an existing content
     * @param contentId The content id
     * @param contentTypeId The content type to add
     * @param actionId The workflow action id
     * @return The result in a Map
     * @throws WorkflowException if
     * @throws AmetysRepositoryException if an error occurred
     */
    @Callable
    public Map<String, Object> addContentType (String contentId, String contentTypeId, int actionId) throws AmetysRepositoryException, WorkflowException
    {
        return _setContentType(contentId, contentTypeId, actionId, false);
    }
    
    /**
     * Remove a content type to an existing content
     * @param contentId The content id
     * @param contentTypeId The content type to add
     * @param actionId The workflow action id
     * @return The result in a Map
     * @throws WorkflowException if
     * @throws AmetysRepositoryException if an error occurred
     */
    @Callable
    public Map<String, Object> removeContentType (String contentId, String contentTypeId, int actionId) throws AmetysRepositoryException, WorkflowException
    {
        return _setContentType(contentId, contentTypeId, actionId, true);
    }
    
    /**
     * Add a mixin type to an existing content
     * @param contentId The content id
     * @param mixinId The mixin type to add
     * @param actionId The workflow action id
     * @return The result in a Map
     * @throws WorkflowException if
     * @throws AmetysRepositoryException if an error occurred
     */
    @Callable
    public Map<String, Object> addMixinType (String contentId, String mixinId, int actionId) throws AmetysRepositoryException, WorkflowException
    {
        return _setMixinType(contentId, mixinId, actionId, false);
    }
    
    /**
     * Remove a mixin type to an existing content
     * @param contentId The content id
     * @param mixinId The mixin type to add
     * @param actionId The workflow action id
     * @return The result in a Map
     * @throws WorkflowException if
     * @throws AmetysRepositoryException if an error occurred
     */
    @Callable
    public Map<String, Object> removeMixinType (String contentId, String mixinId, int actionId) throws AmetysRepositoryException, WorkflowException
    {
        return _setMixinType(contentId, mixinId, actionId, true);
    }
    
    /**
     * Get content edition information.
     * @param contentId the content ID.
     * @return a Map containing content edition information.
     */
    @Callable
    public Map<String, Object> getContentEditionInformation(String contentId)
    {
        Map<String, Object> info = new HashMap<>();
        
        Content content = _resolver.resolveById(contentId);
        
        info.put("hasIndexingReferences", hasIndexingReferences(content));
        
        return info;
    }
    
    /**
     * Test if the given content has indexing references, i.e. if modifying it
     * potentially implies reindexing other contents.
     * @param content the content to test.
     * @return <code>true</code> if one of the content types or mixins has indexing references, <code>false</code> otherwise.
     */
    public boolean hasIndexingReferences(Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            if (_contentTypeEP.hasIndexingReferences(cTypeId))
            {
                return true;
            }
        }
        
        for (String mixinId : content.getMixinTypes())
        {
            if (_contentTypeEP.hasIndexingReferences(mixinId))
            {
                return true;
            }
        }
        
        return false;
    }
    
    private Map<String, Object> _setContentType (String contentId, String contentTypeId, int actionId, boolean remove) throws AmetysRepositoryException, WorkflowException
    {
        Map<String, Object> result = new HashMap<>();
        
        Content content = _resolver.resolveById(contentId);

        if (content instanceof ModifiableContent)
        {
            ModifiableContent modifiableContent = (ModifiableContent) content;
            
            List<String> currentTypes = new ArrayList<>(Arrays.asList(content.getTypes()));
            
            boolean hasChange = false;
            if (remove)
            {
                if (currentTypes.size() > 1)
                {
                    hasChange = currentTypes.remove(contentTypeId);
                }
                else
                {
                    result.put("failure", true);
                    result.put("msg", "empty-list");
                }
            }
            else if (!currentTypes.contains(contentTypeId))
            {
                ContentType cType = _contentTypeEP.getExtension(contentTypeId);
                if (cType.isMixin())
                {
                    result.put("failure", true);
                    result.put("msg", "no-content-type");
                    getLogger().error("Content type '{}' is a mixin type. It can not be added as content type.", contentTypeId);
                }
                else if (!_contentTypesHelper.isCompatibleContentType(content, contentTypeId))
                {
                    result.put("failure", true);
                    result.put("msg", "invalid-content-type");
                    getLogger().error("Content type '{}' is incompatible with content '{}'.", contentTypeId, contentId);
                }
                else
                {
                    currentTypes.add(contentTypeId);
                    hasChange = true;
                }
            }
            
            if (hasChange)
            {
                // TODO check if the content type is compatible
                modifiableContent.setTypes(currentTypes.toArray(new String[currentTypes.size()]));
                modifiableContent.saveChanges();
                
                if (content instanceof WorkflowAwareContent)
                {
                    
                    WorkflowAwareContent waContent = (WorkflowAwareContent) content;
                    AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
                    
                    Map<String, Object> inputs = new HashMap<>();
                    inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
                    inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new LinkedHashMap<>());
                    inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<>());
                    
                    workflow.doAction(waContent.getWorkflowId(), actionId, inputs);
                }
                
                result.put("success", true);
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, modifiableContent);
                eventParams.put(ObservationConstants.ARGS_CONTENT_ID, contentId);
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, _currentUserProvider.getUser(), eventParams));
            }
        }
        else
        {
            result.put("failure", true);
            result.put("msg", "no-modifiable-content");
            getLogger().error("Can not modified content types to a non-modifiable content '{}'.", contentId);
        }
        
        return result;
    }
    
    private Map<String, Object> _setMixinType (String contentId, String mixinId, int actionId, boolean remove) throws AmetysRepositoryException, WorkflowException
    {
        Map<String, Object> result = new HashMap<>();
        
        Content content = _resolver.resolveById(contentId);

        if (content instanceof ModifiableContent)
        {
            ModifiableContent modifiableContent = (ModifiableContent) content;
            
            List<String> currentMixins = new ArrayList<>(Arrays.asList(content.getMixinTypes()));
            
            boolean hasChange = false;
            if (remove)
            {
                hasChange = currentMixins.remove(mixinId);
            }
            else if (!currentMixins.contains(mixinId))
            {
                ContentType cType = _contentTypeEP.getExtension(mixinId);
                if (!cType.isMixin())
                {
                    result.put("failure", true);
                    result.put("msg", "no-mixin");
                    getLogger().error("The content type '{}' is not a mixin type, it can be not be added as a mixin.", mixinId);
                }
                else if (!_contentTypesHelper.isCompatibleContentType(content, mixinId))
                {
                    result.put("failure", true);
                    result.put("msg", "invalid-mixin");
                    getLogger().error("Mixin '{}' is incompatible with content '{}'.", mixinId, contentId);
                }
                else
                {
                    currentMixins.add(mixinId);
                    hasChange = true;
                }
            }
            
            if (hasChange)
            {
                // TODO check if the content type is compatible
                modifiableContent.setMixinTypes(currentMixins.toArray(new String[currentMixins.size()]));
                modifiableContent.saveChanges();
                
                if (content instanceof WorkflowAwareContent)
                {
                    WorkflowAwareContent waContent = (WorkflowAwareContent) content;
                    AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
                    
                    Map<String, Object> inputs = new HashMap<>();
                    inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
                    inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, new LinkedHashMap<>());
                    inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<>());
                    
                    workflow.doAction(waContent.getWorkflowId(), actionId, inputs);
                }
                
                result.put("success", true);
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, modifiableContent);
                eventParams.put(ObservationConstants.ARGS_CONTENT_ID, contentId);
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, _currentUserProvider.getUser(), eventParams));
            }
        }
        else
        {
            result.put("failure", true);
            result.put("msg", "no-modifiable-content");
            getLogger().error("Can not modified mixins to a non-modifiable content '{}'.", contentId);
        }
        
        return result;
    }
    
    /**
     * Converts the content attribute definitions in a JSON Map
     * @param contentId the content identifier
     * @param isEdition <code>true</code> if the JSON result is used for edition purposes (configure a form panel, ...) <code>false</code> otherwise
     * @return the content attribute definitions as a JSON Map
     * @throws ProcessingException if an error occurs when converting the definitions
     */
    @Callable
    public Map<String, Object> getContentAttributeDefinitionsAsJSON(String contentId, boolean isEdition) throws ProcessingException
    {
        return getContentAttributeDefinitionsAsJSON(contentId, List.of(), isEdition);
    }
    
    /**
     * Converts the given content attribute definitions in a JSON Map
     * @param contentId the content identifier
     * @param attibutePaths the paths of the attribute definitions to convert
     * @param isEdition <code>true</code> if the JSON result is used for edition purposes (configure a form panel, ...) <code>false</code> otherwise
     * @return the content attribute definitions as a JSON Map
     * @throws ProcessingException if an error occurs when converting the definitions
     */
    @Callable
    public Map<String, Object> getContentAttributeDefinitionsAsJSON(String contentId, List<String> attibutePaths, boolean isEdition) throws ProcessingException
    {
        Content content = _resolver.resolveById(contentId);
        View view = View.of(getContentTypes(content), attibutePaths.toArray(new String[attibutePaths.size()]));
        DefinitionContext context = DefinitionContext.newInstance().withEdition(isEdition).withObject(content);
        return Map.of("attributes", view.toJSON(context));
    }
    
    /**
     * Converts the content view with the given name in a JSON Map
     * @param contentId the content identifier
     * @param viewName the name of the view to convert
     * @param fallbackViewName the name of the view to convert if the initial was not found. Can be null.
     * @param isEdition <code>true</code> if the JSON result is used for edition purposes (configure a form panel, ...) <code>false</code> otherwise
     * @return the view as a JSON Map
     * @throws ProcessingException if an error occurs when converting the view
     */
    @Callable
    public Map<String, Object> getContentViewAsJSON(String contentId, String viewName, String fallbackViewName, boolean isEdition) throws ProcessingException
    {
        assert StringUtils.isNotEmpty(viewName);
        assert StringUtils.isNotEmpty(fallbackViewName);
        
        Content content = _resolver.resolveById(contentId);
        
        ContextHelper.getRequest(_context).setAttribute(Content.class.getName(), content);
        
        View view = _contentTypesHelper.getViewWithFallback(viewName, fallbackViewName, content.getTypes(), content.getMixinTypes());
        if (isEdition)
        {
            if (ViewHelper.areItemsPresentsOnlyOnce(view))
            {
                view = ViewHelper.getTruncatedView(view);
            }
            else
            {
                throw new ProcessingException("The view '" + view.getName() + "' cannot be used in edition mode, some items appear more than once.");
            }
        }
        
        DefinitionContext context = DefinitionContext.newInstance().withEdition(isEdition).withObject(content);
        return Map.of("view", view.toJSON(context));
    }
    
    /**
     * Retrieves a {@link Collection} containing all content types of the given content
     * @param content the content
     * @return all content types of the content
     */
    public Collection<ContentType> getContentTypes(Content content)
    {
        return getContentTypes(content, true);
    }
    
    /**
     * Retrieves a {@link Collection} containing content types of the given content
     * @param content the content
     * @param includeMixins <code>true</code> to retrieve the mixins the the collection, <code>false</code> otherwise
     * @return content types of the content
     */
    public Collection<ContentType> getContentTypes(Content content, boolean includeMixins)
    {
        Collection<ContentType> contentTypes = _getContentTypesFromIds(content.getTypes());
        
        if (includeMixins)
        {
            contentTypes.addAll(_getContentTypesFromIds(content.getMixinTypes()));
        }
        
        return Collections.unmodifiableCollection(contentTypes);
    }
    
    private Collection<ContentType> _getContentTypesFromIds(String[] contentTypeIds)
    {
        Collection<ContentType> contentTypes = new ArrayList<>();
        
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _contentTypeEP.getExtension(contentTypeId);
            if (contentType != null)
            {
                contentTypes.add(contentType);
            }
            else
            {
                getLogger().warn("Unknown content type identifier: {}", contentTypeId);
            }
        }
        
        return contentTypes;
    }
    
    /**
     * Determines if the given content has some of its types that are unknown (the extension does not exist)
     * @param content the content
     * @return <code>true</code> if at least one of the types of the content is unknown, <code>false</code> otherwise
     */
    public List<String> getUnknownContentTypeIds(Content content)
    {
        return getUnknownContentTypeIds(content, true);
    }

    /**
     * Determines if the given content has some of its types that are unknown (the extension does not exist)
     * @param content the content
     * @param checkMixins <code>true</code> to check unknown content types in mixin types
     * @return <code>true</code> if at least one of the types of the content is unknown, <code>false</code> otherwise
     */
    public List<String> getUnknownContentTypeIds(Content content, boolean checkMixins)
    {
        List<String> unknownContentTypeIds = _getUnknownContentTypeIds(content.getTypes());
        
        if (checkMixins)
        {
            unknownContentTypeIds.addAll(_getUnknownContentTypeIds(content.getMixinTypes()));
        }
        
        return unknownContentTypeIds;
    }
    
    private List<String> _getUnknownContentTypeIds(String[] contentTypeIds)
    {
        List<String> unknownContentTypeIds = new ArrayList<>();
        for (String contentTypeId : contentTypeIds)
        {
            if (!_contentTypeEP.hasExtension(contentTypeId))
            {
                unknownContentTypeIds.add(contentTypeId);
            }
        }
        
        return unknownContentTypeIds;
    }
    
    /**
     * Determines if the content is a reference table content type
     * @param content The content
     * @return true if content is a reference table
     */
    public boolean isReferenceTable(Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType != null)
            {
                if (!cType.isReferenceTable())
                {
                    return false;
                }
            }
            else
            {
                getLogger().warn("Unable to determine if a content is a reference table, unknown content type : '{}'.", cTypeId);
            }
        }
        return true;
    }
    
    /**
     * Determines if a content is a multilingual content
     * @param content The content
     * @return <code>true</code> if the content is an instance of content type
     */
    public boolean isMultilingual(Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType != null && cType.isMultilingual())
            {
                return true;
            }
        }
        return false;
    }
    
    /**
     * Determines if the content is a simple content type
     * @param content The content
     * @return true if content is simple
     */
    public boolean isSimple (Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType != null)
            {
                if (!cType.isSimple())
                {
                    return false;
                }
            }
            else
            {
                getLogger().warn("Unable to determine if a content is simple, unknown content type : '{}'.", cTypeId);
            }
        }
        return true;
    }
    
    /**
     * Determines if the content is archived
     * @param content the content
     * @return true if the content is archived
     */
    public boolean isArchivedContent(Content content)
    {
        boolean canBeArchived = Stream.of(content.getTypes())
            .filter(_contentTypesHelper::isArchivedContentType)
            .findAny()
            .isPresent();
            
        return canBeArchived && content.getValue("archived", false, false);
    }
    
    /**
     * Get the typed value(s) of a content at given path.
     * The path can represent a system property id or a path of an attribute into the content or an attribute on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/attribute'.
     * The returned value is typed.
     * @param content The content
     * @param fieldPath The field id or the path to the attribute, separated by '/'
     * @return The typed final value(s). If the final field is multiple, or contained into a repeater or multiple 'CONTENT' attribute, the returned value will be a Collection
     */
    public Object getValue(Content content, String fieldPath)
    {
        if (StringUtils.isEmpty(fieldPath))
        {
            return null;
        }
        
        // Manage System Properties
        String[] pathSegments = fieldPath.split(ModelItem.ITEM_PATH_SEPARATOR);
        String propertyName = pathSegments[pathSegments.length - 1];
        
        if (_systemPropertyExtensionPoint.hasExtension(propertyName))
        {
            if (_systemPropertyExtensionPoint.isDisplayable(propertyName))
            {
                SystemProperty systemProperty = _systemPropertyExtensionPoint.getExtension(propertyName);
                return _getSystemPropertyValue(content, pathSegments, systemProperty);
            }
            else
            {
                throw new IllegalArgumentException("The system property '" + propertyName + "' is not displayable.");
            }
        }
        else if (content.hasDefinition(fieldPath))
        {
            Object value = content.getValue(fieldPath, true);
            if (value instanceof Object[])
            {
                return Arrays.asList((Object[]) value);
            }
            else
            {
                return value;
            }
        }
        else
        {
            getLogger().warn("Unknown data at path '{}' for content {}. No corresponding system property nor attribute definition found." , fieldPath, content);
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private Object _getSystemPropertyValue(Content content, String[] pathSegments, SystemProperty systemProperty)
    {
        String contentFieldPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
        List<Content> contentsContainingSystemProperty = getTargetContents(content, contentFieldPath);
        if (contentsContainingSystemProperty.size() == 1)
        {
            Object value = systemProperty.getValue(contentsContainingSystemProperty.get(0));
            
            if (value instanceof Object[])
            {
                return Arrays.asList((Object[]) value);
            }
            else
            {
                return value;
            }
        }
        else
        {
            List<Object> values = new ArrayList<>();
            for (Content contentContainingSystemProperty : contentsContainingSystemProperty)
            {
                Object value = systemProperty.getValue(contentContainingSystemProperty);
                
                if (value instanceof Object[])
                {
                    values.addAll(Arrays.asList((Object[]) value));
                }
                else
                {
                    values.add(value);
                }
            }
            return values;
        }
    }
    
    /**
     * Get the content from which to get the system property.
     * @param sourceContent The source content.
     * @param fieldPath The field path
     * @return The target content.
     */
    public Content getTargetContent(Content sourceContent, String fieldPath)
    {
        return getTargetContents(sourceContent, fieldPath)
                .stream()
                .findFirst()
                .orElse(null);
    }
    
    /**
     * Get the contents from which to get the system property.
     * @param sourceContent The source content.
     * @param fieldPath The field path
     * @return The target contents.
     */
    public List<Content> getTargetContents(Content sourceContent, String fieldPath)
    {
        if (StringUtils.isBlank(fieldPath))
        {
            return List.of(sourceContent);
        }
        else
        {
            ModelItem definition = sourceContent.getDefinition(fieldPath);
            if (ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(definition.getType().getId()))
            {
                return _transformToStream(sourceContent.getValue(fieldPath, true))  // Get the value and transform it to stream (depending of null, single or multiple value)
                    .map(ContentValue::getContentIfExists)
                    .flatMap(Optional::stream)      // Keep only existing contents
                    .collect(Collectors.toList());
            }
            else
            {
                // The item at the given path is not of type content
                return List.of();
            }
        }
    }
    
    private Stream<ContentValue> _transformToStream(Object value)
    {
        if (value == null)
        {
            return Stream.of();
        }
        else if (value.getClass().isArray())
        {
            return Stream.of((ContentValue[]) value);
        }
        return Stream.of((ContentValue) value);
    }

    /**
     * Get the title of a content.&lt;br&gt;
     * If the content is a multilingual content, the title will be retrieved for the current locale if exists, or for default locale 'en' if exists, or for the first found locale.
     * @param content The content
     * @return The title of the content
     */
    public String getTitle(Content content)
    {
        Locale defaultLocale = null;
        
        try
        {
            Map objectModel = (Map) _context.get(ContextHelper.CONTEXT_OBJECT_MODEL);
            if (objectModel != null)
            {
                // The object model can be null if #getTitle(content) is called outside a request
                defaultLocale = org.apache.cocoon.i18n.I18nUtils.findLocale(objectModel, "locale", null, Locale.getDefault(), true);
            }
        }
        catch (ContextException e)
        {
            // There is no context
        }
        
        // TODO Use user preference language ?
        return content.getTitle(defaultLocale);
    }
    
    /**
     * Get the title variants of a multilingual content
     * @param content The multilingual content
     * @return the content's title for each locale
     * @throws IllegalArgumentException if the content is not a multilingual content
     */
    public Map<String, String> getTitleVariants(Content content)
    {
        if (!isMultilingual(content))
        {
            throw new IllegalArgumentException("Can not get title variants for a non-multilingual content " + content.getId());
        }
        
        Map<String, String> variants = new HashMap<>();
        
        MultilingualString value = content.getValue(Content.ATTRIBUTE_TITLE);
        if (value != null)
        {
            for (Locale locale : value.getLocales())
            {
                variants.put(locale.getLanguage(), value.getValue(locale));
            }
        }
        
        return variants;
    }
    
    /**
     * Determines if the content has referencing contents other than whose type is in content types to ignore.
     * @param content The content to check
     * @param ignoreContentTypes The content types to ignore for referencing contents
     * @param includeSubTypes True if sub content types are take into account in ignore content types
     * @return <code>true</code> if there is at least one Content referencing the content
     */
    public boolean hasReferencingContents(Content content, List<String> ignoreContentTypes, boolean includeSubTypes)
    {
        List<String> newIgnoreContentTypes = new ArrayList<>();
        newIgnoreContentTypes.addAll(ignoreContentTypes);
        if (includeSubTypes)
        {
            for (String contentType : ignoreContentTypes)
            {
                newIgnoreContentTypes.addAll(_contentTypeEP.getSubTypes(contentType));
            }
        }
        
        for (Content refContent : content.getReferencingContents())
        {
            List<String> contentTypes = Arrays.asList(refContent.getTypes());
            if (!CollectionUtils.containsAny(contentTypes, newIgnoreContentTypes))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Returns all Contents referencing the given content with their value path
     * @param content The content to get references
     * @return the list of pair path / contents
     */
    public List<Pair<String, Content>> getReferencingContents(Content content)
    {
        List<Pair<String, Content>> incomingReferences = new ArrayList<>();
        try
        {
            NodeIterator results = OutgoingReferencesHelper.getContentOutgoingReferences((JCRAmetysObject) content);
            while (results.hasNext())
            {
                Node node = results.nextNode();
                
                Node outgoingRefsNode = node.getParent(); // go up towards node 'ametys-internal:outgoing-references;
                String path = outgoingRefsNode.getProperty(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + DefaultContent.METADATA_OUTGOING_REFERENCES_PATH_PROPERTY).getString();
                
                Node contentNode = outgoingRefsNode.getParent()  // go up towards node 'ametys-internal:root-outgoing-references
                                                   .getParent(); // go up towards node of the content
                Content refContent = _resolver.resolve(contentNode, false);
 
                incomingReferences.add(new ImmutablePair<>(path, refContent));
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to resolve references for content " + content.getId(), e);
        }
        
        return incomingReferences;
    }
    
    /**
     * Get the default workflow name for the content. If several workflows are possible, an empty {@link Optional} is returned.
     * @param content The content
     * @return The default workflow name or {@link Optional#empty()} if it cannot be determine
     */
    public Optional<String> getDefaultWorkflowName(Content content)
    {
        Set<String> defaultWorkflowNames = Stream.of(content.getTypes())
                .map(_contentTypeEP::getExtension)
                // Don't use ContentType.getDefaultWorkflowName because it returns an empty Optional if there are several available workflow names
                .map(ContentType::getConfiguredDefaultWorkflowNames)
                .flatMap(Set::stream)
                .collect(Collectors.toSet());
        
        if (defaultWorkflowNames.size() > 1)
        {
            getLogger().warn("Several default workflows are defined for content {} : {}.", content.toString(), StringUtils.join(defaultWorkflowNames));
            return Optional.empty();
        }
        
        return defaultWorkflowNames
                .stream()
                .findFirst()
                .or(() -> Optional.of(isReferenceTable(content) ? "reference-table" : "content"));
        
    }
    
    /**
     * Get the URL for the HTML view of a content with the needed parameters
     * @param content the content
     * @param viewName the view name
     * @return the content uri
     */
    public String getContentHtmlViewUrl(Content content, String viewName)
    {
        return getContentHtmlViewUrl(content, viewName, Map.of());
    }
    
    /**
     * Get the URL for the HTML view of a content with the needed parameters
     * @param content the content
     * @param viewName the view name
     * @param additionalParams the additional parameters. Can be empty
     * @return the content uri
     */
    public String getContentHtmlViewUrl(Content content, String viewName, Map<String, String> additionalParams)
    {
        return getContentViewUrl(content, viewName, "html", additionalParams);
    }
    
    /**
     * Get the URL for the view of a content with the needed parameters
     * @param content the content
     * @param viewName the view name
     * @param format the output format (html, xml, doc, pdf, ...)
     * @return the content uri
     */
    public String getContentViewUrl(Content content, String viewName, String format)
    {
        return getContentViewUrl(content, viewName, format, Map.of());
    }
    
    /**
     * Get the URL for the view of a content with the needed parameters
     * @param content the content
     * @param viewName the view name
     * @param format the output format (html, xml, doc, pdf, ...)
     * @param additionalParams the additional parameters. Can be empty
     * @return the content uri
     */
    public String getContentViewUrl(Content content, String viewName, String format, Map<String, String> additionalParams)
    {
        String uri = "cocoon://_content." + format;
        Map<String, String> uriParams = getContentViewUrlParameters(content, viewName, format, additionalParams);
        return URIUtils.buildURI(uri, uriParams);
    }
    
    
    /**
     * Get the needed url parameters for a content view
     * @param content the content
     * @param viewName the view name
     * @param format the output format (html, xml, doc, pdf, ...)
     * @return the uri parameters
     */
    public Map<String, String> getContentViewUrlParameters(Content content, String viewName, String format)
    {
        return getContentViewUrlParameters(content, viewName, format, Map.of());
    }
    
    /**
     * Get the needed url parameters for a content view
     * @param content the content
     * @param viewName the view name
     * @param format the output format (html, xml, doc, pdf, ...)
     * @param additionalParams the additional parameters. Can be empty
     * @return the uri parameters
     */
    public Map<String, String> getContentViewUrlParameters(Content content, String viewName, String format, Map<String, String> additionalParams)
    {
        Map<String, String> params = new HashMap<>();
        params.put("contentId", content.getId());
        params.put("viewName", viewName);
        params.put("output-format", format);
        params.putAll(additionalParams);
        
        return params;
    }
    
    /**
     * Get the content URL in back office
     * @param content the content
     * @param contextualParameters the contextual parameters
     * @return the content URL
     */
    public String getContentBOUrl(Content content, Map<String, Object> contextualParameters)
    {
        return _baseURL + "/index.html?uitool=uitool-content,id:%27" + URIUtils.encodeParameter(content.getId()) + "%27";
    }
    
    /**
     * Get all global validators of the given content
     * Deduplicate potential validators appearing twice in the content's types
     * @param content the content
     * @return all content's global validators
     */
    public Collection<ContentValidator> getGlobalValidators(Content content)
    {
        return getContentTypes(content).stream()
                                       .map(ContentType::getGlobalValidators)
                                       .flatMap(Collection::stream)
                                       .collect(Collectors.toSet());
    }
    
    /**
     * Validate the content (global validator and each attribute validation)
     * @param content the content to validate
     * @return the validation result
     */
    public ValidationResult validateContent(Content content)
    {
        ValidationResult results = new ValidationResult();
        
        List<ModelItem> modelItems = ModelHelper.getModelItems(content.getModel())
                .stream()
                .filter(modelItem -> !(modelItem instanceof ElementDefinition) || ((ElementDefinition) modelItem).isEditable())
                .collect(Collectors.toList());

        ValidationResult result = _validateValues(modelItems, Optional.of(content), "", content);
        if (result.hasErrors())
        {
            return result;
        }
        
        for (ContentValidator contentValidator : getGlobalValidators(content))
        {
            ValidationResult validationResult = contentValidator.validate(content);
            if (validationResult.hasErrors())
            {
                List<String> translatedErrors = validationResult.getErrors()
                                                                .stream()
                                                                .map(error -> _i18nUtils.translate(error, "en"))
                                                                .toList();
                results.addError(new I18nizableText(String.format("Validation failed for content '%s' on global validator '%s' with errors %s", content.getId(), contentValidator.getClass().getName(), translatedErrors)));
                return results;
            }
        }
        
        return results;
    }
    
    private ValidationResult _validateValues(List<ModelItem> modelItems, Optional<? extends ModelAwareDataHolder> dataHolder, String dataPath, Content content)
    {
        ValidationResult results = new ValidationResult();
        for (ModelItem modelItem : modelItems)
        {
            String name = modelItem.getName();
            if (!_disableConditionsEvaluator.evaluateDisableConditions(modelItem, dataPath + name, content))
            {
                if (modelItem instanceof ElementDefinition)
                {
                    // simple element
                    ElementDefinition definition = (ElementDefinition) modelItem;
                    Object value = dataHolder.map(holder -> holder.getValue(name)).orElse(null);
                    
                    if (ModelHelper.validateValue(definition, value).hasErrors())
                    {
                        results.addError(new I18nizableText(String.format("Validate attribute failed for content %s on attribute %s with value %s", content.getId(), dataPath + name, String.valueOf(value))));
                        return results;
                    }
                }
                else if (modelItem instanceof CompositeDefinition)
                {
                    // composite
                    Optional<ModelAwareComposite> composite = dataHolder.map(holder -> holder.getComposite(name));
                    ValidationResult result = _validateValues(((CompositeDefinition) modelItem).getChildren(), composite, dataPath + name + "/", content);
                    if (result.hasErrors())
                    {
                        return result;
                    }
                }
                else if (modelItem instanceof RepeaterDefinition)
                {
                    // repeater
                    RepeaterDefinition definition = (RepeaterDefinition) modelItem;
                    Optional<ModelAwareRepeater> repeater = dataHolder.map(holder -> holder.getRepeater(name));
                    
                    Optional<List<? extends ModelAwareRepeaterEntry>> entries = repeater.map(ModelAwareRepeater::getEntries);
                    
                    int repeaterSize = repeater.map(ModelAwareRepeater::getSize).orElse(0);
                    int minSize = definition.getMinSize();
                    int maxSize = definition.getMaxSize();
                    
                    if (repeaterSize < minSize
                        || maxSize > 0 && repeaterSize > maxSize)
                    {
                        results.addError(new I18nizableText(String.format("Validate repeater size failed for content %s on repeater %s with size %s", content.getId(), dataPath + name, repeaterSize)));
                        return results;
                    }
                    
                    if (entries.isPresent())
                    {
                        for (ModelAwareRepeaterEntry entry : entries.get())
                        {
                            ValidationResult result = _validateValues(definition.getChildren(), Optional.of(entry), dataPath + name + "[" + (entry.getPosition())  + "]/", content);
                            if (result.hasErrors())
                            {
                                return result;
                            }
                        }
                    }
                }
            }
        }
        
        return results;
    }
}