/*
 *  Copyright 2010 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.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.Constants;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.xml.sax.SAXException;

import org.ametys.cms.content.references.RichTextOutgoingReferencesExtractor;
import org.ametys.cms.content.referencetable.HierarchicalReferenceTablesHelper;
import org.ametys.cms.contenttype.indexing.CustomIndexingField;
import org.ametys.cms.contenttype.indexing.CustomMetadataIndexingField;
import org.ametys.cms.contenttype.indexing.DefaultMetadataIndexingField;
import org.ametys.cms.contenttype.indexing.IndexingField;
import org.ametys.cms.contenttype.indexing.IndexingModel;
import org.ametys.cms.contenttype.indexing.MetadataIndexingField;
import org.ametys.cms.contenttype.indexing.SemanticAnnotationIndexingField;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.model.ContentRestrictedCompositeDefinition;
import org.ametys.cms.model.ContentRestrictedRepeaterDefinition;
import org.ametys.cms.model.parsing.ContentRestrictedCompositeDefinitionParser;
import org.ametys.cms.model.parsing.ContentRestrictedRepeaterDefinitionParser;
import org.ametys.cms.model.restrictions.ContentRestrictedModelItemHelper;
import org.ametys.cms.model.restrictions.ContentRestrictedModelItemHelper.FirstRestrictionsChecksState;
import org.ametys.cms.model.restrictions.RestrictedModelItem;
import org.ametys.cms.model.restrictions.Restrictions;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentAttributeTypeExtensionPoint;
import org.ametys.cms.transformation.RichTextTransformer;
import org.ametys.cms.transformation.docbook.DocbookOutgoingReferencesExtractor;
import org.ametys.cms.transformation.docbook.DocbookTransformer;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.Enumerator;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.ModelItemGroup;
import org.ametys.runtime.model.TemporaryViewReference;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.AbstractParameterParser;
import org.ametys.runtime.parameter.StaticEnumerator;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;

/**
 * Type of content which is retrieved from a XML configuration.
 * TODO document xml configuration
 * ...
 * Provides access based on rights and current workflow steps.<p>
 * It used a configuration file with the following format:
 * <code><br>
 * &nbsp;&nbsp;&lt;restrict-to&gt;<br>
 * &nbsp;&nbsp;&nbsp;&nbsp;[&lt;right type="read|write" id="RIGHT_ID"/&gt;]*
 * &nbsp;&nbsp;&lt;!-- logical OR between several right id of the same type --&gt;<br>
 * &nbsp;&nbsp;&nbsp;&nbsp;[&lt;workflow type="read|write" step="3"/&gt;]*
 * &nbsp;&nbsp;&lt;!-- logical OR between several workflow step of the same type --&gt;<br>
 * &nbsp;&nbsp;&nbsp;&nbsp;[&lt;cannot type="read|write"/&gt;]*<br>
 * &nbsp;&nbsp;&lt;/restrict-to&gt;<br>
 * </code>
 */
public class DefaultContentType extends AbstractContentTypeDescriptor implements ContentType, Contextualizable, ThreadSafe, Disposable
{
    /** Suffix for global validator role. */
    protected static final String __GLOBAL_VALIDATOR_ROLE_PREFIX = "_globalvalidator";
    
    static Pattern __annotationNamePattern;

    /** Metadata definitions. */
    @Deprecated
    protected Map<String, MetadataDefinition> _metadata = new LinkedHashMap<>();
    /** Model items */
    protected Map<String, ModelItem> _modelItems = new LinkedHashMap<>();
    /** The right needed to create a content of this type, or null if no right is needed. */
    protected String _right;
    /** The abstract property */
    protected boolean _abstract;
    /** Configured workflow names of the content type or its supertypes, can be empty */
    protected Set<String> _configuredWorkflowNames;
    /** Default workflow name. */
    protected Optional<String> _defaultWorkflowName;
    /** The tags */
    protected Set<String> _tags;
    /** The inheritable tags */
    protected Set<String> _inheritableTags;
    /** The parent attribute definition */
    protected ContentAttributeDefinition _parentAttributeDefinition;
    /** Service manager. */
    protected ServiceManager _manager;
    /** Avalon Context. */
    protected Context _context;
    /** Cocoon Context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    /** The restrictions helper */
    protected ContentRestrictedModelItemHelper _restrictedModelItemHelper;
    /** Default rich text transformer. */
    protected RichTextTransformer _richTextTransformer;
    /** Docbook (rich text) outgoing references extractor. */
    protected RichTextOutgoingReferencesExtractor _richTextOutgoingReferencesExtractor;
    /** Potential global validators. */
    protected List<ContentValidator> _globalValidators;
    /** Potentiel richtext updater */
    protected RichTextUpdater _richTextUpdater;
    /** Indexing model */
    protected IndexingModel _indexingModel;
    /** The helper component for hierarchical simple contents */
    protected HierarchicalReferenceTablesHelper _hierarchicalSimpleContentsHelper;
    /** List of overridden attributes */
    protected List<String> _overriddenAttributes = new ArrayList<>();
    /** List of overridden views */
    protected List<String> _overriddenViews = new ArrayList<>();
    /** All content type's views */    
    protected Map<String, View> _views = new LinkedHashMap<>();
    /** All configurations of content type's views */ 
    protected Map<String, Configuration> _viewConfigurations;
    
    /** The parser for content attribute's definitions */
    protected ContentAttributeDefinitionParser _attributeDefinitionParser;
    /** The parser for content compisite's definitions */
    protected ContentRestrictedCompositeDefinitionParser _compositeDefinitionParser;
    /** The parser for content repeater's definitions */
    protected ContentRestrictedRepeaterDefinitionParser _repeaterDefinitionParser;
    /** The parser for dublin core attribute's definitions */
    protected DublinCoreAttributeDefinitionParser _dublinCoreAttributeDefinitionParser;
    
    /**
     * ComponentManager pour les Validator
     * @deprecated use {@link #_validatorManager} instead
     */
    @Deprecated
    private ThreadSafeComponentManager<Validator> _oldValidatorManager;
    
    // ComponentManager for validators
    private ThreadSafeComponentManager<Validator> _validatorManager;
    
    // ComponentManager pour les Global Validators
    private ThreadSafeComponentManager<ContentValidator> _globalValidatorsManager;
    
    private ContentTypeReservedAttributeNameExtensionPoint _contentTypeReservedAttributeNameExtensionPoint; 
    
    /**
     * ComponentManager pour les Enumerator
     * @deprecated use {@link #_enumeratorManager} instead
     */
    @Deprecated
    private ThreadSafeComponentManager<org.ametys.runtime.parameter.Enumerator> _oldEnumeratorManager;
    
    // ComponentManager for enumerators
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    // ComponentManager pour les CustomIndexingField
    private ThreadSafeComponentManager<CustomIndexingField> _customFieldManager;

    // ComponentManager pour les CustomMetadataIndexingField
    private ThreadSafeComponentManager<CustomMetadataIndexingField> _customMetadataIndexingFieldManager;
    
    // Content attribute types extesion point
    private ContentAttributeTypeExtensionPoint _contentAttributeTypeExtensionPoint;
    
    private boolean _isSimple;

    private boolean _isMultilingual;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _manager = manager;
        _richTextTransformer = (RichTextTransformer) manager.lookup(DocbookTransformer.ROLE);
        _richTextOutgoingReferencesExtractor = (RichTextOutgoingReferencesExtractor) manager.lookup(DocbookOutgoingReferencesExtractor.ROLE);
        _richTextUpdater = (RichTextUpdater) manager.lookup(DocbookRichTextUpdater.ROLE);
        _hierarchicalSimpleContentsHelper = (HierarchicalReferenceTablesHelper) manager.lookup(HierarchicalReferenceTablesHelper.ROLE);
        _restrictedModelItemHelper = (ContentRestrictedModelItemHelper) manager.lookup(ContentRestrictedModelItemHelper.ROLE);
        _contentAttributeTypeExtensionPoint = (ContentAttributeTypeExtensionPoint) manager.lookup(ContentAttributeTypeExtensionPoint.ROLE);
    }
    
    /**
     * Get the ContentTypeReservedAttributeNameExtensionPoint instance
     * @return the instance
     */
    protected ContentTypeReservedAttributeNameExtensionPoint _getContentTypeReservedAttributeNameExtensionPoint()
    {
        if (_contentTypeReservedAttributeNameExtensionPoint == null)
        {
            try
            {
                _contentTypeReservedAttributeNameExtensionPoint = (ContentTypeReservedAttributeNameExtensionPoint) _manager.lookup(ContentTypeReservedAttributeNameExtensionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        return _contentTypeReservedAttributeNameExtensionPoint;
    }

    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    @Override
    public void dispose()
    {
        _oldValidatorManager.dispose();
        _oldValidatorManager = null;
        
        _validatorManager.dispose();
        _validatorManager = null;
        
        _globalValidatorsManager.dispose();
        _globalValidatorsManager = null;
        
        _oldEnumeratorManager.dispose();
        _oldEnumeratorManager = null;
        
        _enumeratorManager.dispose();
        _enumeratorManager = null;
        
        _customFieldManager.dispose();
        _customFieldManager = null;
        
        _customMetadataIndexingFieldManager.dispose();
        _customMetadataIndexingFieldManager = null;
    }

    @Override
    protected Configuration getRootConfiguration(Configuration configuration)
    {
        return configuration.getChild("content-type");
    }
    
    @Override
    protected Configuration getOverridenConfiguration() throws ConfigurationException
    {
        Configuration overridenConf = null;
        File ctFile = new File(_cocoonContext.getRealPath("/WEB-INF/param/content-types/_override/" + _id + ".xml"));
        
        if (ctFile.exists())
        {
            try (InputStream is = new FileInputStream(ctFile))
            {
                 
                overridenConf = new DefaultConfigurationBuilder(true).build(is);
            }
            catch (Exception ex)
            {
                throw new ConfigurationException("Unable to parse overriden configuration for content type '" + _id + "' at WEB-INF/param/content-types/_override/" + _id + ".xml", overridenConf, ex);
            }
        }
        
        return overridenConf;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _oldValidatorManager = new ThreadSafeComponentManager<>();
        _oldValidatorManager.setLogger(getLogger());
        _oldValidatorManager.contextualize(_context);
        _oldValidatorManager.service(_manager);
        
        _validatorManager = new ThreadSafeComponentManager<>();
        _validatorManager.setLogger(getLogger());
        _validatorManager.contextualize(_context);
        _validatorManager.service(_manager);
        
        _globalValidatorsManager = new ThreadSafeComponentManager<>();
        _globalValidatorsManager.setLogger(getLogger());
        _globalValidatorsManager.contextualize(_context);
        _globalValidatorsManager.service(_manager);
        
        _oldEnumeratorManager = new ThreadSafeComponentManager<>();
        _oldEnumeratorManager.setLogger(getLogger());
        _oldEnumeratorManager.contextualize(_context);
        _oldEnumeratorManager.service(_manager);
        
        _enumeratorManager = new ThreadSafeComponentManager<>();
        _enumeratorManager.setLogger(getLogger());
        _enumeratorManager.contextualize(_context);
        _enumeratorManager.service(_manager);
        
        _customFieldManager = new ThreadSafeComponentManager<>();
        _customFieldManager.setLogger(getLogger());
        _customFieldManager.contextualize(_context);
        _customFieldManager.service(_manager);
        
        _customMetadataIndexingFieldManager = new ThreadSafeComponentManager<>();
        _customMetadataIndexingFieldManager.setLogger(getLogger());
        _customMetadataIndexingFieldManager.contextualize(_context);
        _customMetadataIndexingFieldManager.service(_manager);
        
        Configuration rootConfiguration = getRootConfiguration(configuration);
        
        _abstract = rootConfiguration.getAttributeAsBoolean("abstract", false);
        
        _configureSuperTypes(rootConfiguration);
        
        _configureLabels(rootConfiguration);
        _configureIcons(rootConfiguration);
        
        _configureCSSFiles(rootConfiguration);
        
        // Tags
        _tags = new HashSet<>();
        _inheritableTags = new HashSet<>();
        
        if (rootConfiguration.getChild("tags", false) != null)
        {
            if (rootConfiguration.getChild("tags").getAttributeAsBoolean("inherited", false))
            {
                // Get tags from super types
                for (String superTypeId : _superTypeIds)
                {
                    ContentType superType = _cTypeEP.getExtension(superTypeId);
                    _tags.addAll(superType.getInheritableTags());
                    _inheritableTags.addAll(superType.getInheritableTags());
                }
            }
            
            _configureLocalTags(rootConfiguration.getChild("tags"));
        }
        
        // Rights
        _right = rootConfiguration.getChild("right").getValue(null);
        
        _isSimple = true;
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (superType == null)
            {
                throw new ConfigurationException("The content type '" + this.getId() + "' cannot extends the unexisting type '" + superTypeId + "'");
            }
            if (!superType.isSimple())
            {
                _isSimple = false;
                break;
            }
        }
        
        _configureDefaultWorkflowName(rootConfiguration);
        
        _isMultilingual = false;
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (superType.isMultilingual())
            {
                _isMultilingual = true;
                break;
            }
        }
        
        // Attribute definitions
        _configureAttributeDefinitions (rootConfiguration);
        
        // Parent content type
        _configureParentContentType(rootConfiguration);
        
        // Views
        _configureViews(rootConfiguration);
        _configureMetadataSets (rootConfiguration);
        
        _checkForReservedAttributeName();
        
        if (!_abstract && !hasTag(TAG_MIXIN))
        {
            if (!_views.containsKey("details"))
            {
                throw new ConfigurationException("Mandatory view named 'details' is missing for content type " + _id, configuration);
            }
            if (!_views.containsKey("main"))
            {
                throw new ConfigurationException("Mandatory view named 'main' is missing for content type " + _id, configuration);
            }
        }
        
        // Global validators
        _configureGlobalValidators (rootConfiguration);
        
        // Indexing model
        _configureIndexingModel (rootConfiguration);
    }
    
    private void _checkForReservedAttributeName() throws ConfigurationException
    {
        Set<String> reservedNames = _getContentTypeReservedAttributeNameExtensionPoint().getExtensionsIds();
        
        List<String> usedReservedKeywords = new ArrayList<>(reservedNames);
        usedReservedKeywords.retainAll(_modelItems.keySet());
        
        if (!usedReservedKeywords.isEmpty())
        {
            throw new ConfigurationException("In content type '" + _id + "', one or more attributes are named with a reserved keyword: " + StringUtils.join(usedReservedKeywords, ", ") 
            + ". The reserved keywords are: {" + StringUtils.join(reservedNames, ", ") + "}");
        }
    }

    /**
     * Configure attribute definitions
     * @param mainConfig The content type configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureAttributeDefinitions (Configuration mainConfig) throws ConfigurationException
    {
        _attributeDefinitionParser = new ContentAttributeDefinitionParser(_contentAttributeTypeExtensionPoint, _enumeratorManager, _validatorManager);
        _compositeDefinitionParser = new ContentRestrictedCompositeDefinitionParser(_contentAttributeTypeExtensionPoint);
        _repeaterDefinitionParser = new ContentRestrictedRepeaterDefinitionParser(_contentAttributeTypeExtensionPoint);
        _dublinCoreAttributeDefinitionParser = new DublinCoreAttributeDefinitionParser(_contentAttributeTypeExtensionPoint, _enumeratorManager, _validatorManager, _dcProvider);
        MetadataAndRepeaterDefinitionParser defParser = new MetadataAndRepeaterDefinitionParser(_oldEnumeratorManager, _oldValidatorManager);
        
        // First, get metadata from super type if applicable.
        _modelItems.putAll(_contentTypesHelper.getModelItems(_superTypeIds));
        _metadata.putAll(_getMetadataDefinitions(_superTypeIds));
        
        Map<String, Configuration> attributeConfiguration = new LinkedHashMap<>();
        _getApplicableAttributes(mainConfig, attributeConfiguration, false);
        
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null)
        {
            _getApplicableAttributes(overriddenConfig, attributeConfiguration, true);
        }
        
        // Then, parse own attributes
        _parseAllMetadatas(attributeConfiguration, defParser);
        _parseAllAttributes(attributeConfiguration);
        
        try
        {
            _attributeDefinitionParser.lookupComponents();
//            _dublinCoreAttributeDefinitionParser.lookupComponents();
            defParser.lookupComponents();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to lookup parameter local components", overriddenConfig, e);
        }
        
    }
    
    @Deprecated
    private Map<String, MetadataDefinition> _getMetadataDefinitions(String[] cTypes) throws ConfigurationException
    {
        Map<String, MetadataDefinition> metadata = new LinkedHashMap<>();

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

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

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

                metadata.put(name, definition);
            }
        }

        return metadata;
    }
    
    /**
     * Fill a map of the applicable attribute configurations.
     * @param config the content type configuration.
     * @param attributeConfigurations the Map of attributes {@link Configuration}, indexed by name.
     * @param allowOverride if true, encountering an attribute which has already been declared (based on its name) will replace it. Otherwise, an exception will be thrown. 
     * @throws ConfigurationException if an error occurs.
     */
    protected void _getApplicableAttributes(Configuration config, Map<String, Configuration> attributeConfigurations, boolean allowOverride) throws ConfigurationException
    {
        for (Configuration childConfiguration : config.getChildren())
        {
            String childName = childConfiguration.getName();
            
            if (childName.equals("metadata") || childName.equals("repeater"))
            {
                String attributeName = childConfiguration.getAttribute("name", "");
                
                if (!allowOverride && attributeConfigurations.containsKey(attributeName))
                {
                    throw new ConfigurationException("Attribute with name '" + attributeName + "' is already defined", childConfiguration);
                }
                else if (allowOverride && attributeConfigurations.containsKey(attributeName))
                {
                    _checkAttributeTypes(attributeConfigurations.get(attributeName), childConfiguration);
                }
                
                if (allowOverride)
                {
                    this._overriddenAttributes.add(attributeName);
                }
                
                attributeConfigurations.put(attributeName, childConfiguration);
            }
            else if (childName.equals("dublin-core"))
            {
                attributeConfigurations.put("dc", childConfiguration);
            }
        }
    }
    /**
     * Get the overridden attributes list
     *  @return the overridden attributes list
     */
    public List<String> getOverriddenAttributes()
    {
        return this._overriddenAttributes;
    }
    
    /**
     * Check if all metadata's types defined in first configuration are equals to those defined in second configuration
     * @param metadataConf1 The first configuration to compare
     * @param metadataConf2 The second configuration to compare
     * @throws ConfigurationException if the types are not equals
     */
    protected void _checkAttributeTypes (Configuration metadataConf1, Configuration metadataConf2) throws ConfigurationException
    {
        String type = metadataConf1.getAttribute("type", "");
        String overridenType = metadataConf2.getAttribute("type", "");
        if (!overridenType.equals(type))
        {
            throw new ConfigurationException("The type of metadata '" + metadataConf1.getAttribute("name") + " (" + type.toUpperCase() + ")" + "' can not be overriden to '" + metadataConf2.getAttribute("name") + " (" + overridenType.toUpperCase() + ")'");
        }
        
        if ("composite".equals(type) || metadataConf1.getName().equals("repeater"))
        {
            for (Configuration childConfig1 : metadataConf1.getChildren())
            {
                String childName = childConfig1.getName();
                if (childName.equals("metadata") || childName.equals("repeater"))
                {
                    Configuration childConfig2 = null;
                    for (Configuration conf : metadataConf2.getChildren(childName))
                    {
                        if (childConfig1.getAttribute("name").equals(conf.getAttribute("name")))
                        {
                            childConfig2 = conf;
                            break;
                        }
                    }
                    
                    if (childConfig2 != null)
                    {
                        _checkAttributeTypes (childConfig1, childConfig2);
                    }
                }
            }
        }
    }
    
    /**
     * Parse all attribute configurations.
     * @param attributeConfigurations the attribute configurations.
     * @throws ConfigurationException if the configuration is invalid.
     */
    protected void _parseAllAttributes(Map<String, Configuration> attributeConfigurations) throws ConfigurationException
    {
        for (Configuration childConfiguration : attributeConfigurations.values())
        {
            String childConfigName = childConfiguration.getName();
            
            if (childConfigName.equals("metadata") || childConfigName.equals("repeater"))
            {
                ModelItem child = _parseModelItem(childConfiguration, null);
                if (child != null)
                {
                    final String childName = child.getName();
                    if (_modelItems.containsKey(childName))
                    {
                        _checkAttributeTypes(_modelItems.get(childName), child);
                    }
                    
                    _checkContentTypeSimplicity(child);
                    _modelItems.put(childName, child);
                }
            }
            else if (childConfigName.equals("dublin-core"))
            {
                _parseDublinCoreAttributes();
            }
        }
    }
    
    /**
     * Parses a model item
     * @param itemConfiguration configuration of the model item to parse
     * @param parent the parent of the model item to parse. Can be <code>null</code> if the item has no parent.
     * @return the parsed model item
     * @throws ConfigurationException if an error occurs while the model item is parsed
     */
    @SuppressWarnings("static-access")
    protected ModelItem _parseModelItem(Configuration itemConfiguration, ModelItemGroup parent) throws ConfigurationException
    {
        ModelItem modelItem = null;
        final String itemConfigName = itemConfiguration.getName();
        if (itemConfigName.equals("metadata"))
        {
            String typeId = itemConfiguration.getAttribute("type");
            if (ModelItemTypeConstants.COMPOSITE_TYPE_ID.equals(typeId))
            {
                modelItem = _compositeDefinitionParser.parse(_manager, _pluginName, itemConfiguration, this, parent);
            }
            else
            {
                modelItem = _attributeDefinitionParser.parse(_manager, _pluginName, itemConfiguration, this, parent);
            }
        }
        else if (ModelItemTypeConstants.REPEATER_TYPE_ID.equals(itemConfigName))
        {
            modelItem = _repeaterDefinitionParser.parse(_manager, _pluginName, itemConfiguration, this, parent);
        }
        
        if (modelItem != null && modelItem instanceof ModelItemGroup)
        {
            for (Configuration childConfiguration : itemConfiguration.getChildren())
            {
                _parseModelItem(childConfiguration, (ModelItemGroup) modelItem);
            }
        }
        
        return modelItem;
    }
    
    /**
     * Check if all attribute types defined in first model item are equals to those defined in second model item
     * @param item1 The first item to compare
     * @param item2 The second item to compare
     * @throws ConfigurationException if the types are not equals
     */
    protected void _checkAttributeTypes (ModelItem item1, ModelItem item2) throws ConfigurationException
    {
        if (item1 instanceof AttributeDefinition)
        {
            AttributeDefinition attributeDef1 = (AttributeDefinition) item1;
            final String attibute1TypeId = attributeDef1.getType().getId();
            if (!(item2 instanceof AttributeDefinition) || !attibute1TypeId.equals(((AttributeDefinition) item2).getType().getId()))
            {
                throw new ConfigurationException("The type of attribute '" + attributeDef1 + "' defined in content type '" + attributeDef1.getModel() + "', can not be overriden to '" + item2 + "' in content type '" + ((AttributeDefinition) item2).getModel() + "'");
            }
        }
        else
        {
            if (!(item2 instanceof ModelItemGroup))
            {
                throw new ConfigurationException("The item group '" + item1 + "' can not be overriden by the non item group '" + item2 + "' in content type '" + ((AttributeDefinition) item2).getModel() + "'");
            }

            ModelItemGroup group1 = (ModelItemGroup) item1;
            ModelItemGroup group2 = (ModelItemGroup) item2;
            
            for (ModelItem subItemfromGroup1 : group1.getChildren())
            {
                ModelItem subItemFromGroup2 = group2.getChild(subItemfromGroup1.getName());
                if (subItemFromGroup2 != null)
                {
                    _checkAttributeTypes(subItemfromGroup1, subItemFromGroup2);
                    _checkContentTypeSimplicity(subItemfromGroup1);
                }
            }
        }
    }
    
    /**
     * Checks the given model item to determine if this content type is multilingual and/or simple
     * All items of a simple content-type have to be a simple type (string, long, date, ..)
     * A multilingual content type should contain at least an attribute of type MULTILINGUAL-STRING
     * @param modelItem The model item to check
     */
    protected void _checkContentTypeSimplicity(ModelItem modelItem)
    {
        if (modelItem instanceof ModelItemGroup)
        {
            // If the content type contains groups, it is not simple
            _isSimple = false;
        }
        else if (modelItem instanceof AttributeDefinition)
        {
            ElementType type = ((AttributeDefinition) modelItem).getType();
            if (!type.isSimple())
            {
                // If there is a no simple attribute, the content type is not simple 
                _isSimple = false;
            }
            
            if (ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID.equals(type.getId()))
            {
                // If there is a multilingual-string attribute, the content type is multilingual
                _isMultilingual = true;
            }
        }
    }
    
    /**
     * Parse DublinCore attributes
     * @throws ConfigurationException if the configuration is invalid
     */
    @SuppressWarnings("static-access")
    protected void _parseDublinCoreAttributes() throws ConfigurationException
    {
        Source src = null;
        
        try
        {
            src = _srcResolver.resolveURI("resource://org/ametys/cms/dublincore/dublincore.xml");
            
            if (src.exists())
            {
                Configuration configuration = null;
                try (InputStream is = src.getInputStream())
                {
                    configuration = new DefaultConfigurationBuilder(true).build(is);
                }
                
                ContentRestrictedCompositeDefinition definition = new ContentRestrictedCompositeDefinition();
                definition.setModel(this);
                definition.setName("dc");
                definition.setLabel(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_LABEL"));
                definition.setDescription(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_DESC"));
                definition.setType(_contentAttributeTypeExtensionPoint.getExtension(ModelItemTypeConstants.COMPOSITE_TYPE_ID));
                
                for (Configuration childConfiguration : configuration.getChildren())
                {
                    String childName = childConfiguration.getName();
                    
                    if (childName.equals("metadata"))
                    {
                        _dublinCoreAttributeDefinitionParser.parse(_manager, _pluginName, childConfiguration, this, definition);
                    }
                }
                
                _modelItems.put("dc", definition);
            }
        }
        catch (IOException | SAXException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core metadata", e);
        }
        finally
        {
            if (src != null)
            {
                _srcResolver.release(src);
            }
        }
    }
    
    /**
     * Parse all metadata configurations.
     * @param metadataConfigurations the metadata configurations.
     * @param defParser the metadata definition parser.
     * @throws ConfigurationException if the configuration is invalid.
     * @deprecated use {@link #_parseAllAttributes(Map)} instead
     */
    @Deprecated
    protected void _parseAllMetadatas(Map<String, Configuration> metadataConfigurations, MetadataAndRepeaterDefinitionParser defParser) throws ConfigurationException
    {
        for (Configuration childConfiguration : metadataConfigurations.values())
        {
            String childName = childConfiguration.getName();
            
            if (childName.equals("metadata") || childName.equals("repeater"))
            {
                _parseMetadata(childConfiguration, defParser);
            }
            else if (childName.equals("dublin-core"))
            {
                _parseDublinCoreMetadata(defParser);
            }
        }
    }
    
    /**
     * Parse a metadata configuration.
     * @param metadataConfiguration the metadata configuration.
     * @param defParser the metadata definition parser.
     * @return the created MetadataDefinition.
     * @throws ConfigurationException if the configuration is invalid
     * @deprecated use {@link #_parseModelItem(Configuration, ModelItemGroup)} instead
     */
    @Deprecated
    protected MetadataDefinition _parseMetadata(Configuration metadataConfiguration, MetadataAndRepeaterDefinitionParser defParser) throws ConfigurationException
    {
        MetadataDefinition metadataDefinition = defParser.parseParameter(_manager, _pluginName, metadataConfiguration);
        metadataDefinition.setReferenceContentType(_id);
        
        String metadataName = metadataDefinition.getName();
        
        if (_metadata.containsKey(metadataName))
        {
            _checkMetadataTypes (_metadata.get(metadataName), metadataDefinition);
        }
        
        // Update simple and multilingual properties
        _checkMetadataDefinition(metadataDefinition);
        
        _metadata.put(metadataName, metadataDefinition);
        
        return metadataDefinition;
    }
    
    /**
     * Check if all metadata's types defined in first metadata definition are equals to those defined in second metadata definition
     * @param metaDef1 The first metadata definition to compare
     * @param metaDef2 The second metadata definition to compare
     * @throws ConfigurationException if the types are not equals
     * @deprecated Use {@link #_checkAttributeTypes(ModelItem, ModelItem)} instead
     */
    @Deprecated
    protected void _checkMetadataTypes (MetadataDefinition metaDef1, MetadataDefinition metaDef2) throws ConfigurationException
    {
        if (!metaDef1.getType().equals(metaDef2.getType()))
        {
            throw new ConfigurationException("The type of metadata '" + metaDef1.toString() + "' defined in content type '" + metaDef1.getReferenceContentType() + "', can not be overriden to '" + metaDef2.toString() + "' in content type '" + metaDef2.getReferenceContentType() + "'");
        }
        
        if (metaDef1.getType().equals(MetadataType.COMPOSITE))
        {
            for (String subMetadataName : metaDef1.getMetadataNames())
            {
                if (metaDef2.getMetadataDefinition(subMetadataName) != null)
                {
                    _checkMetadataTypes (metaDef1.getMetadataDefinition(subMetadataName), metaDef2.getMetadataDefinition(subMetadataName));
                 
                    // Update simple and multilingual properties
                    _checkMetadataDefinition(metaDef1.getMetadataDefinition(subMetadataName));
                }
            }
        }
    }
    
    /**
     * Check the medatata definition to determines if this content type is multilingual and/or simple
     * All medatata of a simple content-type have to be a simple type (string, long, date, ..)
     * A multilingual content type should contain at least a metadata of type MULTILINGUAL_STRING
     * @param metadataDefinition The metadata definition
     * @return false if the medatata definition is not a valid medatata definition for a simple content-type
     * @deprecated Use {@link #_checkContentTypeSimplicity(ModelItem)} instead
     */
    @Deprecated
    protected boolean _checkMetadataDefinition (MetadataDefinition metadataDefinition)
    {
        MetadataType type = metadataDefinition.getType();
        
        switch (type)
        {
            case MULTILINGUAL_STRING:
                // The content type is a multilingual content type
                _isMultilingual = true;
                break;
                
            case COMPOSITE:
            case FILE:
            case REFERENCE:
            case RICH_TEXT:
                // The content type can not be simple (complex metadata are not allowed)
                _isSimple = false;
                break;
            default:
                break;
        }
        
        return true;
    }
    
    /**
     * Parse DublinCore metadata
     * @param defParser The parser definition
     * @throws ConfigurationException if the configuration is invalid
     * @deprecated Use {@link #_parseDublinCoreAttributes()} instead
     */
    @Deprecated
    protected void _parseDublinCoreMetadata (MetadataAndRepeaterDefinitionParser defParser) throws ConfigurationException
    {
        Source src = null;
        
        try
        {
            src = _srcResolver.resolveURI("resource://org/ametys/cms/dublincore/dublincore.xml");
            
            if (src.exists())
            {
                Configuration configuration = null;
                try (InputStream is = src.getInputStream())
                {
                    configuration = new DefaultConfigurationBuilder(true).build(is);
                }
                
                MetadataDefinition metadataDefinition = new MetadataDefinition();
                metadataDefinition.setReferenceContentType(_id);
                metadataDefinition.setId("/dc"); // FIXME ?
                metadataDefinition.setLabel(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_LABEL"));
                metadataDefinition.setDescription(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_DESC"));
                metadataDefinition.setName("dc");
                metadataDefinition.setType(MetadataType.COMPOSITE);
                
                for (Configuration childConfiguration : configuration.getChildren())
                {
                    String childName = childConfiguration.getName();
                    
                    if (childName.equals("metadata"))
                    {
                        MetadataDefinition metaDef = defParser.parseParameter(_manager, _pluginName, childConfiguration);
                        metaDef.setReferenceContentType(_id);
                        String metadataName = metaDef.getName();
                        metaDef.setId("/dc/" + metadataName);  // FIXME ?
                        
                        if (metaDef.getEnumerator() == null && _dcProvider.isEnumerated(metadataName))
                        {
                            StaticEnumerator enumerator = new StaticEnumerator();
                            
                            Map<String, I18nizableText> entries = _dcProvider.getEntries(metadataName);
                            if (entries != null)
                            {
                                for (String value : entries.keySet())
                                {
                                    enumerator.add(entries.get(value), value);
                                }
                               
                            }
                            metaDef.setEnumerator(enumerator);
                        }
                        
                        metadataDefinition.addMetadata(metaDef);
                    }
                }
                
                _metadata.put("dc", metadataDefinition);
            }
        }
        catch (IOException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core metadata", e);
        }
        catch (SAXException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core metadata", e);
        }
        finally
        {
            if (src != null)
            {
                _srcResolver.release(src);
            }
        }
    }
    
    /**
     * Configure the default workflow name from the XML configuration.
     *  - From the overriden configuration
     *  - If not, from the current configuration
     *  - If not, from the supertypes
     *  - If it cannot be determined and the content type is a reference table, then "reference-table"
     *  - Otherwise "content"
     * @param mainConfig The configuration
     * @throws ConfigurationException if an exception occurs
     */
    protected void _configureDefaultWorkflowName(Configuration mainConfig) throws ConfigurationException
    {
        _configuredWorkflowNames = Optional.ofNullable(getOverridenConfiguration())
            // Override mode
            .map(oc -> oc.getChild("default-workflow").getValue(null))
            // Normal mode
            .or(() -> Optional.ofNullable(mainConfig.getChild("default-workflow").getValue(null)))
            // Transform it in a singleton set
            .map(Set::of)
            // Inherited mode
            .orElseGet(this::_getDefaultWorkflowNamesFromSupertypes);
        
        _defaultWorkflowName = _configuredWorkflowNames.size() > 1
                // Several workflow names returns undefined
                ? Optional.empty()
                : _configuredWorkflowNames.stream()
                    // One workflow name is directly returned
                    .findFirst()
                    // Otherwise default workflow : reference-table or content
                    .or(() -> Optional.of(isReferenceTable() ? "reference-table" : "content"));
    }
    
    private Set<String> _getDefaultWorkflowNamesFromSupertypes()
    {
        Set<String> defaultWorkflowNames = new HashSet<>();
        
        // Get tags from super types
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            defaultWorkflowNames.addAll(superType.getConfiguredDefaultWorkflowNames());
        }
        
        if (defaultWorkflowNames.size() > 1)
        {
            getLogger().warn("Several default workflows are defined for content type '{}' : {}.", _id, StringUtils.join(defaultWorkflowNames));
        }
        
        return defaultWorkflowNames;
    }

    /**
     * Configures the "parent" content type. 
     * This must not be confounded with the super types. (See {@link AbstractContentTypeDescriptor#_configureSuperTypes(Configuration)})
     * @param mainConfig The main configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureParentContentType(Configuration mainConfig) throws ConfigurationException
    {
        Configuration parentCTypeConf = mainConfig.getChild("parent-ref", false);
        _parentAttributeDefinition = null;
        
        if (parentCTypeConf != null)
        {
            // Check this content type is a reference table
            if (!isReferenceTable())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' is defined but this feature is only enabled for reference table content types. It will be ignored.", getId());
                return;
            }
            
            String refAttributeName = parentCTypeConf.getAttribute("name");
            // Check valid reference of metadata
            if (!_modelItems.containsKey(refAttributeName))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it does not exist. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            ModelItem modelItem = _modelItems.get(refAttributeName);
            // Check metadata of type "content"
            if (!(modelItem instanceof ContentAttributeDefinition))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it is not an attribute of type CONTENT. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            ContentAttributeDefinition contentAttributeDefinition = (ContentAttributeDefinition) modelItem;
            if (contentAttributeDefinition.isMultiple())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it is a multiple attribute. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            String parentCTypeName = contentAttributeDefinition.getContentTypeId();
            ContentType parentCType = _cTypeEP.getExtension(parentCTypeName);
            
            if (parentCType == null)
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it does not exist or is not yet initialized. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            // Check parent content type is private AND simple
            else if (!parentCType.isPrivate())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it is not private. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            else if (!parentCType.isReferenceTable())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it is not a reference table. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            
            if (!_hierarchicalSimpleContentsHelper.registerRelation(parentCType, this))
            {
                getLogger().error("The content type '{}' defines a parent hierarchy which is not valid. See previous logs to know more.\nThis error can lead to UI issues.", getId());
                return;
            }
            _parentAttributeDefinition = contentAttributeDefinition;
        }
    }
    
    /**
     * Configure the content type views
     * @param mainConfig The content type configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureViews(Configuration mainConfig) throws ConfigurationException
    {
        // Get applicable views configurations
        // At first, get the views configured with the old syntax to replace them by the ones configured with the new syntax
        _viewConfigurations = _getApplicableViews(mainConfig, VIEW_TAG_NAME_WITH_LEGACY_SYNTAX, false);
        _viewConfigurations.putAll(_getApplicableViews(mainConfig, VIEW_TAG_NAME, false));
        
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null)
        {
            _viewConfigurations.putAll(_getApplicableViews(overriddenConfig, VIEW_TAG_NAME_WITH_LEGACY_SYNTAX, true));
            _viewConfigurations.putAll(_getApplicableViews(overriddenConfig, VIEW_TAG_NAME, true));
        }
        
        Map<String, Map<ContentType, Configuration>> allApplicableViews = _contentTypesHelper.getViewConfigurations(_superTypeIds, new String[0]);
        for (Map.Entry<String, Configuration> viewConfigurationByViewName : _viewConfigurations.entrySet())
        {
            String viewName = viewConfigurationByViewName.getKey();
            Configuration viewConfiguration = viewConfigurationByViewName.getValue();
            allApplicableViews.put(viewName, Map.of(this, viewConfiguration));
        }
        
        // Parse content type's views
        for (String viewName : allApplicableViews.keySet())
        {
            View view = _contentTypesHelper.parseView(this, allApplicableViews.get(viewName));
            _views.put(viewName, view);
        }
    }
    
    /**
     * Get the overridden views list
     *  @return the overridden views list
     */
    public List<String> getOverriddenViews()
    {
        return this._overriddenViews;
    }
    
    /**
     * Compute the applicable views from their configurations.
     * @param configuration The content type configuration
     * @param viewTagName The name of the tag containing the view
     * @param allowOverride if <code>true</code>, encountering a view which has already been declared (based on its name) will replace it. Otherwise, an exception will be thrown.
     * @return the applicable views, indexed by their names. For each view, indicates if the view is configured 
     * @throws ConfigurationException if the configuration is invalid
     */
    protected Map<String, Configuration> _getApplicableViews(Configuration configuration, String viewTagName, boolean allowOverride) throws ConfigurationException
    {
        Map<String, Configuration> applicableViews = new LinkedHashMap<>();
        
        for (Configuration viewConfig : configuration.getChildren(viewTagName))
        {
            String name = viewConfig.getAttribute("name");
            if (allowOverride)
            {
                this._overriddenViews.add(name);
            }
            
            if (!allowOverride && applicableViews.containsKey(name))
            {
                // TODO NEWATTRIBUTEAPI_CONTENT: Review the unicity of views due to edition / view differences :
                // In old API, we made the difference between view and edition metadata set.
                // We decided remove this notion. But all existing content types have for example 2 "main" metadata-set, one for view and the other for edition
                // So we can't check here that there is onl one view called "main"
                // Really remove the edition / view notion? or allow the creation of a view without type and put it in edition and view mode?
//                throw new ConfigurationException("The view named '" + name + "' is already defined.", viewConfig);
                getLogger().info("The view named '" + name + "' is already defined.", viewConfig);
            }
            else
            {
                applicableViews.put(name, viewConfig);
            }
        }
        
        return applicableViews;
    }
    
    /**
     * Configure the global validators for content type
     * @param config The content type configuration
     * @throws ConfigurationException if an error occurs
     */
    protected void _configureGlobalValidators (Configuration config) throws ConfigurationException
    {
        _globalValidators = new ArrayList<>();
        List<String> globalValidatorsToLookup = new ArrayList<>();
        
        Configuration globalValidatorsConfig = config.getChild("global-validators", true);
        globalValidatorsToLookup.addAll(_parseGlobalValidators(globalValidatorsConfig, config.getAttributeAsBoolean("include-from-supertype", true)));
        
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null)
        {
            // Global validators into an overriden configuration are added to the original global validators
            globalValidatorsToLookup.addAll(_parseGlobalValidators(overriddenConfig.getChild("global-validators", true), false));
        }
        
        try
        {
            _globalValidatorsManager.initialize();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to initialize global validator manager", e);
        }
        
        for (String validatorRole : globalValidatorsToLookup)
        {
            try
            {
                ContentValidator contentValidator = _globalValidatorsManager.lookup(validatorRole);
                contentValidator.setContentType(this);
                
                _globalValidators.add(contentValidator);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Unable to lookup global validator role: '" + validatorRole + "' for content type: " + this.getId(), e);
            }
        }
        
    }
    
    /**
     * Parse the global validators
     * @param config the configuration
     * @param includeSuperTypeValidators true to include validators of super types
     * @return the role of global validators to be lookuped
     * @throws ConfigurationException if configuration is incorrect
     */
    @SuppressWarnings("unchecked")
    protected List<String> _parseGlobalValidators(Configuration config, boolean includeSuperTypeValidators) throws ConfigurationException
    {
        List<String> gvRoles = new ArrayList<>();
        
        if (includeSuperTypeValidators)
        {
            for (String superTypeId : _superTypeIds)
            {
                ContentType cType = _cTypeEP.getExtension(superTypeId);
                _globalValidators.addAll(cType.getGlobalValidators());
            }
        }
        
        for (Configuration globalValidatorConfig : config.getChildren("global-validator"))
        {
            String globalValidatorId = __GLOBAL_VALIDATOR_ROLE_PREFIX + RandomStringUtils.randomAlphanumeric(10);
            String validatorClassName = globalValidatorConfig.getAttribute("class");
            
            try
            {
                Class validatorClass = Class.forName(validatorClassName);
                _globalValidatorsManager.addComponent(_pluginName, null, globalValidatorId, validatorClass, globalValidatorConfig);
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to instantiate global validator for class: " + validatorClassName, e);
            }
            
            gvRoles.add(globalValidatorId);
        }
        
        return gvRoles;
    }
    
    /**
     * Configure the indexing model
     * @param config The main configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureIndexingModel (Configuration config) throws ConfigurationException
    {
        Configuration indexConf = config.getChild("indexing-model", true);
        
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null && overriddenConfig.getChild("indexing-model", false) != null)
        {
            // Indexing model is overriden (original configuration is ignored)
            indexConf = overriddenConfig.getChild("indexing-model", true);
        }
        
        _indexingModel = new IndexingModel();
        
        boolean includeFromSuperType = indexConf.getAttributeAsBoolean("include-from-supertype", true);
        if (includeFromSuperType)
        {
            _indexingModel = _contentTypesHelper.getIndexingModel(_superTypeIds, new String[0]);
        }
        
        boolean includeAll = indexConf.getAttributeAsBoolean("include-all", true);
        if (includeAll)
        {
            for (String metadataName : _metadata.keySet())
            {
                MetadataDefinition definition = _metadata.get(metadataName);
                _indexingModel.addIndexingField(new DefaultMetadataIndexingField(metadataName, definition, metadataName));
            }
        }
        
        // Optionally add the semantic annotations to the indexing model.
        boolean includeSemanticAnnotations = indexConf.getAttributeAsBoolean("include-semantic-annotations", true);
        if (includeSemanticAnnotations)
        {
            _addSemanticAnnotations(indexConf, this);
        }
        
        // Metadata fields.
        _configureMetadataIndexingFields(indexConf);
        
        // Custom fields.
        _configureCustomIndexingFields(indexConf);
        
        // Custom metadata fields.
        _configureCustomMetadataIndexingFields(indexConf);
    }
    
    /**
     * Add semantic annotations as indexing fields to the indexing model.
     * @param indexConf the indexing model configuration.
     * @param holder the metadata holder (ContentType or MetadataDefinition) to scan for annotable metadata.
     */
    protected void _addSemanticAnnotations(Configuration indexConf, MetadataDefinitionHolder holder)
    {
        // Get the semantic annotations in a multimap.
        Multimap<SemanticAnnotation, String> metadatas = HashMultimap.create();
        _getSemanticAnnotations(holder, metadatas, "");
        
        // Add a custom indexing field for each annotation to the indexing model.
        for (SemanticAnnotation annotation : metadatas.keySet())
        {
            Collection<String> metaPaths = metadatas.get(annotation);
            _indexingModel.addIndexingField(new SemanticAnnotationIndexingField(annotation, metaPaths, this));
        }
    }
    
    /**
     * Get the semantic annotations and their paths from the given metadata definition holder's sub-tree.
     * @param holder The current metadata definition holder.
     * @param annotations The map of semantic annotations and the corresponding metadata paths.
     * @param prefix The current prefix in the metadata tree (with a trailing slash, if applicable).
     */
    protected void _getSemanticAnnotations(MetadataDefinitionHolder holder, Multimap<SemanticAnnotation, String> annotations, String prefix)
    {
        for (String metadataName : holder.getMetadataNames())
        {
            String metaPath = prefix + metadataName;
            MetadataDefinition metaDef = holder.getMetadataDefinition(metadataName);
            if (metaDef instanceof AnnotableDefinition)
            {
                List<SemanticAnnotation> metaAnnotations = ((AnnotableDefinition) metaDef).getSemanticAnnotations();
                for (SemanticAnnotation annotation : metaAnnotations)
                {
                    annotations.put(annotation, metaPath);
                }
            }
            
            _getSemanticAnnotations(metaDef, annotations, metaPath + ContentConstants.METADATA_PATH_SEPARATOR);
        }
    }
    
    /**
     * Configure the metadata indexing fields.
     * @param indexConf the indexing model configuration.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _configureMetadataIndexingFields(Configuration indexConf) throws ConfigurationException
    {
        Configuration[] fieldsConf = indexConf.getChildren("metadata-field");
        for (Configuration fieldConf : fieldsConf)
        {
            String metadataPath = fieldConf.getAttribute("path");
            
            MetadataDefinition metadataDef = _contentTypesHelper.getMetadataDefinition(metadataPath, this);
            if (metadataDef != null)
            {
                String fieldName = fieldConf.getAttribute("name", null);
                if (fieldName == null)
                {
                    fieldName = StringUtils.substringBeforeLast(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
                }
                
                // TODO check if metadataDef.getType() is a primitive type (string, long, double, ..) ?? 
                /*if (MetadataType.COMPOSITE == metadataDef.getType())
                {
                    throw new ConfigurationException("Indexing field of path '" + metadataPath + "' defined in content type '" + this.getId() + "' is not a valid path.");
                }*/
                _indexingModel.addIndexingField(new DefaultMetadataIndexingField(fieldName, metadataDef, metadataPath));
            }
            else
            {
                throw new ConfigurationException("Indexing field of path '" + metadataPath + "' defined in content type '" + this.getId() + "' is not a valid path.", fieldConf);
            }
        }
    }

    /**
     * Configure the custom indexing fields.
     * @param indexConf the indexing model configuration.
     * @throws ConfigurationException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _configureCustomIndexingFields(Configuration indexConf) throws ConfigurationException
    {
        List<String> customFieldRoles = new ArrayList<>();
        
        Configuration[] customsConf = indexConf.getChildren("custom-field");
        for (Configuration customConf : customsConf)
        {
            String className = customConf.getAttribute("class", null);
            if (className == null)
            {
                throw new ConfigurationException("A custom index field defined in content type '" + this.getId() + "' does not specifiy a class.", customConf);
            }
            
            try
            {
                Class<CustomIndexingField> customFieldClass = (Class<CustomIndexingField>) Class.forName(className);
                String fieldRole = getId() + "-" + className;
                _customFieldManager.addComponent("cms", null, getId() + "-" + className, customFieldClass, customConf);
                
                customFieldRoles.add(fieldRole);
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to instanciate custom indexing field for class: " + className, customConf, e);
            }
        }
        
        try
        {
            _customFieldManager.initialize();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to initialize custom indexing field manager", e);
        }
        
        for (String customFieldRole : customFieldRoles)
        {
            try
            {
                CustomIndexingField field = _customFieldManager.lookup(customFieldRole);
                _indexingModel.addIndexingField(field);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Unable to lookup custom indexing field with role: '" + customFieldRole + "' for content type: " + this.getId(), e);
            }
        }
    }
    
    /**
     * Configure the custom metadata indexing fields.
     * @param indexConf the indexing model configuration.
     * @throws ConfigurationException if an error occurs.
     */
    @SuppressWarnings("unchecked")
    protected void _configureCustomMetadataIndexingFields(Configuration indexConf) throws ConfigurationException
    {
        List<String> customMetadataFieldRoles = new ArrayList<>();
        
        int index = 0;
        Configuration[] customMetaConfs = indexConf.getChildren("custom-metadata-field");
        for (Configuration customMetaConf : customMetaConfs)
        {
            String className = customMetaConf.getAttribute("class", null);
            if (className == null)
            {
                throw new ConfigurationException("A custom indexing field defined in content type '" + this.getId() + "' does not specifiy a class.", customMetaConf);
            }
            
            try
            {
                DefaultConfiguration localConf = new DefaultConfiguration(customMetaConf, true);
                DefaultConfiguration cTypeConf = new DefaultConfiguration("contentType");
                cTypeConf.setAttribute("id", this.getId());
                localConf.addChild(cTypeConf);
                
                // Use an index in the role to be able to use several times the same class in a content-type.
                String fieldRole = getId() + "-" + className + "-" + index;
                Class<CustomMetadataIndexingField> customMetaFieldClass = (Class<CustomMetadataIndexingField>) Class.forName(className);
                _customMetadataIndexingFieldManager.addComponent("cms", null, fieldRole, customMetaFieldClass, localConf);
                
                customMetadataFieldRoles.add(fieldRole);
                
                index++;
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to instanciate custom metadata indexing field for class: " + className, customMetaConf, e);
            }
        }
        
        try
        {
            _customMetadataIndexingFieldManager.initialize();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to initialize custom metadata indexing field manager", e);
        }
        
        for (String customMetaFieldRole : customMetadataFieldRoles)
        {
            try
            {
                CustomMetadataIndexingField field = _customMetadataIndexingFieldManager.lookup(customMetaFieldRole);
                _indexingModel.addIndexingField(field);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Unable to lookup custom indexing field with role: '" + customMetaFieldRole + "' for content type: " + this.getId(), e);
            }
        }
    }
    
    /**
     * Parse the tags and add it to tags list
     * @param configuration the configuration to use
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _configureLocalTags(Configuration configuration)  throws ConfigurationException
    {
        Configuration[] children = configuration.getChildren("tag");
        for (Configuration tagConfig : children)
        {
            String tagValue = tagConfig.getValue();
            if (tagConfig.getAttributeAsBoolean("inheritable", true))
            {
                _inheritableTags.add(tagValue);
            }
            _tags.add(tagValue);
        }
    }
    
    @Override
    public void postInitialize() throws Exception
    {
        _checkTitleAttribute();
        
        _checkContentAttributes(this, 0);
        
        _resolveViewReferences();
        
        _computeIndexingModelReferences();
    }
    
    @SuppressWarnings("static-access")
    private void _checkTitleAttribute() throws ConfigurationException
    {
        if (!isAbstract() && !isMixin())
        {
            ModelItem titleItem = null;
            if (hasModelItem(Content.ATTRIBUTE_TITLE))
            {
                titleItem = getModelItem(Content.ATTRIBUTE_TITLE);
            }
            else
            {
                // The title attribute is mandatory for non abstract content types
                throw new ConfigurationException("An attribute 'title' in content type '" + getId() + "' should be defined.");
            }
            
            // The title attribute should'nt be a group item
            if (!(titleItem instanceof ElementDefinition))
            {
                throw new ConfigurationException("An attribute 'title' in content type '" + getId() + "' should be defined.");
            }
            
            // The title attribute should be a string or a multilingual string
            ElementDefinition titleAttribute = (ElementDefinition) titleItem;
            String typeId = titleAttribute.getType().getId();
            if (!ModelItemTypeConstants.STRING_TYPE_ID.equals(typeId) && !ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID.equals(typeId))
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' is defined with the type '" + typeId + "'. Only '" + ModelItemTypeConstants.STRING_TYPE_ID + "' and '" + ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID + "' are allowed");
            }
            
            // The title attribute should not be multiple
            if (titleAttribute.isMultiple())
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' should not be multiple.");
            }
            
            // The title attribute must be mandatory
            Validator titleValidator = titleAttribute.getValidator();
            if (titleValidator == null || !(boolean) titleValidator.getConfiguration().get("mandatory"))
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' should be mandatory.");
            }
        }
    }
    
    /**
     * Check for each content attribute: the content type id, the mutual references and the default values
     * @param modelItemContainer the {@link ModelItemContainer} to check
     * @param repeaterLevel the current nested level of repeaters, 0 if the current attribute isn't in a repeater.
     * @throws ConfigurationException if a content attribute has an invalid configuration
     */
    protected void _checkContentAttributes(ModelItemContainer modelItemContainer, int repeaterLevel) throws ConfigurationException
    {
        for (ModelItem modelItem : modelItemContainer.getModelItems())
        {
            if (ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(modelItem.getType().getId()))
            {
                ContentAttributeDefinition definition = (ContentAttributeDefinition) modelItem;
                _checkContentTypeId(definition);
                _checkMutualReferences(definition, repeaterLevel);
                definition.checkDefaultValue();
            }
            
            // Check sub-attributes
            if (modelItem instanceof ModelItemContainer)
            {
                // Increment the repeater level if the current attribute is a repeater.
                int newRepeaterLevel = (modelItem instanceof org.ametys.plugins.repository.model.RepeaterDefinition) ? repeaterLevel + 1 : repeaterLevel;
                _checkContentAttributes((ModelItemContainer) modelItem, newRepeaterLevel);
            }
        }
    }
    
    /**
     * Check the content type id of the given content attribute definition
     * @param definition the definition to check
     * @throws ConfigurationException if the given content attribute references an invalid or non-existing content type.
     */
    protected void _checkContentTypeId(ContentAttributeDefinition definition) throws ConfigurationException
    {
        String contentTypeId = definition.getContentTypeId();
        
        if (StringUtils.isNotBlank(contentTypeId) && !_cTypeEP.hasExtension(contentTypeId))
        {
            throw new ConfigurationException("The content attribute of path " + definition.getPath() + " in content type " + getId() + " references a nonexistent content-type: '" + contentTypeId + "'");
        }
    }
    
    /**
     * Check the mutual reference declaration of the given content attribute definition
     * @param definition the definition to check
     * @param repeaterLevel the current nested level of repeaters, 0 if the current attribute isn't in a repeater.
     * @throws ConfigurationException if there is a problem with mutual reference declaration
     */
    protected void _checkMutualReferences(ContentAttributeDefinition definition, int repeaterLevel) throws ConfigurationException
    {
        String contentTypeId = definition.getContentTypeId();
        String invertRelationPath = definition.getInvertRelationPath();

        if (StringUtils.isNotEmpty(invertRelationPath))
        {
            String currentAttributePath = definition.getPath();

            if (StringUtils.isEmpty(contentTypeId))
            {
                throw new ConfigurationException("The attribute at path '" + currentAttributePath + "' in content type '" + getId() + "' is declared as a mutual relationship, a content type is required.");
            }

            // Do not check the extension existence, this is already done in _checkContentAttribute method
            ContentType contentType = _cTypeEP.getExtension(contentTypeId);

            if (repeaterLevel > 0 && definition.isMultiple())
            {
                throw new ConfigurationException("The attribute at path '" + currentAttributePath + "' in content type '" + getId() + "' is declared as a mutual relationship, it can't be multiple AND in a repeater.");
            }
            else if (repeaterLevel >= 2)
            {
                throw new ConfigurationException("The attribute at path '" + currentAttributePath + "' in content type '" + getId() + "' is declared as a mutual relationship, it can't be in two levels of repeaters.");
            }

            try
            {
                ModelItem invertRelationDefinition = contentType.getModelItem(invertRelationPath);

                // Ensure that the referenced attribute is of type content.
                if (!ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(invertRelationDefinition.getType().getId()))
                {
                    throw new ConfigurationException("Mutual relationship: the attribute at path '" + invertRelationPath + "' of type " + contentTypeId + " is not of type Content.");
                }

                String invertCTypeId = ((ContentAttributeDefinition) invertRelationDefinition).getContentTypeId();
                String invertPath = ((ContentAttributeDefinition) invertRelationDefinition).getInvertRelationPath();

                // Ensure that the referenced attribute's content type is compatible with the current type.
                if (!_cTypeEP.isSameOrDescendant(getId(), invertCTypeId))
                {
                    throw new ConfigurationException("Mutual relationship: the attribute at path " + invertRelationPath + " of type " + contentTypeId + " references an incompatible type: " + StringUtils.defaultString(invertCTypeId, "<null>"));
                }

                // Ensure that the referenced attribute references this attribute.
                if (!currentAttributePath.equals(invertPath))
                {
                    throw new ConfigurationException("Mutual relationship: the attribute at path " + currentAttributePath + " of type " + getId() + " references the attribute '" + invertRelationPath + "' of type " + contentTypeId + " but the latter does not reference it back.");
                }
            }
            catch (UndefinedItemPathException e)
            {
                // Ensure the referenced attribute presence.
                throw new ConfigurationException("Mutual relationship: the attribute at path '" + invertRelationPath + "' doesn't exist for type " + contentTypeId);
            }
        }
    }
    
    /**
     * Resolve the temporary view references
     * @throws ConfigurationException if a view reference has a configuration error (the content attribute nesting the reference does not specify any content type, the view does not exist, ...)
     */
    protected void _resolveViewReferences() throws ConfigurationException
    {
        for (String viewName : getViewNames())
        {
            View view = getView(viewName);
            _resolveViewReferences(view, viewName);
        }
    }
    
    /**
     * Resolve the temporary view references in the given {@link ViewItemAccessor}
     * @param viewItemAccessor the {@link ViewItemAccessor}
     * @param currentViewName the name of the current view (to avoid views referencing themselves)
     * @throws ConfigurationException if a view reference has a configuration error (the content attribute nesting the reference does not specify any content type, the view does not exist, ...)
     */
    protected void _resolveViewReferences(ViewItemAccessor viewItemAccessor, String currentViewName) throws ConfigurationException
    {
        boolean hasResolvedReferences = false;
        List<ViewItem> viewItemsWithResolvedReferences = new ArrayList<>();
        for (ViewItem viewItem : viewItemAccessor.getViewItems())
        {
            if (viewItem instanceof TemporaryViewReference)
            {
                assert viewItemAccessor instanceof ViewElement;
                
                ElementDefinition definition = ((ViewElement) viewItemAccessor).getDefinition();
                assert definition instanceof ContentAttributeDefinition;
                
                String contentTypeId = ((ContentAttributeDefinition) definition).getContentTypeId();
                if (contentTypeId != null)
                {
                    Set<String> ancestors = _contentTypesHelper.getAncestors(this.getId());
                    if (!(ancestors.contains(contentTypeId) && currentViewName.equals(viewItem.getName())))
                    {
                        ContentType contentType = _cTypeEP.getExtension(contentTypeId);
                        View view = contentType.getView(viewItem.getName());
                        if (view != null)
                        {
                            hasResolvedReferences = true;
                            viewItemsWithResolvedReferences.addAll(view.getViewItems());
                        }
                        else
                        {
                            throw new ConfigurationException("The view '" + viewItem.getName() + "' does not exist in content type '" + contentTypeId + "' referenced by the attribute named '" + definition.getName() + "'.");
                        }
                    }
                    else
                    {
                        throw new ConfigurationException("The view '" + viewItem.getName() + "' cannot make a reference to itself.");
                    }
                }
                else
                {
                    throw new ConfigurationException("The attribute '" + definition.getName() + "' doesn't reference any content type. It is not possible to add the items of the view '" + viewItem.getName() + "'.");
                }
            }
            else
            {
                if (viewItem instanceof ViewItemAccessor)
                {
                    _resolveViewReferences((ViewItemAccessor) viewItem, currentViewName);
                }
                viewItemsWithResolvedReferences.add(viewItem);
            }
        }
        
        if (hasResolvedReferences)
        {
            viewItemAccessor.clear();
            viewItemAccessor.addViewItems(viewItemsWithResolvedReferences);
        }
    }
    
    /**
     * Browse the indexing model and compute indexing field references.
     */
    protected void _computeIndexingModelReferences()
    {
        // Impacted ContentType -> local IndexingField name -> path to impacted content.
        Map<String, Map<String, List<String>>> references = new HashMap<>();
        
        for (IndexingField field : _indexingModel.getFields())
        {
            if (field instanceof MetadataIndexingField)
            {
                String metadataPath = ((MetadataIndexingField) field).getMetadataPath();
                
                List<MetadataDefinition> definitions = getIndexingFieldDefinitions(this, metadataPath);
                
                List<String> joinPaths = new ArrayList<>();
                boolean localContentType = true;
                StringBuilder currentContentPath = new StringBuilder();
                for (MetadataDefinition definition : definitions)
                {
                    if (currentContentPath.length() > 0)
                    {
                        currentContentPath.append(ContentConstants.METADATA_PATH_SEPARATOR);
                    }
                    currentContentPath.append(definition.getName());
                    
                    if (definition.getType() == MetadataType.CONTENT || definition.getType() == MetadataType.SUB_CONTENT)
                    {
                        if (!localContentType)
                        {
                            joinPaths.add(currentContentPath.toString());
                            currentContentPath.setLength(0);
                            
                            String cTypeId = definition.getContentType();
                            
                            Map<String, List<String>> cTypeRefs;
                            if (references.containsKey(cTypeId))
                            {
                                cTypeRefs = references.get(cTypeId);
                            }
                            else
                            {
                                cTypeRefs = new LinkedHashMap<>();
                                references.put(cTypeId, cTypeRefs);
                            }
                            
                            cTypeRefs.put(field.getName(), new ArrayList<>(joinPaths));
                        }
                        
                        localContentType = false;
                    }
                }
            }
        }
        
        _indexingModel.setReferences(references);
    }
    
    /**
     * Get the list of metadata definitions "traversed" from the initial content type to the given metadata.
     * @param initialContentType the initial content type.
     * @param metadataPath the compound metadata path.
     * @return the list of metadata definitions.
     */
    protected List<MetadataDefinition> getIndexingFieldDefinitions(ContentType initialContentType, String metadataPath)
    {
        List<MetadataDefinition> definitions = new ArrayList<>();
        
        String[] pathSegments = StringUtils.split(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
        
        if (pathSegments.length > 0)
        {
            IndexingModel indexingModel = _contentTypesHelper.getIndexingModel(new String[] {initialContentType.getId()}, new String[0]);
            
            IndexingField refField = indexingModel.getField(pathSegments[0]);
            
            MetadataDefinition metadataDef = null;
            if (refField != null && refField instanceof CustomMetadataIndexingField)
            {
                metadataDef = ((CustomMetadataIndexingField) refField).getMetadataDefinition();
            }
            else
            {
                metadataDef = initialContentType.getMetadataDefinition(pathSegments[0]);
            }
            
            if (metadataDef != null)
            {
                definitions.add(metadataDef);
            }
            
            for (int i = 1; i < pathSegments.length && metadataDef != null; i++)
            {
                if (metadataDef.getType() == MetadataType.CONTENT || metadataDef.getType() == MetadataType.SUB_CONTENT)
                {
                    String refCTypeId = metadataDef.getContentType();
                    if (refCTypeId != null && _cTypeEP.hasExtension(refCTypeId))
                    {
                        ContentType refCType = _cTypeEP.getExtension(refCTypeId);
                        
                        List<MetadataDefinition> followingDefs = getIndexingFieldDefinitions(refCType, StringUtils.join(pathSegments, '/', i, pathSegments.length));
                        definitions.addAll(followingDefs);
                        
                        return definitions;
                    }
                }
                else
                {
                    refField = indexingModel.getField(pathSegments[i]);
                    if (refField != null && refField instanceof CustomMetadataIndexingField)
                    {
                        metadataDef = ((CustomMetadataIndexingField) refField).getMetadataDefinition();
                    }
                    else
                    {
                        metadataDef = metadataDef.getMetadataDefinition(pathSegments[i]);
                    }
                    definitions.add(metadataDef);
                }
            }
        }
        
        return definitions;
    }
    
    @Override
    public List<ContentValidator> getGlobalValidators()
    {
        return Collections.unmodifiableList(_globalValidators);
    }
    
    @Override
    public RichTextUpdater getRichTextUpdater()
    {
        return _richTextUpdater;
    }
    
    @Override
    public Set<String> getMetadataNames()
    {
        return Collections.unmodifiableSet(_metadata.keySet());
    }

    @Override
    public MetadataDefinition getMetadataDefinition(String metadataName)
    {
        return _metadata.get(metadataName);
    }
    
    @Override
    public boolean hasMetadataDefinition(String metadataName)
    {
        return _metadata.containsKey(metadataName);
    }
    
    @Override
    public MetadataDefinition getMetadataDefinitionByPath(String metadataPath)
    {
        String[] pathSegments = StringUtils.split(metadataPath, ContentConstants.METADATA_PATH_SEPARATOR);
        
        if (pathSegments.length == 0)
        {
            return null;
        }
        
        MetadataDefinition metadataDef = _metadata.get(pathSegments[0]);
        
        for (int i = 1;  i < pathSegments.length && metadataDef != null; i++)
        {
            metadataDef = metadataDef.getMetadataDefinition(pathSegments[i]);
        }
        
        return metadataDef;
    }
    
    @Override
    public IndexingModel getIndexingModel()
    {
        return _indexingModel;
    }
    
    @Override
    public boolean canRead(Content content, MetadataDefinition metadataDef) throws AmetysRepositoryException
    {
        Restrictions restrictions = _getRestrictionsForPath(metadataDef);
        
        FirstRestrictionsChecksState state = _restrictedModelItemHelper._doFirstRestrictionsChecks(content, restrictions, true);
        if (!FirstRestrictionsChecksState.UNKNOWN.equals(state))
        {
            return FirstRestrictionsChecksState.TRUE.equals(state);
        }
        
        String[] pathSegments = StringUtils.split(metadataDef.getId(), ContentConstants.METADATA_PATH_SEPARATOR);
        if (pathSegments.length > 1)
        {
            // Check read access on parent metadata definition
            String parentMetadataPath = metadataDef.getId().substring(0, metadataDef.getId().lastIndexOf(ContentConstants.METADATA_PATH_SEPARATOR));
            MetadataDefinition parentMetadataDef = _contentTypesHelper.getMetadataDefinition(parentMetadataPath, content);
            return canRead(content, parentMetadataDef);
        }
        
        return true;
    }

    @Override
    public boolean canWrite(Content content, MetadataDefinition metadataDef) throws AmetysRepositoryException
    {
        Restrictions restrictions = _getRestrictionsForPath(metadataDef);
        
        FirstRestrictionsChecksState state = _restrictedModelItemHelper._doFirstRestrictionsChecks(content, restrictions, false);
        if (!FirstRestrictionsChecksState.UNKNOWN.equals(state))
        {
            return FirstRestrictionsChecksState.TRUE.equals(state);
        }
        
        String[] pathSegments = StringUtils.split(metadataDef.getId(), ContentConstants.METADATA_PATH_SEPARATOR);
        if (pathSegments.length > 1)
        {
            // Check write access on parent metadata definition
            String parentMetadataPath = metadataDef.getId().substring(0, metadataDef.getId().lastIndexOf(ContentConstants.METADATA_PATH_SEPARATOR));
            MetadataDefinition parentMetadataDef = _contentTypesHelper.getMetadataDefinition(parentMetadataPath, content);
            return canWrite(content, parentMetadataDef);
        }

        return canRead(content, metadataDef);
    }
    
    @Override
    public Set<String> getTags()
    {
        return Collections.unmodifiableSet(_tags);
    }
    
    @Override
    public Set<String> getInheritableTags()
    {
        return Collections.unmodifiableSet(_inheritableTags);
    }
    
    @Override
    public boolean hasTag(String tagName)
    {
        return _tags.contains(tagName);
    }
    
    @Override
    public boolean isPrivate()
    {
        return hasTag(TAG_PRIVATE);
    }
    
    @Override
    public boolean isAbstract()
    {
        return _abstract;
    }
    
    @Override
    public boolean isSimple()
    {
        return _isSimple;
    }

    @Override
    public boolean isReferenceTable()
    {
        return hasTag(TAG_REFERENCE_TABLE) || hasTag(TAG_RENDERABLE_FERENCE_TABLE);
    }
    
    @Override
    public boolean isMultilingual()
    {
        return _isMultilingual;
    }
    
    @Override
    public boolean isMixin()
    {
        return hasTag(TAG_MIXIN);
    }
    
    @Override
    public Set<String> getConfiguredDefaultWorkflowNames()
    {
        return _configuredWorkflowNames;
    }
    
    @Override
    public Optional<String> getDefaultWorkflowName()
    {
        return _defaultWorkflowName;
    }
    
    @Override
    public String getRight()
    {
        return _right;
    }
    
    @Override
    public void saxContentTypeAdditionalData(org.xml.sax.ContentHandler contentHandler, Content content) throws AmetysRepositoryException, SAXException
    {
        // Nothing
    }
    
    @Override
    public Map<String, Object> getAdditionalData(Content content)
    {
        return new HashMap<>();
    }
    
    /**
     * Retrieves the restrictions for a given path.
     * @param metadataDef the metadata definition.
     * @return the restrictions or <code>null</code> if not found.
     */
    protected Restrictions _getRestrictionsForPath(MetadataDefinition metadataDef)
    {
        if (metadataDef != null && metadataDef instanceof RestrictedDefinition)
        {
            return ((RestrictedDefinition) metadataDef).getRestrictions();
        }
        
        // Not found
        return null;
    }

    @Override
    public String toString()
    {
        return "'" + getId() + "'";
    }
    
    /**
     * Restricted definition.
     * @deprecated use {@link RestrictedModelItem} instead
     */
    @Deprecated
    protected interface RestrictedDefinition
    {
        /**
         * Provides the restrictions.
         * @return the restrictions.
         */
        Restrictions getRestrictions();
    }
    
    /**
     * Definition with semantic annotations
     */
    protected interface AnnotableDefinition
    {
        /**
         * Provides the semantic annotations
         * @return the semantic annotations
         */
        List<SemanticAnnotation> getSemanticAnnotations();

        /**
         * Set the semantic annotations
         * @param annotations the semantic annotations to set
         */
        void setSemanticAnnotations(List<SemanticAnnotation> annotations);
    }
    
    /**
     * Internal {@link MetadataDefinition} storage contains instances of this class.
     * @deprecated Use {@link AttributeDefinition} instead
     */
    @Deprecated
    protected static class RestrictedMetadataDefinition extends MetadataDefinition implements RestrictedDefinition
    {
        /** Restrictions. */
        protected Restrictions _restrictions = new Restrictions();
        
        @Override
        public Restrictions getRestrictions()
        {
            return _restrictions;
        }
    }
    
    /**
     * Internal {@link MetadataDefinition} storage contains instances of this class.
     * @deprecated Use {@link RichTextAttributeDefinition} instead
     */
    @Deprecated
    protected static class RestrictedRichTextDefinition extends RichTextMetadataDefinition  implements RestrictedDefinition
    {
        /** Restrictions. */
        protected Restrictions _restrictions = new Restrictions();
        
        @Override
        public Restrictions getRestrictions()
        {
            return _restrictions;
        }
    }
    
    /**
     * Internal {@link org.ametys.cms.contenttype.RepeaterDefinition} storage contains instances of this class.
     * @deprecated Use {@link ContentRestrictedRepeaterDefinition} instead
     */
    @Deprecated
    protected static class RestrictedRepeaterDefinition extends org.ametys.cms.contenttype.RepeaterDefinition implements RestrictedDefinition
    {
        /** Restrictions. */
        protected Restrictions _restrictions = new Restrictions();
        
        @Override
        public Restrictions getRestrictions()
        {
            return _restrictions;
        }
    }
    
    /**
     * {@link RestrictedMetadataDefinition} and {@link RestrictedRepeaterDefinition} parser.
     * @deprecated Use {@link ContentAttributeDefinitionParser} instead
     */
    @Deprecated
    protected class MetadataAndRepeaterDefinitionParser extends AbstractParameterParser<MetadataDefinition, MetadataType>
    {
        /** Parent prefix. */
        protected String _parentPrefix = "";
        
        /**
         * Creates an {@link MetadataAndRepeaterDefinitionParser}.
         * @param enumeratorManager the enumerator component manager.
         * @param validatorManager the validator component manager.
         */
        public MetadataAndRepeaterDefinitionParser(ThreadSafeComponentManager<org.ametys.runtime.parameter.Enumerator> enumeratorManager, ThreadSafeComponentManager<Validator> validatorManager)
        {
            super(enumeratorManager, validatorManager);
        }
        
        @Override
        protected MetadataDefinition _createParameter(Configuration metadataConfiguration)  throws ConfigurationException
        {
            String defName = metadataConfiguration.getName();                        
                        
            if (defName.equals("metadata"))
            {
                String defType = metadataConfiguration.getAttribute("type");
                if (defType.equals("rich-text") || defType.equals("html-rich-text"))
                {
                    return new RestrictedRichTextDefinition();
                } 
                else 
                {
                    return new RestrictedMetadataDefinition();                    
                }
                
            }
            else if (defName.equals("repeater"))
            {
                return new RestrictedRepeaterDefinition();
            }

            throw new ConfigurationException("Unsupported metadata or repeater configuration", metadataConfiguration);
        }
        
        @Override
        protected String _parseId(Configuration metadataConfiguration) throws ConfigurationException
        {
            String metadataName = metadataConfiguration.getAttribute("name");
            
            if (!metadataName.matches("^[a-zA-Z]((?!__)[a-zA-Z0-9_-])*$"))
            {
                throw new ConfigurationException("Invalid metadata name: " + metadataName + ". The metadata name must start with a letter and must contain only letters, digits, underscore or dash characters.", metadataConfiguration);
            }
            
            return _parentPrefix + (_parentPrefix.length() > 0 ? ContentConstants.METADATA_PATH_SEPARATOR : "") + metadataName;
        }
        
        @Override
        protected MetadataType _parseType(Configuration metadataConfiguration) throws ConfigurationException
        {
            if (metadataConfiguration.getName().equals("repeater"))
            {
                // A repeater is a composite
                return MetadataType.COMPOSITE;
            }
            else if (metadataConfiguration.getAttribute("type").equals("html-rich-text"))
            {
                return MetadataType.RICH_TEXT;
            }
            
            try
            {
                return MetadataType.valueOf(metadataConfiguration.getAttribute("type").toUpperCase().replaceAll("-", "_"));
            }
            catch (IllegalArgumentException e)
            {
                throw new ConfigurationException("Invalid type", metadataConfiguration, e);
            }
        }
        
        @Override
        protected I18nizableText _parseI18nizableText(Configuration config, String pluginName, String name) throws ConfigurationException
        {
            // Override i18n parsing to use the default catalog (which can be application for automatic content types)
            return I18nizableText.parseI18nizableText(config.getChild(name), getDefaultCatalog());
        }
        
        @Override
        protected Object _parseDefaultValue(Configuration metadataConfiguration, MetadataDefinition metadataDef)
        {
            String value;
            
            Configuration childNode = metadataConfiguration.getChild("default-value", false);
            if (childNode == null)
            {
                value = null;
            }
            else
            {
                value = childNode.getValue("");
            }
            
            return value;
        }
        
        @Override
        protected void _additionalParsing(ServiceManager manager, String pluginName, Configuration metadataConfiguration, String metadataId, MetadataDefinition metadataDefinition) throws ConfigurationException
        {
            super._additionalParsing(manager, pluginName, metadataConfiguration, metadataId, metadataDefinition);
            String metadataName = metadataConfiguration.getAttribute("name");
            
            metadataDefinition.setReferenceContentType(_id);
            metadataDefinition.setName(metadataName);
            metadataDefinition.setMultiple(metadataConfiguration.getAttributeAsBoolean("multiple", false));
            // Use default transformer (docbook)
            metadataDefinition.setRichTextTransformer(_richTextTransformer);
            // Use docbook outgoing consistency extractor
            metadataDefinition.setRichTextOutgoingReferencesExtractor(_richTextOutgoingReferencesExtractor);
            
            if (metadataDefinition instanceof org.ametys.cms.contenttype.RepeaterDefinition)
            {
                org.ametys.cms.contenttype.RepeaterDefinition repeaterDefinition = (org.ametys.cms.contenttype.RepeaterDefinition) metadataDefinition;
                
                _parseRepeaterDefinition(manager, pluginName, metadataConfiguration, repeaterDefinition);
            }
            
            if (metadataDefinition instanceof AnnotableDefinition)
            {
                AnnotableDefinition definitionWithSemAnnotations = (AnnotableDefinition) metadataDefinition;
                
                _parseDefinitionWithAnnotations(manager, pluginName, metadataConfiguration, definitionWithSemAnnotations);
            }
            
            _restrictedModelItemHelper.populateRestrictions(metadataConfiguration, ((RestrictedDefinition) metadataDefinition).getRestrictions());
            
            if (metadataDefinition.getType() == MetadataType.CONTENT || metadataDefinition.getType() == MetadataType.SUB_CONTENT)
            {
                // Content metadata: parse and set the content type restriction.
                String contentType = metadataConfiguration.getAttribute("contentType", null);
                if (StringUtils.isNotEmpty(contentType))
                {
                    metadataDefinition.setContentType(contentType);
                }
                
                if (metadataDefinition.getType() == MetadataType.CONTENT)
                {
                    _parseContentRelations(metadataConfiguration, metadataDefinition, contentType);
                }
            }
            else if (metadataDefinition.getType() == MetadataType.COMPOSITE)
            {
                for (Configuration childConfig : metadataConfiguration.getChildren())
                {
                    String childName = childConfig.getName();
                    
                    if (childName.equals("metadata") || childName.equals("repeater"))
                    {
                        String oldParentPrefix = _parentPrefix;
                        // Stack new parent prefix
                        _parentPrefix = _parentPrefix + (_parentPrefix.length() > 0 ? ContentConstants.METADATA_PATH_SEPARATOR : "") + metadataName;
                        MetadataDefinition subMetaDef = parseParameter(manager, pluginName, childConfig);
                        // Restore parent prefix
                        _parentPrefix = oldParentPrefix;
                        
                        if (!metadataDefinition.addMetadata(subMetaDef))
                        {
                            throw new ConfigurationException("Metadata with name " + subMetaDef.getName() + " is already defined", childConfig);
                        }
                    }
                }
            }
        }
        
        /**
         * Parse content mutual relations.
         * @param metadataConfiguration the metadata configuration.
         * @param metadataDefinition the metadata definition to fill.
         * @param contentType the content type.
         */
        protected void _parseContentRelations(Configuration metadataConfiguration, MetadataDefinition metadataDefinition, String contentType)
        {
            String invert = metadataConfiguration.getAttribute("invert", null);
            if (StringUtils.isNotEmpty(invert))
            {
                metadataDefinition.setInvertRelationPath(invert);
                
                boolean forceInvert = metadataConfiguration.getAttributeAsBoolean("forceInvert", false);
                metadataDefinition.setForceInvert(forceInvert);
            }
        }
        
        /**
         * Parses the repeater definition. 
         * @param manager the service manager.
         * @param pluginName the plugin name declaring this parameter.
         * @param metadataConfiguration the metadata configuration to use.
         * @param repeaterDefinition the repeater definition.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _parseRepeaterDefinition(ServiceManager manager, String pluginName, Configuration metadataConfiguration, org.ametys.cms.contenttype.RepeaterDefinition repeaterDefinition) throws ConfigurationException
        {
            repeaterDefinition.setAddLabel(_parseI18nizableText(metadataConfiguration, pluginName, "add-label"));
            repeaterDefinition.setDeleteLabel(_parseI18nizableText(metadataConfiguration, pluginName, "del-label"));
            repeaterDefinition.setHeaderLabel(metadataConfiguration.getChild("header-label").getValue(null));
            repeaterDefinition.setInitialSize(metadataConfiguration.getAttributeAsInteger("initial-size", 0));
            repeaterDefinition.setMinSize(metadataConfiguration.getAttributeAsInteger("min-size", 0));
            repeaterDefinition.setMaxSize(metadataConfiguration.getAttributeAsInteger("max-size", -1));
        }
        
        /**
         * Parses the definition with semantic annotations. 
         * @param manager the service manager.
         * @param pluginName the plugin name declaring this parameter.
         * @param metadataConfiguration the metadata configuration to use.
         * @param annotableDefinition the metadata definition
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _parseDefinitionWithAnnotations(ServiceManager manager, String pluginName, Configuration metadataConfiguration, AnnotableDefinition annotableDefinition) throws ConfigurationException
        {            
            Configuration annotationsConfiguration = metadataConfiguration.getChild("annotations");
            List<SemanticAnnotation> semAnnotations = _parseSemAnnotations(pluginName, annotationsConfiguration);
            annotableDefinition.setSemanticAnnotations(semAnnotations);
        }
        
        /**
         * Extract the list of the declared annotations
         * @param pluginName the plugin name declaring this parameter.
         * @param annotationsConfiguration the annotations configuration to use.
         * @return the list of the declared annotations
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected List<SemanticAnnotation> _parseSemAnnotations(String pluginName, Configuration annotationsConfiguration)  throws ConfigurationException
        {
            List<SemanticAnnotation> annotations = new ArrayList<>();
            
            for (Configuration annotationConfig : annotationsConfiguration.getChildren("annotation"))
            {
                String id = annotationConfig.getAttribute("name");
                
                if (!_getAnnotationNamePattern().matcher(id).matches())
                {
                    throw new ConfigurationException("Invalid annonation name '" + id + "'. This value is not permitted: only [a-zA-Z][a-zA-Z0-9-_]* are allowed.");
                }
                
                I18nizableText label = _parseI18nizableText(annotationConfig, pluginName, "label");
                I18nizableText description = _parseI18nizableText(annotationConfig, pluginName, "description");
                annotations.add(new SemanticAnnotation(id, label, description));
            }
            
            return annotations;
        }
        
        /**
         * Get the annotation name pattern to test validity.
         * @return The annotation name pattern.
         */
        protected Pattern _getAnnotationNamePattern()
        {
            if (__annotationNamePattern == null)
            {
                // [a-zA-Z][a-zA-Z0-9_]*
                __annotationNamePattern = Pattern.compile("[a-z][a-z0-9-_]*", Pattern.CASE_INSENSITIVE);
            }

            return __annotationNamePattern;
        }
    }
    
    public Optional<ContentAttributeDefinition> getParentAttributeDefinition()
    {
        return Optional.ofNullable(_parentAttributeDefinition);
    }
    
    public Collection<ModelItem> getModelItems()
    {
        return Collections.unmodifiableCollection(_modelItems.values());
    }
    
    public Set<String> getViewNames(boolean includeInternals)
    {
        if (includeInternals)
        {
            return Collections.unmodifiableSet(_views.keySet());
        }
        else
        {
            return _views.entrySet()
                         .stream()
                         .filter(entry -> !entry.getValue().isInternal())
                         .map(Map.Entry::getKey)
                         .collect(Collectors.toSet());
        }
    }
    
    public View getView(String viewName)
    {
        return _views.get(viewName);
    }
    
    public Optional<Configuration> getViewConfiguration(String viewName)
    {
        return Optional.ofNullable(_viewConfigurations.get(viewName));
    }
    
    public String getFamilyId()
    {
        return ContentTypeExtensionPoint.ROLE;
    }
}