/*
 *  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.stream.Collectors;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
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.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.LifecycleHelper;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

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.cms.repository.ContentAttributeTypeExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
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.core.impl.cache.AbstractCacheKey;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.DefinitionContext;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemContainer;
import org.ametys.runtime.model.ViewParser;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ModelItemTypeConstants;

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

    /** Archived content type */
    public static final String ARCHIVED_CONTENT_TYPE = "org.ametys.cms.ArchivedContent";

    private static final String __VIEW_METADATASET = ContentTypesHelper.class.getName() + "$view.metadataset";
    
    private static final String __EDITION_METADATASET = ContentTypesHelper.class.getName() + "$edition.metadataset";
    
    private static final String __VIEW_CACHE = ContentTypesHelper.class.getName() + "$view.cache";

    /** 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;
    /** The extension point with the available types for contents */
    protected ContentAttributeTypeExtensionPoint _contentAttributeTypeExtensionPoint;
    
    private DynamicContentTypeDescriptorExtentionPoint _dynamicCTDescriptorEP;

    private Context _context;
    private ServiceManager _smanager;

    private AbstractCacheManager _cacheManager;
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _smanager = smanager;
        _userProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _rightManager = (RightManager) smanager.lookup(RightManager.ROLE);
        _rootContentHelper = (RootContentHelper) smanager.lookup(RootContentHelper.ROLE);
        _contentAttributeTypeExtensionPoint = (ContentAttributeTypeExtensionPoint) smanager.lookup(ContentAttributeTypeExtensionPoint.ROLE);
        _cacheManager = (AbstractCacheManager) smanager.lookup(AbstractCacheManager.ROLE);
    }

    /**
     * Initialize
     */
    @Override
    public void initialize()
    {
        _createCaches();
    }
    
    /**
     * Creates the caches
     */
    protected void _createCaches()
    {
        _cacheManager.createMemoryCache(__VIEW_METADATASET, 
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_VIEW_METADATASET_LABEL"),
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_VIEW_METADATASET_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__EDITION_METADATASET, 
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_EDITION_METADATASET_LABEL"),
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_EDITION_METADATASET_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__VIEW_CACHE, 
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_VIEW_LABEL"),
                new I18nizableText("plugin.cms", "PLUGINS_CMS_CACHE_VIEW_DESCRIPTION"),
                true,
                null);
    }
    
    private DynamicContentTypeDescriptorExtentionPoint _getDynamicContentTypeDescriptorExtentionPoint()
    {
        if (_dynamicCTDescriptorEP == null)
        {
            try
            {
                _dynamicCTDescriptorEP = (DynamicContentTypeDescriptorExtentionPoint) _smanager.lookup(DynamicContentTypeDescriptorExtentionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                throw new IllegalStateException(e);
            }
        }
        return _dynamicCTDescriptorEP;
    }

    @Override
    public void dispose()
    {
        _getCacheForView().invalidateAll();
        _getCacheForEdition().invalidateAll();
        _getViewCache().invalidateAll();
    }
    
    /**
     * 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 identifiers of the content types common ancestors
     * @param contentTypeIds The identifiers of the content types to compare
     * @return The identifiers of common ancestors
     */
    public Set<String> getCommonAncestors(Collection<String> contentTypeIds)
    {
        Set<String> commonAncestors = new HashSet<>();
        
        // Get ancestors of each content type
        List<Collection<String>> superTypeIdsByCType = new ArrayList<>();
        for (String contentTypeId : contentTypeIds)
        {
            Set<String> superTypeIds = new HashSet<>();

            superTypeIds.add(contentTypeId);
            superTypeIds.addAll(getAncestors(contentTypeId));

            superTypeIdsByCType.add(superTypeIds);
        }
        
        // Make the intersection of all the ancestors collections
        if (!superTypeIdsByCType.isEmpty())
        {
            Iterator<Collection<String>> superTypeIdsByCTypeIt = superTypeIdsByCType.iterator();
            commonAncestors.addAll(superTypeIdsByCTypeIt.next());
            while (superTypeIdsByCTypeIt.hasNext() && !commonAncestors.isEmpty())
            {
                commonAncestors.retainAll(superTypeIdsByCTypeIt.next());
            }
        }
        
        // Remove ancestors of ancestors: their attributes will be given by the first one
        commonAncestors = removeAncestors(commonAncestors);
        
        return commonAncestors;
    }

    /**
     * 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;

    }
    
    /**
     * Get super type's ids for the given content type
     * The first entry contains super content types, the second one contains super mixin types 
     * 
     * @param contentTypeId The content type id to test
     * @return An array of super type's ids.
     * @throws IllegalArgumentException if the content type does not exist.
     */
    public Pair<String[], String[]> getSupertypeIds(String contentTypeId)
    {
        ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
        if (contentType == null)
        {
            throw new IllegalArgumentException("Unable to get super types of unknown content type '" + contentTypeId + "'");
        }

        List<String> superMixins = new ArrayList<>();
        List<String> superContentTypes = new ArrayList<>();
        for (String supertypeId : contentType.getSupertypeIds())
        {
            ContentType supertype = _getContentTypeEP().getExtension(supertypeId);
            if (supertype == null)
            {
                throw new IllegalArgumentException("Unable to get the unknown super type '" + supertypeId + "' for type '" + contentTypeId + "'");
            }

            if (supertype.isMixin())
            {
                superMixins.add(supertypeId);
            }
            else
            {
                superContentTypes.add(supertypeId);
            }
        }
        
        String[] superContentTypesArray = superContentTypes.toArray(new String[superContentTypes.size()]);
        String[] superMixinsArray = superMixins.toArray(new String[superMixins.size()]);
        return Pair.of(superContentTypesArray, superMixinsArray);
    }

    /**
     * Get plugin name for the given content type
     * 
     * @param contentTypeId The content type id to test
     * @return the plugin name
     * @throws IllegalArgumentException if the content type does not exist.
     */
    public String getPluginName(String contentTypeId)
    {
        ContentType cType = _getContentTypeEP().getExtension(contentTypeId);
        if (cType == null)
        {
            throw new IllegalArgumentException("Unable to get plugin name of unknown content type '" + contentTypeId + "'");
        }

        return cType.getPluginName();
    }
    
    /**
     * 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;
    }
    
    /**
     * Get all views resulting of the concatenation of views of given content types and mixins.
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @return The views
     */
    public Map<String, View> getViews(String[] contentTypeIds, String[] mixinIds)
    {
        return getViews(contentTypeIds, mixinIds, Collections.emptySet());
    }
    
    /**
     * Get all views resulting of the concatenation of views of given content types and mixins.
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @param viewNamesToAvoid names of views that should not be managed
     * @return The views
     */
    public Map<String, View> getViews(String[] contentTypeIds, String[] mixinIds, Set<String> viewNamesToAvoid)
    {
        Map<String, View> views = new HashMap<>();
        
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
            for (String viewName : contentType.getViewNames())
            {
                if (!viewNamesToAvoid.contains(viewName) && !views.containsKey(viewName))
                {
                    views.put(viewName, getView(viewName, contentTypeIds, mixinIds));
                }
            }
        }
        
        return views;
    }
    
    /**
     * Get the view for view resulting of the concatenation of views of the given content.
     * @param viewName the name of the view to retrieve
     * @param content the given content
     * @return The view or null if none matches.
     */
    public View getView(String viewName, Content content)
    {
        return getView(viewName, content.getTypes(), content.getMixinTypes());
    }
    
    /**
     * Get the view for view resulting of the concatenation of views of the given content types and mixins.
     * @param viewName the name of the view to retrieve
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @return The view or null if none matches.
     */
    public View getView(String viewName, String[] contentTypeIds, String[] mixinIds)
    {
        CacheKey cacheKey = CacheKey.of(Set.of(contentTypeIds), Set.of(mixinIds), viewName);
        return _getViewCache().get(cacheKey,  __ -> _computeView(viewName, contentTypeIds, mixinIds));
    }
    
    /**
     * Get the view for view resulting for a given content
     * @param viewName the name of the view to retrieve. If null or empty, fallback view will be used.
     * @param fallbackViewName the name of the view to retrieve if the initial was not found. If null or empty, "main" view view will be used as fallback view.
     * @param content the content
     * @return The view or null if none matches.
     */
    public View getViewWithFallback(String viewName, String fallbackViewName, Content content)
    {
        return getViewWithFallback(viewName, fallbackViewName, content.getTypes(), content.getMixinTypes());
    }
    
    /**
     * Get the view for view resulting of the concatenation of views of the given content types and mixins.
     * @param viewName the name of the view to retrieve. If null or empty, fallback view will be used.
     * @param fallbackViewName the name of the view to retrieve if the initial was not found. If null or empty, "main" view view will be used as fallback view.
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @return The view or null if none matches.
     */
    public View getViewWithFallback(String viewName, String fallbackViewName, String[] contentTypeIds, String[] mixinIds)
    {
        String usedFallbackViewName = fallbackViewName;
        if (StringUtils.isBlank(fallbackViewName))
        {
            usedFallbackViewName = "main";
        }
        
        // Use the fallbackViewName if no viewName is provided
        String usedViewName = viewName;
        if (StringUtils.isBlank(usedViewName))
        {
            usedViewName = usedFallbackViewName;
        }
        
        View view = getView(usedViewName, contentTypeIds, mixinIds);
        
        if (view == null && !usedViewName.equals(usedFallbackViewName))
        {
            view = getView(usedFallbackViewName, contentTypeIds, mixinIds);
        }
        
        return view;
    }

    /**
     * Converts the view with the given name in a JSON Map
     * @param contentTypeId the content type identifier
     * @param viewName the name of the view to convert
     * @param isEdition <code>true</code> if the JSON result is used for edition purposes (configure a form panel, ...) <code>false</code> otherwise
     * @return the view as a JSON Map
     * @throws ProcessingException if an error occurs when converting the view
     */
    @Callable
    public Map<String, Object> getViewAsJSON(String contentTypeId, String viewName, boolean isEdition) throws ProcessingException
    {
        Map<String, Object> json = new LinkedHashMap<>();
        
        ContentType contentType = _cTypeEP.getExtension(contentTypeId);
        json.put("contentType", Map.of(
                "id", contentTypeId,
                "label", contentType.getLabel(),
                "defaultTitle", contentType.getDefaultTitle()));
        
        View view = contentType.getView(viewName);
        if (view != null)
        {
            json.put("view", view.toJSON(DefinitionContext.newInstance().withEdition(isEdition)));
        }
        else
        {
            if (getLogger().isWarnEnabled())
            {
                getLogger().warn(String.format("Unknown view '%s' for content type '%s'", viewName, contentType.getId()));
            }
        }
        
        return json;
    }
    
    /**
     * Converts the title view in a JSON Map
     * @param contentTypeId the content type identifier
     * @param isEdition <code>true</code> if the JSON result is used for edition purposes (configure a form panel, ...) <code>false</code> otherwise
     * @return the view as a JSON Map
     * @throws ProcessingException if an error occurs when converting the view
     */
    @Callable
    public Map<String, Object> getTitleViewAsJSON(String contentTypeId, boolean isEdition) throws ProcessingException
    {
        Map<String, Object> json = new LinkedHashMap<>();
        
        ContentType contentType = _cTypeEP.getExtension(contentTypeId);
        json.put("contentType", Map.of(
                "id", contentTypeId,
                "label", contentType.getLabel(),
                "defaultTitle", contentType.getDefaultTitle()));
        
        View titleView = new View();
        
        ModelItem modelItem = contentType.getModelItem("title");
        ViewElement viewElement = new ViewElement();
        viewElement.setDefinition((ElementDefinition) modelItem);
        titleView.addViewItem(viewElement);
        
        json.put("view", titleView.toJSON(DefinitionContext.newInstance().withEdition(isEdition)));
        return json;
    }
    
    private View _computeView(String viewName, String[] contentTypeIds, String[] mixinIds)
    {
        List<View> views = new ArrayList<>();
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);

            View view = contentType.getView(viewName);
            if (view != null)
            {
                views.add(view);
            }
        }

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

            View view = mixin.getView(viewName);
            if (view != null)
            {
                views.add(view);
            }
        }

        return joinViews(views);
    }
    
    /**
     * Parses the view of the given content type from the configurations
     * @param contentType the content type
     * @param viewConfigurations the view's configurations, indexed by the content types defining this view
     * @return the parsed view
     * @throws ConfigurationException if the configuration is invalid
     */
    public View parseView(ContentType contentType, Map<ContentType, Configuration> viewConfigurations) throws ConfigurationException
    {
        List<View> views = new ArrayList<>();
        for (Map.Entry<ContentType, Configuration> viewConfigurationById : viewConfigurations.entrySet())
        {
            ContentType originalContentType = viewConfigurationById.getKey();
            Configuration viewConfiguration = viewConfigurationById.getValue();

            ViewParser parser;
            if (ContentType.VIEW_TAG_NAME.equals(viewConfiguration.getName()))
            {
                parser = new ContentTypeViewParser(contentType, originalContentType);
            }
            else
            {
                parser = new ContentTypeViewParser(contentType, originalContentType, Optional.of(ContentType.GROUP_TAG_NAME_WITH_LEGACY_SYNTAX), Optional.of(ContentType.ATTRIBUTE_REF_TAG_NAME_WITH_LEGACY_SYNTAX), false);
            }
            try
            {
                LifecycleHelper.setupComponent(parser, getLogger(), _context, _smanager, null);

                View view = parser.parseView(viewConfiguration);
                views.add(view);
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to initialize the content view parser", e);
            }
            finally
            {
                LifecycleHelper.dispose(parser);
            }
        }

        return joinViews(views);
    }
    
    /**
     * Creates a view that is a jointure between all the given views
     * @param views the views to join
     * @return the joined view
     */
    public View joinViews(List<View> views)
    {
        if (views.isEmpty())
        {
            return null;
        }
        
        View joinView = new View();
        for (View view : views)
        {
            joinView.includeView(view);

            if (joinView.getName() == null)
            {
                joinView.setName(view.getName());
                joinView.setLabel(view.getLabel());
                joinView.setDescription(view.getDescription());
                joinView.setInternal(view.isInternal());
                joinView.setIconGlyph(view.getIconGlyph());
                joinView.setIconDecorator(view.getIconDecorator());
                joinView.setSmallIcon(view.getSmallIcon());
                joinView.setMediumIcon(view.getMediumIcon());
                joinView.setLargeIcon(view.getLargeIcon());
            }
        }
        return joinView;
    }
    
    /**
     * Get all configurations of the views resulting of the concatenation of views of given content types and mixins.
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @return The views' configurations, indexed by view names and content type containing the configuration
     */
    Map<String, Map<ContentType, Configuration>> getViewConfigurations(String[] contentTypeIds, String[] mixinIds)
    {
        Map<String, Map<ContentType, Configuration>> viewConfigurations = new HashMap<>();
        
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
            for (String viewName : contentType.getViewNames())
            {
                viewConfigurations.computeIfAbsent(viewName, name -> new LinkedHashMap<>())
                    .putAll(getViewConfigurations(viewName, new String[] {contentTypeId}, new String[0]));
            }
        }
        
        return viewConfigurations;
    }
    
    /**
     * Get the configurations of the view resulting of the concatenation of views of given content types and mixins.
     * @param viewName the name of the view
     * @param contentTypeIds the identifiers of the content types
     * @param mixinIds the identifiers of the mixins
     * @return The views' configurations, indexed by content type containing the configuration
     */
    Map<ContentType, Configuration> getViewConfigurations(String viewName, String[] contentTypeIds, String[] mixinIds)
    {
        Map<ContentType, Configuration> viewConfigurations = new LinkedHashMap<>();
        
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
            contentType.getViewConfiguration(viewName)
                       .ifPresentOrElse(config -> viewConfigurations.put(contentType, config), 
                           () -> viewConfigurations.putAll(getViewConfigurations(viewName, contentType.getSupertypeIds(), new String[0])));
        }
        
        return viewConfigurations;
    }
    
    /**
     * 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
     * @deprecated Use {@link #getViews(String[], String[])} instead
     */
    @Deprecated
    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
     * @deprecated Use {@link #getViews(String[], String[])} instead
     */
    @Deprecated
    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.
     * @deprecated Use {@link #getView(String, String[], String[])} instead
     */
    @Deprecated
    public MetadataSet getMetadataSetForView(String metadataSetName, String[] cTypes, String[] mixins)
    {
        MetadataSet joinMetadataSet = _getCacheForView().get(
            CacheKey.of(Set.of(cTypes), Set.of(mixins), metadataSetName),
            __ -> _computeMetadataSetForView(metadataSetName, cTypes, mixins));
        return joinMetadataSet;
    }
    
    @Deprecated
    private MetadataSet _computeMetadataSetForView(String metadataSetName, String[] cTypes, String[] mixins)
    {
        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;
        }

        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
     * @deprecated Use {@link #getView(String, String[], String[])} instead
     */
    @Deprecated
    public MetadataSet getMetadataSetForEdition(String metadataSetName, String[] cTypes, String[] mixins)
    {
        MetadataSet joinMetadataSet = _getCacheForEdition().get(
            CacheKey.of(Set.of(cTypes), Set.of(mixins), metadataSetName),
            __ -> _computeMetadataSetForEdition(metadataSetName, cTypes, mixins));
        return joinMetadataSet;
    }
    
    @Deprecated
    private MetadataSet _computeMetadataSetForEdition(String metadataSetName, String[] cTypes, String[] mixins)
    {
        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;
        }
        
        return joinMetadataSet;
    }
    
    /**
     * Get the views of a content type
     * @param contentTypeId the content type id
     * @param includeInternals Set to true to include internal views.
     * @return the views' info
     */
    public List<Map<String, Object>> getViewsInfo(String contentTypeId, boolean includeInternals)
    {
        List<Map<String, Object>> views = new ArrayList<>();
        
        ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
        
        Set<String> viewNames = contentType.getViewNames(includeInternals);
        for (String viewName : viewNames)
        {
            View view = contentType.getView(viewName);
            
            Map<String, Object> viewInfos = new HashMap<>();
            viewInfos.put("name", viewName);
            viewInfos.put("label", view.getLabel());
            viewInfos.put("description", view.getDescription());
            views.add(viewInfos);
        }
        
        return views;
    }
    
    /**
     * 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
     * @deprecated Use {@link View#includeView(View)} instead
     */
    @Deprecated
    public void copyMetadataSetElementsIfNotExist(AbstractMetadataSetElement src, AbstractMetadataSetElement dest)
    {
        _copyMetadataSetElementsIfNotExist(src, dest, null);
    }

    /**
     * Copy the elements of the source to the destination if they do not exist in the reference
     * @param src the source
     * @param dest the destination
     * @param reference the reference
     * @deprecated Use {@link View#includeView(View)} instead
     */
    @Deprecated
    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);

                dest.addElement(fieldset);
            }
        }
    }
    
    /** 
     * 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.
     * @deprecated Use {@link Content#getDefinition(String)} API instead
     */
    @Deprecated
    public MetadataDefinition getMetadataDefinition(String metadataPath, Content content)
    {
        List<MetadataDefinition> metadataDefinitionsByPath = _getMetadataDefinitionPath(metadataPath, content);
        return metadataDefinitionsByPath.size() > 0 ? metadataDefinitionsByPath.get(metadataDefinitionsByPath.size() - 1) : null;
    }

    /** 
     * 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.
     * @deprecated Use {@link ContentTypesHelper#getModelItemPath(String, Content)} instead
     */
    @Deprecated
    private List<MetadataDefinition> _getMetadataDefinitionPath(String metadataPath, Content content)
    {
        return _getMetadataDefinitionPath(metadataPath, content.getTypes(), content.getMixinTypes());
    }
    
    /** 
     * 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.
     * @deprecated Use {@link ContentTypesHelper#getModelItem(String, String[], String[])} instead
     */
    @Deprecated
    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;
    }
    
    /**
     * Retrieves the model item at the given path
     * @param path path of the model item to retrieve. No matter if it is a definition or data path (with repeater entry positions)
     * @param cTypes identifiers of the content types where to search the model item
     * @param mixins identifiers of the mixins where to search the model item
     * @return the model item
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if there is no item defined at the given path in given item containers
     */
    public ModelItem getModelItem(String path, String[] cTypes, String[] mixins) throws IllegalArgumentException, UndefinedItemPathException
    {
        Collection<ContentType> contentTypes = new ArrayList<>();

        String[] allContentTypes = ArrayUtils.addAll(cTypes, mixins);
        for (String contentTypeId : allContentTypes)
        {
            if (_getContentTypeEP().hasExtension(contentTypeId))
            {
                contentTypes.add(_getContentTypeEP().getExtension(contentTypeId));
            }
            else
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn("Unknown content type identifier : " + contentTypeId);
                }
            }
        }
        
        return ModelHelper.getModelItem(path, contentTypes);
    }

    /** 
     * 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
     * @deprecated Use {@link ContentTypesHelper#getModelItemPath(String, Content)} instead
     */
    @Deprecated
    private 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();
    }
    
    /** 
     * 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 
     * @deprecated Use {@link ContentType#getModelItem(String)} instead
     */
    @Deprecated
    public MetadataDefinition getMetadataDefinition(String metadataPath, ContentType initialContentType)
    {
        List<MetadataDefinition> metadataDefinitionsByPath = _getMetadataDefinitionPath(metadataPath, initialContentType);
        return metadataDefinitionsByPath.size() > 0 ? metadataDefinitionsByPath.get(metadataDefinitionsByPath.size() - 1) : null;
    }
    
    /** 
     * 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.
     * @deprecated Use {@link ContentTypesHelper#getModelItemPath(String, ContentType)} instead
     */
    @Deprecated
    private 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;
    }
    
    /**
     * Retrieve the list of successive model items represented by the given paths, indexed by path.
     * @param paths paths of the model items to retrieve. These paths are relative to the given containers. No matter if they are definition or data paths (with repeater entry positions)
     * @param content the content
     * @return the list of successive model items, indexed by path
     * @throws IllegalArgumentException if one of the given paths is null or empty
     * @throws UndefinedItemPathException if there is no item defined at one of the given paths in given item containers
     */
    public Map<String, List<ModelItem>> getModelItemsPaths(Set<String> paths, Content content)
    {
        return ModelHelper.getAllModelItemsInPaths(paths, content.getModel());
    }
    
    /**
     * Retrieve the list of successive model items represented by the given path.
     * @param path path of the model items to retrieve. This path is relative to the given containers. No matter if it is a definition or data path (with repeater entry positions)
     * @param content the content
     * @return the list of successive model items
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if there is no item defined at the given path in given item containers
     */
    public List<ModelItem> getModelItemPath(String path, Content content) throws IllegalArgumentException, UndefinedItemPathException
    {
        return ModelHelper.getAllModelItemsInPath(path, content.getModel());
    }
    
    /**
     * Retrieve the list of successive model items represented by the given paths, indexed by path.
     * @param paths paths of the model items to retrieve. These paths are relative to the given containers. No matter if they are definition or data paths (with repeater entry positions)
     * @param contentType the content type
     * @return the list of successive model items, indexed by path
     * @throws IllegalArgumentException if one of the given paths is null or empty
     * @throws UndefinedItemPathException if there is no item defined at one of the given paths in given item containers
     */
    public Map<String, List<ModelItem>> getModelItemsPaths(Set<String> paths, ContentType contentType)
    {
        return ModelHelper.getAllModelItemsInPaths(paths, Collections.singleton(contentType));
    }
    
    /**
     * Retrieve the list of successive model items represented by the given path.
     * @param path path of the model items to retrieve. This path is relative to the given containers. No matter if it is a definition or data path (with repeater entry positions)
     * @param contentType the content type
     * @return the list of successive model items
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if there is no item defined at the given path in given item containers
     */
    public List<ModelItem> getModelItemPath(String path, ContentType contentType)
    {
        return ModelHelper.getAllModelItemsInPath(path, Collections.singleton(contentType));
    }
    
    /**
     * 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
        {
            getModelItems(cTypes.toArray(new String[cTypes.size()]));
            return true;
        }
        catch (ConfigurationException e)
        {
            return false;
        }
    }

    /**
     * Retrieves all model items of given content types.
     * @param contentTypes The identifier of the content types
     * @return the model items
     * @throws ConfigurationException if an error occurred
     */
    public Map<String, ModelItem> getModelItems(String[] contentTypes) throws ConfigurationException
    {
        Map<String, ModelItem> items = new LinkedHashMap<>();

        for (String id : contentTypes)
        {
            ContentType contentType = _getContentTypeEP().getExtension(id);

            for (ModelItem currentItem : contentType.getModelItems())
            {
                final String currentItemName = currentItem.getName();
                if (items.containsKey(currentItemName))
                {
                    ModelItem existingItem = items.get(currentItemName);
                    
                    if (!currentItem.getModel().equals(existingItem.getModel()))
                    {
                        // The definition does not provide from a common ancestor
                        throw new ConfigurationException("The metadata '" + currentItemName + "' defined in content-type '" + id + "' is already defined in another co-super-type '"
                                + existingItem.getModel() + "'");
                    }
                    continue;
                }

                items.put(currentItemName, currentItem);
            }
        }

        return items;
    }
    
    /**
     * Retrieves the common model items for a list of content types
     * @param contentTypeIds The list of content types to consider
     * @param viewName The view name to list model items
     * @return The map of model items. Key are the model item's path in the content type
     */
    public Map<String, ModelItem> getCommonModelItems(Collection<String> contentTypeIds, String viewName)
    {
        Map<String, ModelItem> commonModelItems = null;
        
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
            View view = contentType.getView(viewName);
            
            Map<String, ModelItem> accumulator = new LinkedHashMap<>();
            if (view != null)
            {
                _populateModelItemsAccumulator(accumulator, view, StringUtils.EMPTY);
            }
            
            if (commonModelItems == null)
            {
                commonModelItems = new LinkedHashMap<>();
                for (Map.Entry<String, ModelItem> accumulatorEntry : accumulator.entrySet())
                {
                    commonModelItems.put(accumulatorEntry.getKey(), accumulatorEntry.getValue());
                }
            }
            else
            {
                // only retains common attributes (performs a set intersection)
                commonModelItems.keySet().retainAll(accumulator.keySet());
            }
        }
        
        return commonModelItems != null ? commonModelItems : Collections.emptyMap();
    }
    
    /**
     * Populates the accumulator with the model items
     * @param internalAcc the accumulator of model items
     * @param viewItemContainer the view item container of the content
     * @param prefix the view item accessor path prefix
     */
    protected void _populateModelItemsAccumulator(Map<String, ModelItem> internalAcc, ViewItemContainer viewItemContainer, String prefix)
    {
        for (ViewItem viewItem : viewItemContainer.getViewItems())
        {
            String newPrefix = prefix;
            
            if (viewItem instanceof ModelViewItem)
            {
                ModelItem modelItem = ((ModelViewItem) viewItem).getDefinition();
                if (modelItem != null)
                {
                    internalAcc.put(modelItem.getPath(), modelItem);

                    if (viewItem instanceof ViewItemContainer)
                    {
                        newPrefix += ModelItem.ITEM_PATH_SEPARATOR + modelItem.getName();
                    }
                }
            }
            
            if (viewItem instanceof ViewItemContainer)
            {
                _populateModelItemsAccumulator(internalAcc, (ViewItemContainer) viewItem, newPrefix);
            }
        }
    }
    
    /**
     * Get information on content types.<br>
     * @return A Map with content types
     */
    public Set<Map<String, Object>> getContentTypesInformations()
    {
        // Collect content types.
        List<String> allContentTypesIds = _getContentTypeEP()
                .getExtensionsIds()
                .stream()
                .collect(Collectors.toList());
        return getContentTypesInformations(allContentTypesIds, true);
    }
    
    /**
     * Get the content types information as JSON
     * @param contentTypeIds the list of content type ids
     * @param withRight true to add rights to results
     * @return the list of content types information as JSON
     */
    @Callable
    public Set<Map<String, Object>> getContentTypesInformations(List<String> contentTypeIds, boolean withRight)
    {
        Set<Map<String, Object>> results = new HashSet<>();
        for (String contentTypeId : contentTypeIds)
        {
            ContentType cType = _cTypeEP.getExtension(contentTypeId);
            if (cType != null)
            {
                Map<String, Object> contentTypeProperties = getContentTypeProperties(cType);
                if (withRight)
                {
                    contentTypeProperties.put("rightEvaluated", _hasRight(cType));
                }
                results.add(contentTypeProperties);
            }
        }
        
        return results;
    }
    
    /**
     * 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", contentType.getParentAttributeDefinition()
                                                   .map(ContentAttributeDefinition::getPath)
                                                   .orElse(StringUtils.EMPTY));
        infos.put("editionMetatadaSets", contentType.getEditionMetadataSetNames(true));
        
        return infos;
    }

    /**
     * Test if the current user has the right needed by the content type to create a content.
     * @param contentTypeId The content type id
     * @return true if the user has the right needed, false otherwise.
     */
    public boolean hasRight(String contentTypeId)
    {
        return Optional.ofNullable(contentTypeId)
            .filter(_getContentTypeEP()::hasExtension)
            .map(_getContentTypeEP()::getExtension)
            .map(this::_hasRight)
            .orElse(false);
    }
    
    /**
     * 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.
     * @deprecated Use {@link AttributeDefinition#canRead(Content)} instead
     */
    @Deprecated
    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.
     * @deprecated Use {@link AttributeDefinition#canWrite(Content)} instead
     */
    @Deprecated
    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)
    {
        String dynamicContentTypeId = getDynamicContentTypeId(content.getTypes(), content.getMixinTypes());
        if (dynamicContentTypeId != null)
        {
            return dynamicContentTypeId;
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getId() : StringUtils.EMPTY;
    }

    /**
     * Get the id of the dynamic content type matching to given ones
     * @param contentTypes The content types
     * @param mixinTypes The mixins
     * @return the id of dynamic content type or null if no dynamic content type was found
     */
    public String getDynamicContentTypeId(String[] contentTypes, String[] mixinTypes)
    {
        DynamicContentTypeDescriptor dynamicContentType = _getDynamicContentTypeDescriptorExtentionPoint().getMatchingDescriptor(contentTypes, mixinTypes);
        if (dynamicContentType != null)
        {
            return dynamicContentType.getId();
        }
        
        return null;
    }

    /**
     * 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)
    {
        String dynamicContentTypePlugin = getDynamicContentTypePlugin(content.getTypes(), content.getMixinTypes());
        if (dynamicContentTypePlugin != null)
        {
            return dynamicContentTypePlugin;
        }
        
        ContentType firstContentType = getFirstContentType(content);
        return firstContentType != null ? firstContentType.getPluginName() : StringUtils.EMPTY;
    }

    /**
     * Get the plugin name of the dynamic content type matching to given ones
     * @param contentTypes The content types
     * @param mixinTypes The mixins
     * @return the plugin name of dynamic content type or null if no dynamic content type was found
     */
    public String getDynamicContentTypePlugin(String[] contentTypes, String[] mixinTypes)
    {
        DynamicContentTypeDescriptor dynamicContentType = _getDynamicContentTypeDescriptorExtentionPoint().getMatchingDescriptor(contentTypes, mixinTypes);
        if (dynamicContentType != null)
        {
            return dynamicContentType.getPluginName();
        }
        
        return null;
    }

    /**
     * Retrieves the label of the content type.
     * 
     * @param content The content
     * @return the label.
     */
    public I18nizableText getContentTypeLabel(Content content)
    {
        DynamicContentTypeDescriptor dynamicContentType = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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 = _getDynamicContentTypeDescriptorExtentionPoint().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.
     * @deprecated Use {@link ContentTypesHelper#getTitleAttributeDefinition()} instead
     */
    @Deprecated
    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;
    }
    
    /**
     * Retrieves the definition for the standard "title" attribute.
     * @return the standard "title" attribute.
     */
    public AttributeDefinition<String> getTitleAttributeDefinition()
    {
        AttributeDefinition<String> definition = new AttributeDefinition<>();
        definition.setName(Content.ATTRIBUTE_TITLE);
        definition.setLabel(new I18nizableText("plugin.cms", "PLUGINS_CMS_METADATA_TITLE_LABEL"));
        definition.setDescription(new I18nizableText("plugin.cms", "PLUGINS_CMS_METADATA_TITLE_DESCRIPTION"));
        definition.setType(_contentAttributeTypeExtensionPoint.getExtension(ModelItemTypeConstants.STRING_TYPE_ID));
        definition.setMultiple(false);
        return definition;
    }

    /**
     * Determines if the content type is an archived content type
     * @param cTypeId The id of content type
     * @return true if the content type is an org.ametys.cms.ArchivedContent
     */
    public boolean isArchivedContentType(String cTypeId)
    {
        return getAncestors(cTypeId).contains(ARCHIVED_CONTENT_TYPE);
    }
    
    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;
        }
    }

    @Deprecated
    private Cache<CacheKey, MetadataSet> _getCacheForView()
    {
        return _cacheManager.get(__VIEW_METADATASET);
    }
    
    @Deprecated
    private Cache<CacheKey, MetadataSet> _getCacheForEdition()
    {
        return _cacheManager.get(__EDITION_METADATASET);
    }
    
    private Cache<CacheKey, View> _getViewCache()
    {
        return _cacheManager.get(__VIEW_CACHE);
    }
    
    static final class CacheKey extends AbstractCacheKey
    {
        private CacheKey(Set<String> contentTypeIds, Set<String> mixinIds, String viewName)
        {
            super(contentTypeIds, mixinIds, viewName);
        }

        static CacheKey of(Set<String> contentTypeIds, Set<String> mixinIds, String viewName)
        {
            return new CacheKey(contentTypeIds, mixinIds, viewName);
        }
    }
    
}