/*
 *  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.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

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.logger.AbstractLogEnabled;
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.components.ContextHelper;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
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.ContentConstants;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataManager;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
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.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.MultilingualString;
import org.ametys.plugins.repository.metadata.MultilingualStringHelper;
import org.ametys.plugins.repository.metadata.UnknownMetadataException;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;

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 '" + contentTypeId + "' is a mixin type. It can not be added as content type.");
                }
                else if (!_contentTypesHelper.isCompatibleContentType(content, contentTypeId))
                {
                    result.put("failure", true);
                    result.put("msg", "invalid-content-type");
                    getLogger().error("Content type '" + contentTypeId + "' is incompatible with content '" + 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 '" + content.getId() + "'.");
        }
        
        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 '" + mixinId + "' is not a mixin type, it can be not be added as a mixin.");
                }
                else if (!_contentTypesHelper.isCompatibleContentType(content, mixinId))
                {
                    result.put("failure", true);
                    result.put("msg", "invalid-mixin");
                    getLogger().error("Mixin '" + mixinId + "' is incompatible with content '" + 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 '" + content.getId() + "'.");
        }
        
        return result;
    }
    
    /**
     * 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
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn(String.format("Unable to determine if a content is a reference table, unknown content type : '%s'.", 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
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn(String.format("Unable to determine if a content is simple, unknown content type : '%s'.", cTypeId));
                }
            }
        }
        return true;
    }
    
    /**
     * Get the typed value(s) of a content at given path.
     * The path can represent a system property id or a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param fieldPath The field id or the path to the metadata, separated by '/'
     * @param defaultLocale The default locale to resolve localized values if the content's language is null. Can be null.
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @return The typed final value. If the final field is multiple, or contains into a repeater or multiple 'CONTENT' metadata, the returned value will be a Collection
     */
    public Object getValue(Content content, String fieldPath, Locale defaultLocale, boolean resolveReferences)
    {
        return getValue(content, fieldPath, defaultLocale, resolveReferences, false);
    }
    
    /**
     * Get the typed value(s) of a content at given path.
     * The path can represent a system property id or a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param fieldPath The field id or the path to the metadata, separated by '/'
     * @param defaultLocale The default locale to resolve localized values if the content's language is null. Can be null.
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @param returnNullValues <code>true</code> true to return null values when the metadata does not exists in a repeater or linked content.
     * @return The typed final value. If the final field is multiple, or contains into a repeater or multiple 'CONTENT' metadata, the returned value will be a Collection
     */
    public Object getValue(Content content, String fieldPath, Locale defaultLocale, boolean resolveReferences, boolean returnNullValues)
    {
        if (StringUtils.isAnyEmpty(fieldPath))
        {
            return null;
        }
        
        // Manage System Properties
        String[] pathSegments = fieldPath.split(ContentConstants.METADATA_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
        {
            return getMetadataValue(content, fieldPath, defaultLocale, resolveReferences, returnNullValues);
        }
    }

    private Object _getSystemPropertyValue(Content content, String[] pathSegments, SystemProperty systemProperty)
    {
        String contentFieldPath = StringUtils.join(pathSegments, ContentConstants.METADATA_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)
    {
        if (StringUtils.isBlank(fieldPath))
        {
            return sourceContent;
        }
        else
        {
            Object value = getMetadataValue(sourceContent, fieldPath, null, true);
            if (value != null && value instanceof Content)
            {
                return (Content) value;
            }
            else if (value != null && value instanceof Collection<?> && ((Collection) value).size() > 0)
            {
                Object first = ((Collection) value).iterator().next();
                if (first instanceof Content)
                {
                    return (Content) first;
                }
            }
        }
        
        return 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)
    {
        List<Content> targetContents = new ArrayList<>();
        
        if (StringUtils.isBlank(fieldPath))
        {
            targetContents.add(sourceContent);
        }
        else
        {
            Object value = getMetadataValue(sourceContent, fieldPath, null, true);
            if (value != null && value instanceof Content)
            {
                targetContents.add((Content) value);
            }
            else if (value != null && value instanceof Collection<?>)
            {
                Iterator it = ((Collection) value).iterator();
                while (it.hasNext())
                {
                    Object object = it.next();
                    if (object instanceof Content)
                    {
                        targetContents.add((Content) object);
                    }
                    
                }
            }
        }
        
        return targetContents;
    }

    /**
     * Get the typed metadata value(s) of a content at given path.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param defaultLocale The locale to use to sax localized values such as multilingual content or multilingual string. 
     * Only to be valued if initial content's language is null, otherwise set this parameter to null.
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @return The typed final value. If the final metadata is multiple, or contains into a repeater or multiple 'CONTENT' metadata, the returned value will be a Collection
     */
    public Object getMetadataValue(Content content, String metadataPath, Locale defaultLocale, boolean resolveReferences)
    {
        return getMetadataValue(content, metadataPath, defaultLocale, resolveReferences, false);
    }
    
    /**
     * Get the typed metadata value(s) of a content at given path.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param defaultLocale The locale to use to sax localized values such as multilingual content or multilingual string. 
     * Only to be valued if initial content's language is null, otherwise set this parameter to null.
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @param returnNullValues <code>true</code> true to return null values when the metadata does not exists in a repeater or linked content.
     * @return The typed final value. If the final metadata is multiple, or contains into a repeater or multiple 'CONTENT' metadata, the returned value will be a Collection
     */
    public Object getMetadataValue(Content content, String metadataPath, Locale defaultLocale, boolean resolveReferences, boolean returnNullValues)
    {
        String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
        
        MetadataDefinition definition = _contentTypesHelper.getMetadataDefinition(pathSegments[0], content);
        if (definition != null)
        {
            Locale contentLocale = content.getLanguage() != null ? new Locale(content.getLanguage()) : defaultLocale;
            return getMetadataValue(content.getMetadataHolder(), definition, metadataPath, contentLocale, resolveReferences, returnNullValues);
        }
        
        getLogger().warn("Unknown metadata definition at path '" + metadataPath + "' for content '" + content.getId());
        return null;
    }
    
    /**
     * Get the typed values of a content at given path.
     * The value is always returned into a collection of object event if the metadata is a single metadata.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param contentId The ID of the content
     * @param metadataPath The Path to the metadata, separated by '/'
     * @return The typed final value. If the final metadata is single, the returned value will be a Collection of one element
     */
    @Callable
    public List<Object> getMetadataValues(String contentId, String metadataPath)
    {
        return getMetadataValues(_resolver.resolveById(contentId), metadataPath, null, false, true);
    }
    
    /**
     * Get the typed values of a content at given path.
     * The value is always returned into a collection of object event if the metadata is a single metadata.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param defaultLocale The locale to use to sax localized values such as multilingual content or multilingual string. 
     * Only to be valued if initial content's language is null, otherwise set this parameter to null.
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @param returnNullValues <code>true</code> true to return null values when the metadata does not exists in a repeater or linked content.
     * @return The typed final value. If the final metadata is single, the returned value will be a Collection of one element
     */
    public List<Object> getMetadataValues(Content content, String metadataPath, Locale defaultLocale, boolean resolveReferences, boolean returnNullValues)
    {
        String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
        
        MetadataDefinition definition = _contentTypesHelper.getMetadataDefinition(pathSegments[0], content);
        if (definition != null)
        {
            Locale locale = content.getLanguage() != null ? new Locale(content.getLanguage()) : defaultLocale;
            Object values = getMetadataValue(content.getMetadataHolder(), definition, metadataPath, locale, resolveReferences, returnNullValues);
            if (values instanceof Collection<?>)
            {
                return new ArrayList<>((Collection<?>) values); 
            }
            else if (values != null || returnNullValues)
            {
                return Arrays.asList(values);
            }
            else
            {
                return Collections.EMPTY_LIST;
            }
        }
        
        getLogger().warn("Unknown metadata definition at path '" + metadataPath + "' for content '" + content.getId());
        
        return null;
    }
    
    /**
     * 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.getMetadataHolder().getMultilingualString(DefaultContent.METADATA_TITLE);
        for (Locale locale : value.getLocales())
        {
            variants.put(locale.getLanguage(), value.getValue(locale));
        }
        
        return variants;
    }
    
    /**
     * Get the typed value(s) at given path.
     * The path can represent a path of a metadata in the parent composite metadata or a path of a metadata into a linked content.
     * The returned value is typed.
     * @param metadataHolder The parent composite metadata
     * @param definition The definition of the first metadata in path
     * @param metadataPath The path to the metadata, separated by '/'
     * @param locale The locale to used to resolve localized metadata
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @param returnNullValues <code>true</code> true to return null values when metadata does not exists.
     * @return The typed final value. If the final metadata is multiple, or contains into a repeater or multiple 'CONTENT' metadata, the returned value will be a Collection
     */
    public Object getMetadataValue(CompositeMetadata metadataHolder, MetadataDefinition definition, String metadataPath, Locale locale, boolean resolveReferences, boolean returnNullValues)
    {
        String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
        
        String metadataName = pathSegments[0];
        
        if (!metadataHolder.hasMetadata(metadataName))
        {
            return null;
        }
        
        MetadataType type = definition.getType();
        switch (type)
        {
            case COMPOSITE:
                return _getCompositeMetadataValue(metadataHolder, definition, locale, resolveReferences, returnNullValues, pathSegments, metadataName);
            
            case CONTENT:
                return _getContentMetadataValue(metadataHolder, definition, locale, resolveReferences, returnNullValues, pathSegments, metadataName);
            default:
                if (pathSegments.length == 1)
                {
                    return getSimpleMetadataValue(metadataHolder, definition, metadataName, locale, resolveReferences);
                }
                
                throw new IllegalArgumentException("Metadata at path '" + definition.getId() + "' is a simple metadata : can not invoked get sub metadata values at path " + StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length));
        }
    }

    private Object _getContentMetadataValue(CompositeMetadata metadataHolder, MetadataDefinition definition, Locale defaultLocale, boolean resolveReferences, boolean returnNullValues,
            String[] pathSegments, String metadataName)
    {
        if (pathSegments.length > 1)
        {
            if (definition.isMultiple())
            {
                List<Object> values = new ArrayList<>();
                String[] refContentIds = metadataHolder.getStringArray(metadataName, new String[0]);
                for (String refContentId : refContentIds)
                {
                    Content refContent = _resolver.resolveById(refContentId);
                    Locale locale = refContent.getLanguage() != null ? new Locale(refContent.getLanguage()) : defaultLocale;
                    Object remoteValue = getMetadataValue(refContent, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences, returnNullValues);
                    if (remoteValue != null && remoteValue instanceof Collection<?>)
                    {
                        values.addAll((Collection<?>) remoteValue);
                    }
                    else if (remoteValue != null || returnNullValues)
                    {
                        values.add(remoteValue);
                    }
                }
                return values;
            }
            else
            {
                String refContentId = metadataHolder.getString(metadataName);
                Content refContent = _resolver.resolveById(refContentId);
                Locale locale = refContent.getLanguage() != null ? new Locale(refContent.getLanguage()) : defaultLocale;
                return getMetadataValue(refContent, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences, returnNullValues);
            }   
        }
        else
        {
            return getSimpleMetadataValue(metadataHolder, definition, metadataName, defaultLocale, resolveReferences);
        }
    }

    private Object _getCompositeMetadataValue(CompositeMetadata metadataHolder, MetadataDefinition definition, Locale locale, boolean resolveReferences, boolean returnNullValues, String[] pathSegments, String metadataName)
    {
        if (pathSegments.length > 1)
        {
            if (definition instanceof RepeaterDefinition)
            {
                // Repeater: get and sort the entry names.
                CompositeMetadata repeater = metadataHolder.getCompositeMetadata(metadataName);
                String[] entries = repeater.getMetadataNames();
                Arrays.sort(entries, MetadataManager.REPEATER_ENTRY_COMPARATOR);
                
                List<Object> values = new ArrayList<>();
                
                for (String entryName : entries)
                {
                    CompositeMetadata entry = repeater.getCompositeMetadata(entryName);
                    
                    Object entryValue = getMetadataValue(entry, definition.getMetadataDefinition(pathSegments[1]), StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences, returnNullValues);
                    if (entryValue != null && entryValue instanceof Collection<?>)
                    {
                        values.addAll((Collection<?>) entryValue);
                    }
                    else if (entryValue != null || returnNullValues)
                    {
                        values.add(entryValue);
                    }
                }
                
                return values;
            }
            else
            {
                // Composite.
                CompositeMetadata subMetadataHolder = metadataHolder.getCompositeMetadata(metadataName);
                MetadataDefinition subMetadataDef = definition.getMetadataDefinition(pathSegments[1]);
                return getMetadataValue(subMetadataHolder, subMetadataDef, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences, returnNullValues);
            }
        }
                        
        throw new IllegalArgumentException("Metadata at path '" + definition.getId() + "' is a composite metadata : can not invoked #getMetadataValue");
    }
    
    /**
     * Get the typed value(s) of a simple metadata.
     * @param metadataHolder The parent composite metadata
     * @param definition The definition of the first metadata in path
     * @param metadataName The name of the metadata
     * @param locale The locale to used to resolve localized metadata
     * @param resolveReferences <code>true</code> true to resolve references (such as resource or content)
     * @return The typed final value.
     */
    public Object getSimpleMetadataValue(CompositeMetadata metadataHolder, MetadataDefinition definition, String metadataName, Locale locale, boolean resolveReferences)
    {
        if (metadataName.contains(ContentConstants.METADATA_PATH_SEPARATOR))
        {
            throw new IllegalArgumentException("The metadata name cannot represent a path : " + metadataName);
        }
        
        Object value = null;
        
        switch (definition.getType())
        {
            case LONG:
                value = _getLongValue(metadataHolder, metadataName, definition);
                break;
            case DOUBLE:
                value = _getDoubleValue(metadataHolder, metadataName, definition);
                break;
            case BOOLEAN:
                value = _getBooleanValue(metadataHolder, metadataName, definition);
                break;
            case DATE:
            case DATETIME:
                value = _getDateValue(metadataHolder, metadataName, definition);
                break;
            case USER:
                value = _getUserValue(metadataHolder, metadataName, definition);
                break;
            case BINARY:
                value = _getBinaryValue(metadataHolder, metadataName);
                break;
            case FILE:
                value = _getFileValue(metadataHolder, metadataName, definition, resolveReferences);
                break;
            case GEOCODE:
                value = _getGeocodeValue(metadataHolder, metadataName);
                break;
            case RICH_TEXT:
                value = _getRichTextValue(metadataHolder, metadataName);
                break;
            case CONTENT:
                value = _getContentValue(metadataHolder, metadataName, definition, resolveReferences);
                break;
            case SUB_CONTENT:
                // TODO or ignore ?
                break;
            case REFERENCE:
                value = _getReferenceValue(metadataHolder, metadataName, definition);
                break;
            case MULTILINGUAL_STRING:
                value = _getMultilingualStringValue(metadataHolder, metadataName, locale, resolveReferences);
                break;
            case STRING:
            default:
                value = _getStringValue(metadataHolder, metadataName, definition);
        }
        
        return value;
    }
    
    private Object _getStringValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(metadataHolder.getStringArray(metadataName));
            }
            else
            {
                return metadataHolder.getString(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getMultilingualStringValue(CompositeMetadata metadataHolder, String metadataName, Locale locale, boolean resolve)
    {
        if (resolve)
        {
            return metadataHolder.getMultilingualString(metadataName);
        }
        else
        {
            return MultilingualStringHelper.getValue(metadataHolder, metadataName, locale);
        }
    }
    
    private Object _getContentValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition, boolean resolve)
    {
        try
        {
            if (definition.isMultiple())
            {
                String[] refContentIds = metadataHolder.getStringArray(metadataName);
                if (resolve)
                {
                    List<Content> contents = new ArrayList<>();
                    for (String refContentId : refContentIds)
                    {
                        try
                        {
                            contents.add(_resolver.resolveById(refContentId));
                        }
                        catch (UnknownAmetysObjectException e)
                        {
                            // Ignore
                            if (getLogger().isWarnEnabled())
                            {
                                getLogger().warn("Metadata '" + definition.getId() + "' refers a non-existing content of id '" + refContentId + "'", e);
                            }
                        }
                    }
                    return contents;
                }
                else
                {
                    return Arrays.asList(refContentIds);
                }
            }
            else
            {
                if (resolve)
                {
                    try
                    {
                        return _resolver.resolveById(metadataHolder.getString(metadataName));
                    }
                    catch (UnknownAmetysObjectException e)
                    {
                        return null;
                    }
                }
                else
                {
                    return metadataHolder.getString(metadataName);
                }
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getUserValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(metadataHolder.getUserArray(metadataName));
            }
            else
            {
                return metadataHolder.getUser(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getDateValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(metadataHolder.getDateArray(metadataName));
            }
            else
            {
                return metadataHolder.getDate(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getLongValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(ArrayUtils.toObject(metadataHolder.getLongArray(metadataName)));
            }
            else
            {
                return metadataHolder.getLong(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getDoubleValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(ArrayUtils.toObject(metadataHolder.getDoubleArray(metadataName)));
            }
            else
            {
                return metadataHolder.getDouble(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getBooleanValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            if (definition.isMultiple())
            {
                return Arrays.asList(ArrayUtils.toObject(metadataHolder.getBooleanArray(metadataName)));
            }
            else
            {
                return metadataHolder.getBoolean(metadataName);
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getRichTextValue(CompositeMetadata metadataHolder, String metadataName)
    {
        try
        {
            return metadataHolder.getRichText(metadataName);
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getBinaryValue(CompositeMetadata metadataHolder, String metadataName)
    {
        try
        {
            return metadataHolder.getBinaryMetadata(metadataName);
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getResourceValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition, boolean resolve)
    {
        try
        {
            if (definition.isMultiple())
            {
                String[] resourceIds = metadataHolder.getStringArray(metadataName);
                if (resolve)
                {
                    List<Resource> resources = new ArrayList<>();
                    for (String resourceId : resourceIds)
                    {
                        try
                        {
                            resources.add(_resolver.resolveById(resourceId));
                        }
                        catch (UnknownAmetysObjectException e)
                        {
                            // Ignore
                        }
                    }
                    return resources;
                }
                else
                {
                    return Arrays.asList(resourceIds);
                }
            }
            else
            {
                if (resolve)
                {
                    try
                    {
                        return _resolver.resolveById(metadataHolder.getString(metadataName));
                    }
                    catch (UnknownAmetysObjectException e)
                    {
                        return null;
                    }
                }
                else
                {
                    return metadataHolder.getString(metadataName);
                }
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getGeocodeValue(CompositeMetadata metadataHolder, String metadataName)
    {
        try
        {
            // FIXME should return a GeoCode object
            CompositeMetadata geoMetadata = metadataHolder.getCompositeMetadata(metadataName);
            
            if (geoMetadata.hasMetadata("longitude") && geoMetadata.hasMetadata("latitude")) 
            {
                Double longitude = geoMetadata.getDouble("longitude");
                Double latitude = geoMetadata.getDouble("latitude");
                
                Map<String, Double> geocode = new LinkedHashMap<>();
                geocode.put("longitude", longitude);
                geocode.put("latitude", latitude);
                
                return geocode;
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
        }
        
        return null;
    }
    
    private Object _getReferenceValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition)
    {
        try
        {
            // FIXME should return a Reference object
            
            CompositeMetadata referencesComposite = metadataHolder.getCompositeMetadata(metadataName);
            
            if (definition.isMultiple())
            {
                List<Map<String, Object>> references = new ArrayList<>();
                
                String[] types = referencesComposite.getStringArray("types");
                String[] values = referencesComposite.getStringArray("values");
                
                for (int i = 0; i < types.length; i++)
                {
                    Map<String, Object> reference = new HashMap<>(2);
                    reference.put("type", types[i]);
                    reference.put("value", values[i]);
                    
                    references.add(reference);
                }
                
                return references;
            }
            else
            {
                String type = referencesComposite.getString("type");
                String value = referencesComposite.getString("value");
                
                Map<String, Object> reference = new HashMap<>(2);
                reference.put("type", type);
                reference.put("value", value);
                
                return reference;
            }
        }
        catch (UnknownMetadataException e)
        {
            // Ignore, just return null.
            return null;
        }
    }
    
    private Object _getFileValue(CompositeMetadata metadataHolder, String metadataName, MetadataDefinition definition, boolean resolveReference)
    {
        if (org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.BINARY.equals(metadataHolder.getType(metadataName)))
        {
            return _getBinaryValue(metadataHolder, metadataName);
        }
        else
        {
            return _getResourceValue(metadataHolder, metadataName, definition, resolveReference);
        }
    }
    
    /**
     * 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;
    }
}