/*
 *  Copyright 2014 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.contenttype;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.ConfigurationException;
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.avalon.framework.thread.ThreadSafe;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.content.RootContentHelper;
import org.ametys.cms.contenttype.indexing.IndexingField;
import org.ametys.cms.contenttype.indexing.IndexingModel;
import org.ametys.cms.repository.Content;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * Helper for manipulating {@link ContentType}s
 * 
 */
public class ContentTypesHelper extends AbstractLogEnabled implements Component, Serviceable, ThreadSafe, Disposable
{
    /** The Avalon role */
    public static final String ROLE = ContentTypesHelper.class.getName();

    /** The content types extension point */
    protected ContentTypeExtensionPoint _cTypeEP;
    /** The current user provider */
    protected CurrentUserProvider _userProvider;
    /** The rights manager */
    protected RightManager _rightManager;
    /** Helper for root content */
    protected RootContentHelper _rootContentHelper;
    
    private DynamicContentTypeDescriptorExtentionPoint _dynamicCTDescriptorEP;

    // Cache
    private Map<String, Map<String, MetadataSet>> _cacheForView = new HashMap<>();
    private Map<String, Map<String, MetadataSet>> _cacheForEdition = new HashMap<>();

    private ServiceManager _smanager;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _smanager = smanager;
        _dynamicCTDescriptorEP = (DynamicContentTypeDescriptorExtentionPoint) smanager.lookup(DynamicContentTypeDescriptorExtentionPoint.ROLE);
        _userProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _rightManager = (RightManager) smanager.lookup(RightManager.ROLE);
        _rootContentHelper = (RootContentHelper) smanager.lookup(RootContentHelper.ROLE);
    }

    @Override
    public void dispose()
    {
        _cacheForView = new HashMap<>();
        _cacheForEdition = new HashMap<>();
    }
    
    /**
     * Lazy lookup of {@link ContentTypeExtensionPoint}
     * @return the content type extension point
     */
    protected ContentTypeExtensionPoint _getContentTypeEP()
    {
        if (_cTypeEP == null)
        {
            try
            {
                _cTypeEP = (ContentTypeExtensionPoint) _smanager.lookup(ContentTypeExtensionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException("Unable to lookup ContentTypeExtensionPoint component", e);
            }
        }
        return _cTypeEP;
    }

    /**
     * Determines if a content is a instance of given content type id
     * 
     * @param content The content
     * @param cTypeId The id of content type or mixin
     * @return <code>true</code> if the content is an instance of content type
     */
    public boolean isInstanceOf(Content content, String cTypeId)
    {
        String[] types = content.getTypes();
        if (ArrayUtils.contains(types, cTypeId))
        {
            return true;
        }

        String[] mixins = content.getMixinTypes();
        if (ArrayUtils.contains(mixins, cTypeId))
        {
            return true;
        }

        return _containsContentType(ArrayUtils.addAll(types, mixins), cTypeId);
    }

    private boolean _containsContentType(String[] cTypesId, String cTypeId)
    {
        for (String id : cTypesId)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);
            if (cType != null)
            {
                if (ArrayUtils.contains(cType.getSupertypeIds(), cTypeId))
                {
                    return true;
                }
                else if (_containsContentType(cType.getSupertypeIds(), cTypeId))
                {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Get the id of the content type common ancestor
     * 
     * @param contentTypes The content types to compare
     * @return The id of common ancestor or <code>null</code> if not found
     */
    public String getCommonAncestor(Collection<String> contentTypes)
    {
        if (contentTypes.isEmpty())
        {
            return null;
        }

        if (contentTypes.size() == 1)
        {
            return contentTypes.iterator().next();
        }

        List<Collection<String>> superTypesByCType = new ArrayList<>();
        for (String id : contentTypes)
        {
            Set<String> superTypes = new HashSet<>();

            superTypes.add(id);
            superTypes.addAll(getAncestors(id));

            superTypesByCType.add(superTypes);
        }
        
        Iterator<Collection<String>> superTypesByCTypeIt = superTypesByCType.iterator();
        
        Set<String> commonCTypes = new HashSet<>(superTypesByCTypeIt.next());
        while (superTypesByCTypeIt.hasNext() && !commonCTypes.isEmpty())
        {
            commonCTypes.retainAll(superTypesByCTypeIt.next());
        }
        
        commonCTypes = removeAncestors(commonCTypes);
        
        if (commonCTypes.size() == 1)
        {
            return commonCTypes.iterator().next();
        }

        return null; // No common ancestor
    }

    /**
     * Remove all content types in the set that are ancestors of other content types in the set.
     * @param contentTypes a Set of content type IDs.
     * @return a Set of content type IDs without ancestors.
     */
    protected Set<String> removeAncestors(Set<String> contentTypes)
    {
        Set<String> noAncestors = new HashSet<>(contentTypes);
        
        Iterator<String> it1 = contentTypes.iterator();
        while (it1.hasNext())
        {
            ContentType cType1 = _getContentTypeEP().getExtension(it1.next());
            
            Iterator<String> it2 = contentTypes.iterator();
            while (it2.hasNext())
            {
                String cType2 = it2.next();
                String[] supertypeIds = cType1.getSupertypeIds();
                
                // CType2 is an ancestor of CType1: remove it.
                if (ArrayUtils.contains(supertypeIds, cType2))
                {
                    noAncestors.remove(cType2);
                }
            }
        }
        
        return noAncestors;
    }

    /**
     * Get all ancestors for the given content type
     * 
     * @param contentTypeId The content type id to test
     * @return A non-null set of all ancestors. Does not contains the contentTypeId itself.
     * @throws IllegalArgumentException if the content type does not exist.
     */
    public Set<String> getAncestors(String contentTypeId)
    {
        Set<String> superTypes = new HashSet<>();

        ContentType cType = _getContentTypeEP().getExtension(contentTypeId);
        
        if (cType == null)
        {
            throw new IllegalArgumentException("Unable to get anscestors of unknown content type '" + contentTypeId + "'");
        }
        

        String[] supertypeIds = cType.getSupertypeIds();

        for (String superTypeId : supertypeIds)
        {
            superTypes.add(superTypeId);
            superTypes.addAll(getAncestors(superTypeId));
        }

        return superTypes;

    }
    
    /**
     * Builds the reverse hierarchies of ancestors of a content type
     * @param contentTypeId The content type's id
     * @return the reverse hierarchies with ancestors
     */
    public List<Set<String>> buildReverseHierarchies(String contentTypeId)
    {
        Set<String> hierarchy = new LinkedHashSet<>();
        hierarchy.add(contentTypeId);
        return _buildReverseHierarchies (contentTypeId, hierarchy);
    }
    
    private List<Set<String>> _buildReverseHierarchies(String contentTypeId, Set<String> hierarchy)
    {
        List<Set<String>> hierarchies = new ArrayList<>();
        
        ContentType cType = _getContentTypeEP().getExtension(contentTypeId);
        if (cType == null)
        {
            throw new IllegalArgumentException("Unable to get anscestors of unknown content type '" + contentTypeId + "'");
        }
        
        String[] supertypeIds = cType.getSupertypeIds();
        if (supertypeIds.length > 0)
        {
            for (String superTypeId : supertypeIds)
            {
                Set<String> superHierarchy = new LinkedHashSet<>(hierarchy);
                superHierarchy.add(superTypeId);
                hierarchies.addAll(_buildReverseHierarchies(superTypeId, superHierarchy));
            }
        }
        else
        {
            hierarchies.add(hierarchy);
        }
        
        return hierarchies;
    }
    
    /**
     * Retrieves the root metadata names of a content.
     * @param content The content.
     * @return the metadata names.
     */
    public Set<String> getMetadataNames(Content content)
    {
        return getMetadataNames(content.getTypes(), content.getMixinTypes());
    }
    
    /**
     * Retrieves the metadata names resulting of the union of metadata
     * names of given content types and mixins
     * 
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return the metadata names.
     */
    public Set<String> getMetadataNames(String[] cTypes, String[] mixins)
    {
        Set<String> metadataNames = new HashSet<>();

        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);
            metadataNames.addAll(cType.getMetadataNames());
        }

        for (String id : mixins)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);
            metadataNames.addAll(cType.getMetadataNames());
        }

        return metadataNames;
    }

    /**
     * Get all metadata sets for view resulting of the concatenation of metadata
     * sets of given content types and mixins.
     * 
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @param includeInternal <code>true</code> True to include internal
     *            metadata sets
     * @return The metadata sets
     */
    public Map<String, MetadataSet> getMetadataSetsForView(String[] cTypes, String[] mixins, boolean includeInternal)
    {
        Map<String, MetadataSet> metadataSets = new HashMap<>();

        Set<String> viewMetadataSetNames = new HashSet<>();
        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);
            for (String name : cType.getViewMetadataSetNames(includeInternal))
            {
                if (!viewMetadataSetNames.contains(name))
                {
                    viewMetadataSetNames.add(name);
                }
            }
        }

        for (String viewMetadataSetName : viewMetadataSetNames)
        {
            metadataSets.put(viewMetadataSetName, getMetadataSetForView(viewMetadataSetName, cTypes, mixins));
        }

        return metadataSets;
    }

    /**
     * Get all metadata sets for edition resulting of the concatenation of
     * metadata sets of given content types and mixins.
     * 
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @param includeInternal <code>true</code> True to include internal
     *            metadata sets
     * @return The metadata sets
     */
    public Map<String, MetadataSet> getMetadataSetsForEdition(String[] cTypes, String[] mixins, boolean includeInternal)
    {
        Map<String, MetadataSet> metadataSets = new HashMap<>();

        Set<String> editionMetadataSetNames = new HashSet<>();
        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);
            for (String name : cType.getEditionMetadataSetNames(includeInternal))
            {
                if (!editionMetadataSetNames.contains(name))
                {
                    editionMetadataSetNames.add(name);
                }
            }
        }

        for (String editionMetadataSetName : editionMetadataSetNames)
        {
            metadataSets.put(editionMetadataSetName, getMetadataSetForEdition(editionMetadataSetName, cTypes, mixins));
        }

        return metadataSets;
    }

    /**
     * Get the metadata set for view resulting of the concatenation of metadata
     * sets of given content types and mixins.
     * 
     * @param metadataSetName the name of metadata set to retrieve
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return The list of metadata set names.
     */
    public MetadataSet getMetadataSetForView(String metadataSetName, String[] cTypes, String[] mixins)
    {
        String cacheId = _getCacheIdentifier(cTypes, mixins);

        if (_cacheForView.containsKey(cacheId) && _cacheForView.get(cacheId).containsKey(metadataSetName))
        {
            return _cacheForView.get(cacheId).get(metadataSetName);
        }

        MetadataSet joinMetadataSet = new MetadataSet();
        boolean foundOne = false;

        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            MetadataSet metadataSet = cType.getMetadataSetForView(metadataSetName);
            if (metadataSet != null)
            {
                foundOne = true;
                copyMetadataSetElementsIfNotExist(metadataSet, joinMetadataSet);

                if (joinMetadataSet.getName() == null)
                {
                    joinMetadataSet.setName(metadataSetName);
                    joinMetadataSet.setLabel(metadataSet.getLabel());
                    joinMetadataSet.setDescription(metadataSet.getDescription());
                    joinMetadataSet.setIconGlyph(metadataSet.getIconGlyph());
                    joinMetadataSet.setIconDecorator(metadataSet.getIconDecorator());
                    joinMetadataSet.setSmallIcon(metadataSet.getSmallIcon());
                    joinMetadataSet.setMediumIcon(metadataSet.getMediumIcon());
                    joinMetadataSet.setLargeIcon(metadataSet.getLargeIcon());
                    joinMetadataSet.setEdition(false);
                }
            }
        }

        for (String id : mixins)
        {
            ContentType mixin = _getContentTypeEP().getExtension(id);

            MetadataSet metadataSet = mixin.getMetadataSetForView(metadataSetName);
            if (metadataSet != null)
            {
                foundOne = true;
                copyMetadataSetElementsIfNotExist(metadataSet, joinMetadataSet);
            }
        }

        if (!foundOne)
        {
            return null;
        }
        
        if (!_cacheForView.containsKey(cacheId))
        {
            _cacheForView.put(cacheId, new HashMap<String, MetadataSet>());
        }
        _cacheForView.get(cacheId).put(metadataSetName, joinMetadataSet);

        return joinMetadataSet;
    }

    /**
     * Get the metadata set for edition resulting of the concatenation of
     * metadata sets of given content types and mixins.
     * 
     * @param metadataSetName the name of metadata set to retrieve
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return The metadata set
     */
    public MetadataSet getMetadataSetForEdition(String metadataSetName, String[] cTypes, String[] mixins)
    {
        String cacheId = _getCacheIdentifier(cTypes, mixins);

        if (_cacheForEdition.containsKey(cacheId) && _cacheForEdition.get(cacheId).containsKey(metadataSetName))
        {
            return _cacheForEdition.get(cacheId).get(metadataSetName);
        }

        MetadataSet joinMetadataSet = new MetadataSet();
        boolean foundOne = false;

        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            MetadataSet metadataSet = cType.getMetadataSetForEdition(metadataSetName);
            if (metadataSet != null)
            {
                foundOne = true;
                copyMetadataSetElementsIfNotExist(metadataSet, joinMetadataSet);

                if (joinMetadataSet.getName() == null)
                {
                    joinMetadataSet.setName(metadataSetName);
                    joinMetadataSet.setLabel(metadataSet.getLabel());
                    joinMetadataSet.setDescription(metadataSet.getDescription());
                    joinMetadataSet.setIconGlyph(metadataSet.getIconGlyph());
                    joinMetadataSet.setIconDecorator(metadataSet.getIconDecorator());
                    joinMetadataSet.setSmallIcon(metadataSet.getSmallIcon());
                    joinMetadataSet.setMediumIcon(metadataSet.getMediumIcon());
                    joinMetadataSet.setLargeIcon(metadataSet.getLargeIcon());
                    joinMetadataSet.setEdition(true);
                }
            }
        }

        for (String id : mixins)
        {
            ContentType mixin = _getContentTypeEP().getExtension(id);

            MetadataSet metadataSet = mixin.getMetadataSetForEdition(metadataSetName);
            if (metadataSet != null)
            {
                foundOne = true;
                copyMetadataSetElementsIfNotExist(metadataSet, joinMetadataSet);
            }
        }

        if (!foundOne)
        {
            return null;
        }
        
        if (!_cacheForEdition.containsKey(cacheId))
        {
            _cacheForEdition.put(cacheId, new HashMap<String, MetadataSet>());
        }
        _cacheForEdition.get(cacheId).put(metadataSetName, joinMetadataSet);

        return joinMetadataSet;
    }
    
    /**
     * Get the metadata sets of a content type
     * @param cTypeId the content type id
     * @param edition Set to true to get edition metadata set. False otherwise.
     * @param includeInternal Set to true to include internal metadata sets.
     * @return the metadata sets info
     */
    @Callable
    public List<Map<String, Object>> getMetadataSetsInfo(String cTypeId, boolean edition, boolean includeInternal)
    {
        List<Map<String, Object>> metadataSets = new ArrayList<>();
        
        ContentType cType = _getContentTypeEP().getExtension(cTypeId);
        
        Set<String> metadataSetNames = edition ? cType.getEditionMetadataSetNames(includeInternal) : cType.getViewMetadataSetNames(includeInternal);
        for (String metadataSetName : metadataSetNames)
        {
            MetadataSet metadataSet = edition ? cType.getMetadataSetForEdition(metadataSetName) : cType.getMetadataSetForView(metadataSetName);
            
            Map<String, Object> viewInfos = new HashMap<>();
            viewInfos.put("name", metadataSetName);
            viewInfos.put("label", metadataSet.getLabel());
            viewInfos.put("description", metadataSet.getDescription());
            metadataSets.add(viewInfos);
        }
        
        return metadataSets;
    }
    
    /**
     * Get the indexing model resulting of the concatenation of indexing models of given content types and mixins.
     * @param content The content.
     * @return The indexing model
     */
    public IndexingModel getIndexingModel(Content content)
    {
        return getIndexingModel(content.getTypes(), content.getMixinTypes());
    }

    /**
     * Get the indexing model resulting of the concatenation of indexing models of given content types and mixins.
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return The indexing model
     */
    public IndexingModel getIndexingModel(String[] cTypes, String[] mixins)
    {
        IndexingModel joinIndexingModel = new IndexingModel();
        
        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            if (cType != null)
            {
                IndexingModel indexingModel = cType.getIndexingModel();
                
                for (IndexingField field : indexingModel.getFields())
                {
                    joinIndexingModel.addIndexingField(field);
                }
            }
            else
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn(String.format("Trying to get indexing model for an unknown content type : '%s'.", id));
                }
            }
        }
        
        for (String id : mixins)
        {
            ContentType mixin = _getContentTypeEP().getExtension(id);
            
            if (mixin != null)
            {
                IndexingModel indexingModel = mixin.getIndexingModel();
                
                for (IndexingField field : indexingModel.getFields())
                {
                    joinIndexingModel.addIndexingField(field);
                }
            }
            else
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn(String.format("Trying to get indexing model for an unknown mixin type : '%s'.", id));
                }
            }
        }
        
        return joinIndexingModel;
    }
    
    /**
     * Copy the elements of metadata set into a metadata set of destination,
     * only if the elements are not already presents
     * 
     * @param src The metadata set to copy
     * @param dest The metadata of destination
     */
    public void copyMetadataSetElementsIfNotExist(AbstractMetadataSetElement src, AbstractMetadataSetElement dest)
    {
        _copyMetadataSetElementsIfNotExist(src, dest, null);
    }

    private void _copyMetadataSetElementsIfNotExist(AbstractMetadataSetElement src, AbstractMetadataSetElement dest, AbstractMetadataSetElement reference)
    {
        AbstractMetadataSetElement root = reference == null ? dest : reference;

        for (AbstractMetadataSetElement elmt : src.getElements())
        {
            if (elmt instanceof MetadataDefinitionReference)
            {
                String metadataName = ((MetadataDefinitionReference) elmt).getMetadataName();
                if (!root.hasMetadataDefinitionReference(metadataName))
                {
                    dest.addElement(elmt);
                }
            }
            else if (elmt instanceof Fieldset)
            {
                Fieldset fieldset = new Fieldset();
                fieldset.setLabel(((Fieldset) elmt).getLabel());
                fieldset.setRole(((Fieldset) elmt).getRole());

                _copyMetadataSetElementsIfNotExist(elmt, fieldset, root);

                if (fieldset.getElements().size() > 0)
                {
                    dest.addElement(fieldset);
                }
            }
        }
    }
    
    /**
     * Retrieve the definition of a given content metadata value path.
     * @param metadataValuePath the metadata value path: it is separated by slashes and repeaters are valued: eg: "mycomposite/myrepeater[3]/mymetadata".
     * @param content the content.
     * @return the metadata definition or <code>null</code> if not found
     */
    public MetadataDefinition getMetadataDefinitionByMetadataValuePath(String metadataValuePath, Content content)
    {
        return getMetadataDefinitionByMetadataValuePath(metadataValuePath, content.getTypes(), content.getMixinTypes());
    }

    /**
     * Retrieve the definition of a given content metadata value path.
     * @param metadataValuePath the metadata value path: it is separated by slashes and repeaters are valued: eg: "mycomposite.myrepeater[3].mymetadata".
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return the metadata definition or <code>null</code> if not found
     */
    public MetadataDefinition getMetadataDefinitionByMetadataValuePath(String metadataValuePath, String[] cTypes, String[] mixins)
    {
        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            MetadataDefinition metadataDef = getMetadataDefinitionByMetadataValuePath(metadataValuePath, cType);
            if (metadataDef != null)
            {
                return metadataDef;
            }
        }

        for (String id : mixins)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            MetadataDefinition metadataDef = getMetadataDefinitionByMetadataValuePath(metadataValuePath, cType);
            if (metadataDef != null)
            {
                return metadataDef;
            }
        }

        return null;
    }
    
    /**
     * Retrieve the definition of a given content metadata value path.
     * @param metadataValuePath the metadata value path: it is separated by slashes and repeaters are valued: eg: "mycomposite/myrepeater[3]/mymetadata".
     * @param metadataDefHolder The metadata def holder (such as the content type)
     * @return the metadata definition or <code>null</code> if not found
     */
    private MetadataDefinition getMetadataDefinitionByMetadataValuePath(String metadataValuePath, MetadataDefinitionHolder metadataDefHolder)
    {
        String metadataName = StringUtils.substringBefore(metadataValuePath, ContentConstants.METADATA_PATH_SEPARATOR);
        String subMetadataPath = StringUtils.substringAfter(metadataValuePath, ContentConstants.METADATA_PATH_SEPARATOR);
        // Ignore the repeater entry if any (we're only browsing the model).
        metadataName = StringUtils.substringBefore(metadataName, "[");
        
        MetadataDefinition metadataDefinition = metadataDefHolder.getMetadataDefinition(metadataName);
        if (metadataDefinition != null && StringUtils.isNotBlank(subMetadataPath))
        {
            if (metadataDefinition.getType() == MetadataType.COMPOSITE)
            {
                return getMetadataDefinitionByMetadataValuePath(subMetadataPath, metadataDefinition);
            }
            else
            {
                return null;
            }
        }
        
        return metadataDefinition;
    }
    
    /**
     * Get a flat map of MetadataDefinition corresponding to a metadataset of a content
     * @param metadataSet The metadataset to get
     * @return The flat map of metadatapath and MetadataDefinition
     */
    public Set<String> getMetadataPaths(MetadataSet metadataSet)
    {
        Set<String> results = new HashSet<>();

        for (AbstractMetadataSetElement subMetadataSetElement : metadataSet.getElements())
        {
            results.addAll(getMetadataPaths(subMetadataSetElement, ""));
        }
        
        return results;
    }
    
    /**
     * Get a flat map of metadatadefinition corresponding to a metadataset of a content
     * @param metadataSet The metadataset to get
     * @param prefix The metadata path of the parent
     * @return The flat map of metadatapath and metadatadefinition
     */
    protected Set<String> getMetadataPaths(AbstractMetadataSetElement metadataSet, String prefix)
    {
        Set<String> results = new HashSet<>();
        
        MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) metadataSet;
        
        String metadataName = metadataDefRef.getMetadataName();
        
        String metadataPath = prefix + metadataName;
        results.add(metadataPath);
        
        for (AbstractMetadataSetElement subMetadataSetElement : metadataSet.getElements())
        {
            results.addAll(getMetadataPaths(subMetadataSetElement, metadataPath + ContentConstants.METADATA_PATH_SEPARATOR));
        }
        
        return results;
    }    
    
    /** 
     * Retrieve the metadata definition represented by the given path.
     * The path can represent a metadata on another content.
     * @param metadataPath the metadata path separated by '/'
     * @param content The content.
     * @return the metadata definition or null.
     */ 
    public MetadataDefinition getMetadataDefinition(String metadataPath, Content content)
    {
        List<MetadataDefinition> metadataDefinitionsByPath = getMetadataDefinitionPath(metadataPath, content);
        return metadataDefinitionsByPath.size() > 0 ? metadataDefinitionsByPath.get(metadataDefinitionsByPath.size() - 1) : null;
    }

    /**
     * Get a flat map of MetadataDefinition corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param content The content associated
     * @return The flat map of metadatapath and MetadataDefinition
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(Set<String> metadataPaths, Content content)
    {
        Map<String, MetadataDefinition> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinition(metadataPath, content));
        }
        
        return results;
    }
    
    /**
     * Get a flat map of MetadataDefinition corresponding to a metadataSet
     * @param metadataSet A metadataSet to analyse
     * @param content The content associated
     * @return The flat map of metadatapath and MetadataDefinition
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(MetadataSet metadataSet, Content content)
    {
        return getMetadataDefinitions(getMetadataPaths(metadataSet), content);
    }
    
    /** 
     * Retrieve the list of successive metadata definitions represented by the given path.
     * The path can represent a metadata on another content.
     * @param metadataPath the metadata path separated by '/'
     * @param content The content.
     * @return the list of metadata definitions, one by path element.
     */ 
    public List<MetadataDefinition> getMetadataDefinitionPath(String metadataPath, Content content)
    {
        return getMetadataDefinitionPath(metadataPath, content.getTypes(), content.getMixinTypes());
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param content The content associated
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(Set<String> metadataPaths, Content content)
    {
        Map<String, List<MetadataDefinition>> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinitionPath(metadataPath, content));
        }
        
        return results;
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a metadataset
     * @param metadataSet A metadataset to analyse
     * @param content The content associated
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(MetadataSet metadataSet, Content content)
    {
        return getMetadataDefinitionsPaths(getMetadataPaths(metadataSet), content);
    }
    
    /** 
     * Retrieve the metadata definition represented by the given path.
     * The path can represent a metadata on another content.
     * @param metadataPath the metadata path separated by '/'
     * @param cTypes The content types.
     * @param mixins The content mixins types.
     * @return the metadata definition or null.
     */ 
    public MetadataDefinition getMetadataDefinition(String metadataPath, String[] cTypes, String[] mixins)
    {
        List<MetadataDefinition> metadataDefinitionsByPath = getMetadataDefinitionPath(metadataPath, cTypes, mixins);
        return metadataDefinitionsByPath.size() > 0 ? metadataDefinitionsByPath.get(metadataDefinitionsByPath.size() - 1) : null;
    }

    /** 
     * Get a flat map of MetadataDefinition corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param cTypes The content types.
     * @param mixins The content mixins types.
     * @return The flat map of metadatapath and MetadataDefinition
     */ 
    public Map<String, MetadataDefinition> getMetadataDefinitions(Set<String> metadataPaths, String[] cTypes, String[] mixins)
    {
        Map<String, MetadataDefinition> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinition(metadataPath, cTypes, mixins));
        }
        
        return results;
    }
    
    /** 
     * Get a flat map of MetadataDefinition corresponding to a metadataset
     * @param metadataSet A metadataset to analyse
     * @param cTypes The content types.
     * @param mixins The content mixins types.
     * @return The flat map of metadatapath and MetadataDefinition
     */ 
    public Map<String, MetadataDefinition> getMetadataDefinitions(MetadataSet metadataSet, String[] cTypes, String[] mixins)
    {
        return getMetadataDefinitions(getMetadataPaths(metadataSet), cTypes, mixins);
    }
    
    /**
     * Get a flat map of MetadataDefinition corresponding to the required predicate (boolean-valued function)
     *  For example, to get all metadata definitions of type CONTENT, we can do:
     *      getMetadataDefinitions(contentType, m -&gt; m.getType() == MetadataType.CONTENT)
     *      
     * @param metaDefHolder The metadata definition holder
     * @param predicate The predicate (ex. m -&gt; m.getType() == MetadataType.CONTENT)
     * @return  The flat map of metadata's path and their definition
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(MetadataDefinitionHolder metaDefHolder, Predicate<MetadataDefinition> predicate)
    {
        Map<String, MetadataDefinition> metaDefs = new HashMap<>();
        
        Set<String> metadataNames = metaDefHolder.getMetadataNames();
        for (String metadataName : metadataNames)
        {
            MetadataDefinition metadataDef = metaDefHolder.getMetadataDefinition(metadataName);
            if (predicate.test(metadataDef))
            {
                metaDefs.put(metadataDef.getId(), metadataDef);
            }
            
            if (metadataDef.getType() == MetadataType.COMPOSITE || metadataDef instanceof RepeaterDefinition)
            {
                metaDefs.putAll(getMetadataDefinitions(metadataDef, predicate));
            }
        }
        
        return metaDefs;
    }
    
    /** 
     * Retrieve the list of successive metadata definitions represented by the given path.
     * The path can represent a metadata on another content.
     * @param metadataPath the metadata path separated by '/'
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return the metadata definition or <code>null</code> if not found
     */
    public List<MetadataDefinition> getMetadataDefinitionPath(String metadataPath, String[] cTypes, String[] mixins)
    {
        String[] allContentTypes = ArrayUtils.addAll(cTypes, mixins);
        
        for (String cTypeId : allContentTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(cTypeId);
            if (cType != null)
            {
                List<MetadataDefinition> metaDefs = getMetadataDefinitionPath(metadataPath, cType);
                if (!metaDefs.isEmpty())
                { 
                    return metaDefs;
                }
            }
            else
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn("Unknown content type identifier : " + cTypeId);
                }
            }
        }
        
        return Collections.emptyList();
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(Set<String> metadataPaths, String[] cTypes, String[] mixins)
    {
        Map<String, List<MetadataDefinition>> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinitionPath(metadataPath, cTypes, mixins));
        }
        
        return results;
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a metadataset
     * @param metadataSet A metadataset to analyse
     * @param cTypes The id of content types
     * @param mixins The id of mixins
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(MetadataSet metadataSet, String[] cTypes, String[] mixins)
    {
        return getMetadataDefinitionsPaths(getMetadataPaths(metadataSet), cTypes, mixins);
    }
    
    /** 
     * Retrieves a metadata definition from a path. The metadata can be defined in a referenced or sub content.
     * @param metadataPath the metadata path separated by '/'
     * @param initialContentType The initial content type to start the search
     * @return the metadata definition or <code>null</code> if not found 
     */ 
    public MetadataDefinition getMetadataDefinition(String metadataPath, ContentType initialContentType)
    {
        List<MetadataDefinition> metadataDefinitionsByPath = getMetadataDefinitionPath(metadataPath, initialContentType);
        return metadataDefinitionsByPath.size() > 0 ? metadataDefinitionsByPath.get(metadataDefinitionsByPath.size() - 1) : null;
    }
    
    /**
     * Get a flat map of MetadataDefinition corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param initialContentType The initial content type to start the search
     * @return The flat map of metadatapath and MetadataDefinition
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(Set<String> metadataPaths, ContentType initialContentType)
    {
        Map<String, MetadataDefinition> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinition(metadataPath, initialContentType));
        }
        
        return results;
    }

    /**
     * Get a flat map of MetadataDefinition corresponding to a metadataset
     * @param metadataSet A metadataset to analyse
     * @param initialContentType The initial content type to start the search
     * @return The flat map of metadatapath and MetadataDefinition
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(MetadataSet metadataSet, ContentType initialContentType)
    {
        return getMetadataDefinitions(getMetadataPaths(metadataSet), initialContentType);
    }
    
    /** 
     * Retrieve the list of successive metadata definitions represented by the given path.
     * The path can represent a metadata on another content.
     * @param initialContentType The initial content type to start the search
     * @param metadataPath the metadata path separated by '/'
     * @return the list of metadata definitions, one by path element.
     */ 
    public List<MetadataDefinition> getMetadataDefinitionPath(String metadataPath, ContentType initialContentType)
    {
        List<MetadataDefinition> definitions = new ArrayList<>();
        
        String[] pathSegments = StringUtils.split(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
        
        if (pathSegments.length > 0)
        {
            MetadataDefinition metadataDef = initialContentType.getMetadataDefinition(pathSegments[0]);
            
            if (metadataDef != null)
            {
                definitions.add(metadataDef);
            }
            else
            {
                return Collections.emptyList();
            }
            
            for (int i = 1; i < pathSegments.length; i++)
            {
                if (metadataDef.getType() == MetadataType.CONTENT || metadataDef.getType() == MetadataType.SUB_CONTENT)
                {
                    String refCTypeId = metadataDef.getContentType();
                    if (refCTypeId != null && _getContentTypeEP().hasExtension(refCTypeId))
                    {
                        ContentType refCType = _getContentTypeEP().getExtension(refCTypeId);
                        
                        List<MetadataDefinition> followingDefs = getMetadataDefinitionPath(StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, i, pathSegments.length), refCType);
                        if (CollectionUtils.isEmpty(followingDefs))
                        {
                            return Collections.emptyList();
                        }
                        definitions.addAll(followingDefs);
                        
                        return definitions;
                    }
                    else if ("title".equals(pathSegments[i]))
                    {
                        // No specific content type: allow only title.
                        definitions.add(getTitleMetadataDefinition());
                        return definitions;
                    }
                    else
                    {
                        return Collections.emptyList();
                    }
                }
                else
                {
                    metadataDef = metadataDef.getMetadataDefinition(pathSegments[i]);
                    if (metadataDef != null)
                    {
                        definitions.add(metadataDef);
                    }
                    else
                    {
                        return Collections.emptyList();
                    }
                }
            }
        }
        
        return definitions;
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a set of metadata paths
     * @param metadataPaths A set of metadata path to analyse
     * @param initialContentType The initial content type to start the search
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(Set<String> metadataPaths, ContentType initialContentType)
    {
        Map<String, List<MetadataDefinition>> results = new HashMap<>();
        
        for (String metadataPath : metadataPaths)
        {
            results.put(metadataPath, getMetadataDefinitionPath(metadataPath, initialContentType));
        }
        
        return results;
    }
    
    /**
     * Get a flat map of MetadataDefinition path corresponding to a metadataSet
     * @param metadataSet A semetadataSet to analyse
     * @param initialContentType The initial content type to start the search
     * @return The flat map of metadatapath and corresponding list of MetadataDefinition path
     */
    public Map<String, List<MetadataDefinition>> getMetadataDefinitionsPaths(MetadataSet metadataSet, ContentType initialContentType)
    {
        return getMetadataDefinitionsPaths(getMetadataPaths(metadataSet), initialContentType);
    }
    
    /**
     * Determines if the given content type can be added to content
     * 
     * @param content The content
     * @param cTypeId The id of content type
     * @return <code>true</code> if the content type is compatible with content
     */
    public boolean isCompatibleContentType(Content content, String cTypeId)
    {
        String[] currentContentTypes = ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());

        ArrayList<String> cTypes = new ArrayList<>(Arrays.asList(currentContentTypes));
        cTypes.add(cTypeId);

        try
        {
            getMetadataDefinitions(cTypes.toArray(new String[cTypes.size()]));
            return true;
        }
        catch (ConfigurationException e)
        {
            return false;
        }
    }

    /**
     * Retrieves all definitions of a metadata resulting of the concatenation of
     * metadata of given content types.
     * 
     * @param cTypes The id of content types
     * @return the metadata definitions
     * @throws ConfigurationException if an error occurred
     */
    public Map<String, MetadataDefinition> getMetadataDefinitions(String[] cTypes) throws ConfigurationException
    {
        Map<String, MetadataDefinition> metadata = new LinkedHashMap<>();

        for (String id : cTypes)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            for (String name : cType.getMetadataNames())
            {
                MetadataDefinition definition = cType.getMetadataDefinition(name);

                if (metadata.containsKey(name))
                {
                    if (!definition.getReferenceContentType().equals(metadata.get(name).getReferenceContentType()))
                    {
                        // The definition does not provide from a common
                        // ancestor
                        throw new ConfigurationException("The metadata '" + name + "' defined in content-type '" + id + "' is already defined in another co-super-type '"
                                + metadata.get(name).getReferenceContentType() + "'");
                    }
                    continue;
                }

                metadata.put(name, definition);
            }
        }

        return metadata;
    }
    
    /**
     * Retrieves the common metadata definitions for a list of content types
     * @param cTypeIds The list of content types to consider
     * @param metadataSetName The metadata set name to list metadata
     * @param isEdition Is the metadata set for edition (or for view)
     * @return The map of metadata definition. Key are the metadata path in the content type
     */
    public Map<String, MetadataDefinition> getCommonMetadataDefinitions(Collection<String> cTypeIds, String metadataSetName, boolean isEdition)
    {
        Map<String, MetadataDefinition> commonMetadataDefinitions = null;
        
        for (String cTypeId : cTypeIds)
        {
            ContentType cType = _getContentTypeEP().getExtension(cTypeId);
            AbstractMetadataSetElement metadataSetElement = _getMetadataSet(cType, metadataSetName, isEdition);
            
            Map<String, MetadataDefinition> accumulator = new LinkedHashMap<>();
            if (metadataSetElement != null)
            {
                _getMetadataDefinitionsAcc(accumulator, metadataSetElement, "", cType);
            }
            
            if (commonMetadataDefinitions == null)
            {
                commonMetadataDefinitions = new LinkedHashMap<>();
                for (String name : accumulator.keySet())
                {
                    commonMetadataDefinitions.put(name, accumulator.get(name));
                }
            }
            else
            {
                // only retains common metadata (performs a set intersection)
                commonMetadataDefinitions.keySet().retainAll(accumulator.keySet());
            }
        }
        
        return commonMetadataDefinitions != null ? commonMetadataDefinitions : Collections.emptyMap();
    }
    
    /**
     * Populate the accumulator with the metadata definition
     * @param internalAcc the accumulator of metadata definition
     * @param metadataSetElement the metadata set of the content
     * @param prefix the path prefix preceding the names of the metadata
     * @param metaDefHolder the holder of the metadata definitions for the content
     */
    protected void _getMetadataDefinitionsAcc(Map<String, MetadataDefinition> internalAcc, AbstractMetadataSetElement metadataSetElement, String prefix, MetadataDefinitionHolder metaDefHolder)
    {
        if (metadataSetElement instanceof MetadataDefinitionReference)
        {
            MetadataDefinitionReference metadataDefRef = (MetadataDefinitionReference) metadataSetElement;
            String subMetadataName = metadataDefRef.getMetadataName();
            MetadataDefinition subMetadataDef = metaDefHolder.getMetadataDefinition(subMetadataName);

            if (subMetadataDef != null)
            {
                if (MetadataType.COMPOSITE.equals(subMetadataDef.getType()))
                {
                    for (AbstractMetadataSetElement subElement : metadataSetElement.getElements())
                    {
                        String path = prefix + subMetadataName;
                        internalAcc.put(path, subMetadataDef);
                        _getMetadataDefinitionsAcc(internalAcc, subElement, path + "/", subMetadataDef);
                    }
                }
                else
                {
                    String path = prefix + subMetadataName;
                    internalAcc.put(path, subMetadataDef);
                }
            }
        }
        else
        {
            for (AbstractMetadataSetElement subElement : metadataSetElement.getElements())
            {
                _getMetadataDefinitionsAcc(internalAcc, subElement, prefix, metaDefHolder);
            }
        }
    }
    
    /**
     * Get the metadataset of a content given the parameters
     * @param contentType The content type to consider
     * @param metadataSetName The metadata set to get (that list the metadata to consider)
     * @param isEdition Is the metadata set for edition (or for view)
     * @return The metadataset
     */
    protected MetadataSet _getMetadataSet(ContentType contentType, String metadataSetName, boolean isEdition)
    {
        String name = metadataSetName;
        if (StringUtils.isBlank(name))
        {
            name = "main";
        }
        
        MetadataSet metadataSet = null;
        
        if (isEdition)
        {
            metadataSet = contentType.getMetadataSetForEdition(name);
        }
        else
        {
            metadataSet = contentType.getMetadataSetForView(name);
        }
        
        return metadataSet;
    }

    /**
     * Get information on content types.<br>
     * @return A Map with content types
     */
    public Set<Map<String, Object>> getContentTypesInformations()
    {
        Set<Map<String, Object>> result = new HashSet<>();
        
        // Collect content types.
        Collection<String> allContentTypesIds = _getContentTypeEP().getExtensionsIds();
        for (String id : allContentTypesIds)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            if (cType != null)
            {
                Map<String, Object> contentTypeProperties = getContentTypeProperties(cType);
                contentTypeProperties.put("rightEvaluated", _hasRight(cType));
                result.add(contentTypeProperties);
            }
        }
        
        return result;
    }
    
    /**
     * Get information on content types.<br>
     * 
     * @param ids The id of content types to retrieve
     * @param inherited If true, the sub-types will be also returned.
     * @param checkRights If true, only content types allowed for creation will
     *            be returned
     * @param includePrivate If true, the list will include the private content types. By default the list is restricted to the public content types.
     * @param includeMixins If true the list will include the mixins content types.
     * @param includeAbstract If true the list will include the abstract content types.
     * @return A Map with retrieved, unknown, not-allowed and private content types
     */
    @Callable
    public Map<String, Object> getContentTypesList (List<String> ids, boolean inherited, boolean checkRights, boolean includePrivate, boolean includeMixins, boolean includeAbstract)
    {
        // Collect content types.
        Collection<String> allContentTypesIds = new ArrayList<>();
        if (ids == null || ids.isEmpty())
        {
            allContentTypesIds = _getContentTypeEP().getExtensionsIds();
        }
        else
        {
            for (String id : ids)
            {
                _addIfNotPresent(allContentTypesIds, id);
    
                if (inherited)
                {
                    for (String subTypeId : _getContentTypeEP().getSubTypes(id))
                    {
                        _addIfNotPresent(allContentTypesIds, subTypeId);
                    }
                }
            }
        }

        // Resolve and organize content types
        return _dispatchContentTypes(checkRights, includePrivate, includeMixins, includeAbstract, allContentTypesIds);
    }

    private Map<String, Object> _dispatchContentTypes(boolean checkRights, boolean includePrivate, boolean includeMixins, boolean includeAbstract, Collection<String> allContentTypesIds)
    {
        List<Map<String, Object>> contentTypes = new ArrayList<>();
        List<String> unknownContentTypes = new ArrayList<>();
        List<String> noRightContentTypes = new ArrayList<>();
        List<String> privateContentTypes = new ArrayList<>();
        List<String> mixinContentTypes = new ArrayList<>();
        List<String> abstractContentTypes = new ArrayList<>();

        for (String id : allContentTypesIds)
        {
            ContentType cType = _getContentTypeEP().getExtension(id);

            if (cType != null)
            {
                if (cType.isAbstract() && !includeAbstract)
                {
                    abstractContentTypes.add(id);
                }
                else if (cType.isPrivate() && !includePrivate)
                {
                    privateContentTypes.add(id);
                }
                else if (cType.isMixin() && !includeMixins)
                {
                    mixinContentTypes.add(id);
                }
                else if (!checkRights || _hasRight(cType))
                {
                    contentTypes.add(getContentTypeProperties(cType));
                }
                else
                {
                    noRightContentTypes.add(id);
                }
            }
            else
            {
                unknownContentTypes.add(id);
            }
        }
        
        Map<String, Object> result = new HashMap<>();

        result.put("contentTypes", contentTypes);
        result.put("noRightContentTypes", noRightContentTypes);
        result.put("unknownContentTypes", unknownContentTypes);
        result.put("privateContentTypes", privateContentTypes);
        result.put("mixinContentTypes", mixinContentTypes);
        result.put("abstractContentTypes", abstractContentTypes);

        return result;
    }

    /**
     * Get the content type properties
     * 
     * @param contentType The content type
     * @return The content type properties
     */
    public Map<String, Object> getContentTypeProperties(ContentType contentType)
    {
        Map<String, Object> infos = new HashMap<>();

        infos.put("id", contentType.getId());
        infos.put("label", contentType.getLabel());
        infos.put("description", contentType.getDescription());
        infos.put("defaultTitle", contentType.getDefaultTitle());
        infos.put("iconGlyph", contentType.getIconGlyph());
        infos.put("iconDecorator", contentType.getIconDecorator());
        infos.put("iconSmall", contentType.getSmallIcon());
        infos.put("iconMedium", contentType.getMediumIcon());
        infos.put("iconLarge", contentType.getLargeIcon());
        infos.put("right", contentType.getRight());
        infos.put("isMultilingual", contentType.isMultilingual());
        infos.put("isSimple", contentType.isSimple());
        infos.put("isPrivate", contentType.isPrivate());
        infos.put("isAbstract", contentType.isAbstract());
        infos.put("isReferenceTable", contentType.isReferenceTable());
        infos.put("isMixin", contentType.isMixin());
        infos.put("superTypes", contentType.getSupertypeIds());
        infos.put("tags", contentType.getTags());
        infos.put("parentMetadataName", Optional.ofNullable(contentType.getParentMetadata()).map(MetadataDefinition::getId).orElse(""));
        
        return infos;
    }

    /**
     * Test if the current user has the right needed by the content type to create a content.
     * @param contentType The content type
     * @return true if the user has the right needed, false otherwise.
     */
    protected boolean _hasRight(ContentType contentType)
    {
        boolean hasRight = false;

        String right = contentType.getRight();

        if (right == null)
        {
            hasRight = true;
        }
        else
        {
            UserIdentity user = _userProvider.getUser();
            hasRight = _rightManager.hasRight(user, right, "/cms") == RightResult.RIGHT_ALLOW || _rightManager.hasRight(user, right, _rootContentHelper.getRootContent()) == RightResult.RIGHT_ALLOW;
        }

        return hasRight;
    }

    private void _addIfNotPresent(Collection<String> collection, String value)
    {
        if (!collection.contains(value))
        {
            collection.add(value);
        }
    }

    /**
     * Determine whether a metadata can be read at this time.
     * 
     * @param metadataDef the metadata definition
     * @param content The content where metadata is to be read on.
     * @return <code>true</code> if the current user is allowed to read the
     *         metadata of this content.
     * @throws AmetysRepositoryException if an error occurs while accessing the
     *             content.
     */
    public boolean canRead(Content content, MetadataDefinition metadataDef)
    {
        String id = metadataDef.getReferenceContentType();
        ContentType cType = _getContentTypeEP().getExtension(id);
        return cType.canRead(content, metadataDef);
    }

    /**
     * Determine whether a metadata can be read at this time.
     * 
     * @param metadataDef the metadata definition
     * @param content The content where metadata is to be read on.
     * @return <code>true</code> if the current user is allowed to read the
     *         metadata of this content.
     * @throws AmetysRepositoryException if an error occurs while accessing the
     *             content.
     */
    public boolean canWrite(Content content, MetadataDefinition metadataDef)
    {
        String id = metadataDef.getReferenceContentType();
        ContentType cType = _getContentTypeEP().getExtension(id);
        return cType.canWrite(content, metadataDef);
    }

    /**
     * Get the id of content type to use for rendering
     * 
     * @param content The content
     * @return the id of dynamic or standard content type
     */
    public String getContentTypeIdForRendering(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicContentType != null)
        {
            return dynamicContentType.getId();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getId() : StringUtils.EMPTY;
    }

    /**
     * Get the plugin name of content type to use for rendering
     * 
     * @param content The content
     * @return the plugin name of dynamic or standard content type
     */
    public String getContentTypePluginForRendering(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicContentType != null)
        {
            return dynamicContentType.getPluginName();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getPluginName() : StringUtils.EMPTY;
    }

    /**
     * Retrieves the label of the content type.
     * 
     * @param content The content
     * @return the label.
     */
    public I18nizableText getContentTypeLabel(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicContentType != null)
        {
            return dynamicContentType.getLabel();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getLabel() : new I18nizableText(StringUtils.EMPTY);
    }

    /**
     * Retrieves the description of the content type.
     * 
     * @param content The content
     * @return the label.
     */
    public I18nizableText getContentTypeDescription(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicContentType != null)
        {
            return dynamicContentType.getDescription();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getDescription() : new I18nizableText(StringUtils.EMPTY);
    }

    /**
     * Retrieves the default title of the content type.
     * 
     * @param content The content
     * @return the label.
     */
    public I18nizableText getContentTypeDefaultTitle(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicContentType != null)
        {
            return dynamicContentType.getDefaultTitle();
        }

        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getDefaultTitle() : new I18nizableText(StringUtils.EMPTY);
    }

    /**
     * Retrieves the category of the content type.
     * 
     * @param content The content
     * @return the label.
     */
    public I18nizableText getContentTypeCategory(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getCategory();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getCategory() : new I18nizableText(StringUtils.EMPTY);
    }
    
    /**
     * Retrieves the CSS class to use as glyph icon of the content
     * @param content The content
     * @return the glyph
     */
    public String getIconGlyph(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getIconGlyph();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getIconGlyph() : null;
    }
    
    /**
     * Retrieves the CSS class to use as decorator above the main icon
     * @param content The content
     * @return the decorator CSS class name
     */
    public String getIconDecorator(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getIconDecorator();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getIconDecorator() : null;
    }

    /**
     * Retrieves the URL of the icon without the context path.
     * 
     * @param content The content
     * @return the icon URL for the small image 16x16.
     */
    public String getSmallIcon(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getSmallIcon();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getSmallIcon() : StringUtils.EMPTY;
    }

    /**
     * Retrieves the URL of the icon without the context path.
     * 
     * @param content The content
     * @return the icon URL for the medium image 32x32.
     */
    public String getMediumIcon(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getMediumIcon();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getMediumIcon() : StringUtils.EMPTY;
    }

    /**
     * Retrieves the URL of the icon without the context path.
     * 
     * @param content The content
     * @return the icon URL for the large image 48x48.
     */
    public String getLargeIcon(Content content)
    {
        DynamicContentTypeDescriptor dynamicCTDescriptor = _dynamicCTDescriptorEP.getMatchingDescriptor(content.getTypes(), content.getMixinTypes());
        if (dynamicCTDescriptor != null)
        {
            return dynamicCTDescriptor.getLargeIcon();
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getLargeIcon() : StringUtils.EMPTY;
    }

    /**
     * Get the content type which determines the content icons and rendering
     * 
     * @param content The content
     * @return The main content type
     */
    public ContentType getFirstContentType(Content content)
    {
        TreeSet<ContentType> treeSet = new TreeSet<>(new ContentTypeComparator());

        for (String id : content.getTypes())
        {
            ContentType contentType = _getContentTypeEP().getExtension(id);
            if (contentType != null)
            {
                treeSet.add(contentType);
            }
            else
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn(String.format("Trying to get an unknown content type : '%s'.", id));
                }
            }
        }
        
        return !treeSet.isEmpty() ? treeSet.first() : null;
    }
    
    /**
     * Get the metadata definition for the "title" standard metadata.
     * @return The standard title metadata definition.
     */
    public static MetadataDefinition getTitleMetadataDefinition()
    {
        MetadataDefinition def = new MetadataDefinition();
        def.setId("title");
        def.setName("title");
        def.setLabel(new I18nizableText("plugin.cms", "PLUGINS_CMS_METADATA_TITLE_LABEL"));
        def.setDescription(new I18nizableText("plugin.cms", "PLUGINS_CMS_METADATA_TITLE_DESCRIPTION"));
        def.setType(MetadataType.STRING);
        def.setMultiple(false);
        
        return def;
    }

    class ContentTypeComparator implements Comparator<ContentType>
    {
        @Override
        public int compare(ContentType c1, ContentType c2)
        {
            I18nizableText t1 = c1.getLabel();
            I18nizableText t2 = c2.getLabel();

            String str1 = t1.isI18n() ? t1.getKey() : t1.getLabel();
            String str2 = t2.isI18n() ? t2.getKey() : t2.getLabel();

            int compareTo = str1.toString().compareTo(str2.toString());
            if (compareTo == 0)
            {
                // Content types have same keys but there are not equals, so do
                // not return 0 to add it in TreeSet
                // Indeed, in a TreeSet implementation two elements that are
                // equal by the method compareTo are, from the standpoint of the
                // set, equal
                return 1;
            }
            return compareTo;
        }
    }

    private String _getCacheIdentifier(String[] contentTypes, String[] mixins)
    {
        Arrays.sort(contentTypes);
        String name = StringUtils.join(contentTypes, ";");

        if (mixins.length > 0)
        {
            Arrays.sort(mixins);
            name += ";";
            name += StringUtils.join(mixins, ";");
        }

        return name;
    }
}