/*
 *  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.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.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.data.ContentValue;
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.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.metadata.MultilingualString;
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.model.DefinitionContext;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewHelper;
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
{
    /** The component role. */
    public static final String ROLE = ContentHelper.class.getName();
    
    private AmetysObjectResolver _resolver;
    private ContentTypesHelper _contentTypesHelper;
    private ContentTypeExtensionPoint _contentTypeEP;
    
    private ObservationManager _observationManager;
    private WorkflowProvider _workflowProvider;
    private CurrentUserProvider _currentUserProvider;
    private SystemPropertyExtensionPoint _systemPropertyExtensionPoint;
    
    private Context _context;

    @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);
    }
    
    @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 HashMap<String, Object>());
                    inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
                    
                    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 HashMap<String, Object>());
                    inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
                    
                    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;
        }
    }

    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)
                    .filter(Optional::isPresent)    // Keep only existing contents
                    .map(Optional::get)
                    .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);
        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"));
        
    }
}