/*
 *  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.Function;
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.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.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.data.type.ModelItemTypeExtensionPoint;
import org.ametys.cms.repository.Content;
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.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.ModelHelper.ConfigurationAndPluginName;
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.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
{
    /** 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 ModelItemTypeExtensionPoint _contentAttributeTypeExtensionPoint;
    
    private DynamicContentTypeDescriptorExtentionPoint _dynamicCTDescriptorEP;

    private ServiceManager _smanager;

    private AbstractCacheManager _cacheManager;
    
    @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 = (ModelItemTypeExtensionPoint) smanager.lookup(ModelItemTypeExtensionPoint.ROLE_CONTENT_ATTRIBUTE);
        _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()
    {
        _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);
    }
    
    /**
     * 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;
    }
    
    /**
     * Stores all the configurations of the current content type for a view
     * @param viewName the name of the view
     * @param mainConfiguration the main configuration of the view, if it is configures on the current type
     * @param overrides the list of overrides configured on the current type
     */
    public record ViewConfigurations(String viewName, Optional<ConfigurationAndPluginName> mainConfiguration, List<ConfigurationAndPluginName> overrides) { /* empty */ }
    
    /**
     * Stores all the configurations for a view, by the content types in which the configuration is declared
     * @param viewName the name of the view
     * @param mainConfigurations the main configurations of the view
     * @param overrides the list of overrides of the view
     */
    public record ViewConfigurationsByType(String viewName, Map<ContentType, ConfigurationAndPluginName> mainConfigurations, Map<ContentType, List<ConfigurationAndPluginName>> overrides) { /* empty */ }
    
    /**
     * 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
     */
    public Map<String, ViewConfigurationsByType> getViewConfigurations(String[] contentTypeIds, String[] mixinIds)
    {
        Map<String, ViewConfigurationsByType> viewConfigurations = new HashMap<>();
        for (String viewName : _getConfiguredViewNames(contentTypeIds))
        {
            getViewConfigurationsByType(viewName, contentTypeIds, mixinIds)
                .ifPresent(currentViewConfigurations -> viewConfigurations.put(viewName, currentViewConfigurations));
        }
        
        return viewConfigurations;
    }
    
    private Set<String> _getConfiguredViewNames(String[] contentTypeIds)
    {
        List<ContentType> contentTypes = Arrays.stream(contentTypeIds)
                                               .map(_getContentTypeEP()::getExtension)
                                               .collect(Collectors.toList());
        
        // Create a Set with configured views of the given content types
        Set<String> viewNames = contentTypes.stream()
                .map(ContentType::getViewConfigurations)
                .map(Map::keySet)
                .flatMap(Collection::stream)
                .collect(Collectors.toSet());

        // Add views configured on given content types' super types
        contentTypes.stream()
                    .map(ContentType::getSupertypeIds)
                    .map(this::_getConfiguredViewNames)
                    .forEach(viewNames::addAll);
        
        return viewNames;
    }
    
    /**
     * Get all configurations of the given view resulting of the concatenation 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
     */
    public Optional<ViewConfigurationsByType> getViewConfigurationsByType(String viewName, String[] contentTypeIds, String[] mixinIds)
    {
        Optional<ViewConfigurationsByType> viewConfigurationsByType = Optional.empty();
        for (String contentTypeId : contentTypeIds)
        {
            ContentType contentType = _getContentTypeEP().getExtension(contentTypeId);
            
            // If there is a main configuration for the view in this type, add the confs in the record but do not check the configurations of the super types
            if (_hasMainConfiguration(contentType, viewName))
            {
                ViewConfigurations currentTypeViewConfigurations = contentType.getViewConfigurations(viewName).get();
                // Main configuration
                Map<ContentType, ConfigurationAndPluginName> mainConfigurations = viewConfigurationsByType.map(ViewConfigurationsByType::mainConfigurations)
                        .orElse(new LinkedHashMap<>());
                currentTypeViewConfigurations.mainConfiguration().ifPresent(config -> mainConfigurations.put(contentType, config));

                // overrides
                Map<ContentType, List<ConfigurationAndPluginName>> overrides = viewConfigurationsByType.map(ViewConfigurationsByType::overrides)
                        .orElse(new LinkedHashMap<>());
                if (!currentTypeViewConfigurations.overrides().isEmpty())
                {
                    overrides.put(contentType, currentTypeViewConfigurations.overrides());
                }

                viewConfigurationsByType = Optional.of(new ViewConfigurationsByType(viewName, mainConfigurations, overrides));
            }
            else
            {
                Optional<ViewConfigurationsByType> parentsOptionalViewConfigurations = getViewConfigurationsByType(viewName, contentType.getSupertypeIds(), new String[0]);
                if (parentsOptionalViewConfigurations.isPresent() && !parentsOptionalViewConfigurations.get().mainConfigurations().isEmpty())
                {
                    ViewConfigurationsByType parentsViewConfigurations = parentsOptionalViewConfigurations.get();

                    // Merge parents main configurations to the current one
                    Map<ContentType, ConfigurationAndPluginName> mainConfigurations = parentsViewConfigurations.mainConfigurations();
                    viewConfigurationsByType.map(ViewConfigurationsByType::mainConfigurations)
                                            .ifPresent(mainConfigurations::putAll);

                    // Merge parents overrides to the current one. Put first the parent's overrides, the the child's one, and at the end the overrides that are already present
                    Map<ContentType, List<ConfigurationAndPluginName>> overrides = parentsViewConfigurations.overrides();
                    if (_hasOverrides(contentType, viewName))
                    {
                        ViewConfigurations currentTypeViewConfigurations = contentType.getViewConfigurations(viewName).get();
                        overrides.put(contentType, currentTypeViewConfigurations.overrides());
                    }
                    viewConfigurationsByType.map(ViewConfigurationsByType::overrides)
                                            .ifPresent(overrides::putAll);

                    viewConfigurationsByType = Optional.of(new ViewConfigurationsByType(viewName, mainConfigurations, overrides));
                }
            }
        }
        
        return viewConfigurationsByType;
    }
    
    private boolean _hasMainConfiguration(ContentType contentType, String viewName)
    {
        Optional<ViewConfigurations> optionalViewConfigurations = contentType.getViewConfigurations(viewName);
        return optionalViewConfigurations.isPresent() && optionalViewConfigurations.get().mainConfiguration().isPresent();
    }
    
    private boolean _hasOverrides(ContentType contentType, String viewName)
    {
        Optional<ViewConfigurations> optionalViewConfigurations = contentType.getViewConfigurations(viewName);
        return optionalViewConfigurations.isPresent() && !optionalViewConfigurations.get().overrides().isEmpty();
    }
    
    /**
     * 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;
    }
    
    /**
     * 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 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 (IllegalArgumentException e)
        {
            return false;
        }
    }

    /**
     * Retrieves all model items of given content types, indexed by their names.
     * @param contentTypeIds The identifier of the content types
     * @return the model items
     * @throws IllegalArgumentException if some content types define a model item with the same name and this model item does not come from a common ancestor
     */
    public Map<String, ModelItem> getModelItemsIndexedByName(String[] contentTypeIds) throws IllegalArgumentException
    {
        return getModelItems(contentTypeIds).stream()
                                            .collect(Collectors.toMap(ModelItem::getName, Function.identity()));
    }
    
    /**
     * Retrieves all model items of given content types.
     * @param contentTypeIds The identifier of the content types
     * @return the model items
     * @throws IllegalArgumentException if some content types define a model item with the same name and this model item does not come from a common ancestor
     */
    public Collection<? extends ModelItem> getModelItems(String[] contentTypeIds) throws IllegalArgumentException
    {
        List<ContentType> contentTypes = Arrays.stream(contentTypeIds)
                .map(id -> _getContentTypeEP().getExtension(id))
                .collect(Collectors.toList());
        
        return ModelHelper.getModelItems(contentTypes);
    }
    
    /**
     * 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("parentModelItemName", contentType.getParentAttributeDefinition()
                                                   .map(ContentAttributeDefinition::getPath)
                                                   .orElse(StringUtils.EMPTY));
        infos.put("viewNames", contentType.getViewNames(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);
        }
    }

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

    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);
        }
    }
}