/*
 *  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.Set;
import java.util.regex.Pattern;

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.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.ModelItemGroup;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.SimpleViewItemGroup;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemGroup;
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. */
    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;
    /** The tags */
    protected Set<String> _tags;
    /** The parent metadata name */
    protected String _parentMetadataName;
    /** 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;

    /** Non-internal views */    
    protected Map<String, View> _views = new LinkedHashMap<>();
    
    /** 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;
    
    /**
     * 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;
    
    // Content type extension point
    private ContentTypeExtensionPoint _contentTypeExtensionPoint;
    
    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);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
    }

    @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<>();
        
        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.getTags());
                }
            }
            _tags.addAll(_parseTags (rootConfiguration.getChild("tags")));
        }
        
        // Rights
        _right = rootConfiguration.getChild("right").getValue(null);
        
        _isSimple = true;
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (!superType.isSimple())
            {
                _isSimple = false;
                break;
            }
        }
        
        _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);
        
        if (!_abstract && !hasTag(TAG_MIXIN))
        {
            if (!_views.containsKey("details"))
            {
                throw new ConfigurationException("Mandatory view named 'details' is missing for content type " + _id);
            }
            if (!_views.containsKey("main"))
            {
                throw new ConfigurationException("Mandatory view named 'main' is missing for content type " + _id);
            }
        }
        
        // Global validators
        _configureGlobalValidators (rootConfiguration);
        
        // Indexing model
        _configureIndexingModel (rootConfiguration);
    }
    
    /**
     * 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(_contentTypesHelper.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);
        }
        
    }
    
    /**
     * 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);
                }
                
                attributeConfigurations.put(attributeName, childConfiguration);
            }
            else if (childName.equals("dublin-core"))
            {
                attributeConfigurations.put("dc", childConfiguration);
            }
        }
    }
    
    /**
     * 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 GEOCODE:
            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);
            }
        }
    }

    /**
     * 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 occured
     * TODO NEWATTRIBUTEAPI_CONTENT: Adapt this method when all attribute types are managed with the new API
     */
    protected void _configureParentContentType(Configuration mainConfig) throws ConfigurationException
    {
        Configuration parentCTypeConf = mainConfig.getChild("parent-ref", false);
        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 refMetadataName = parentCTypeConf.getAttribute("name");
            // Check valid reference of metadata
            if (!_metadata.containsKey(refMetadataName))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the metadata '{}' but it does not exist. It will be ignored.", getId(), refMetadataName);
                return;
            }
            
            MetadataDefinition metadataDef = _metadata.get(refMetadataName);
            // Check metadata of type "content"
            if (!MetadataType.CONTENT.equals(metadataDef.getType()))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the metadata '{}' but it is not a metadata of type CONTENT. It will be ignored.", getId(), refMetadataName);
                return;
            }
            else if (metadataDef.isMultiple())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the metadata '{}' but it is a multiple metadata. It will be ignored.", getId(), refMetadataName);
                return;
            }
            
            String parentCTypeName = metadataDef.getContentType();
            ContentType parentCType = _cTypeEP.getExtension(parentCTypeName);
            
            if (parentCType == null)
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the metadata '{}' with content-type '{}' but it does not exist or is not yet initialized. It will be ignored.", getId(), refMetadataName, 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 metadata '{}' with content-type '{}' but it is not private. It will be ignored.", getId(), refMetadataName, parentCTypeName);
                return;
            }
            else if (!parentCType.isReferenceTable())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the metadata '{}' with content-type '{}' but it is not a reference table. It will be ignored.", getId(), refMetadataName, 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;
            }
            _parentMetadataName = refMetadataName;
        }
    }
    
    /**
     * 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
        Map<String, Configuration> viewConfigurations = _getApplicableViews(mainConfig, false);
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null)
        {
            viewConfigurations.putAll(_getApplicableViews(overriddenConfig, true));
        }
        
        // Parse content type's own views
        Map<String, View> contentTypeViews = _parseViews(viewConfigurations.values(), _superTypeIds);
        
        // Get views from super types that are not overriden by the content type itself
        Map<String, View> superTypesViews = _contentTypesHelper.getViews(_superTypeIds, new String[0], contentTypeViews.keySet());
        
        // Put in views: first the super types views, and then the content type's own views
        _views.putAll(superTypesViews);
        _views.putAll(contentTypeViews);
    }
    
    /**
     * Compute the applicable views from their configurations.
     * @param configuration The content type configuration
     * @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
     * @throws ConfigurationException if the configuration is invalid
     */
    protected Map<String, Configuration> _getApplicableViews(Configuration configuration, boolean allowOverride) throws ConfigurationException
    {
        Map<String, Configuration> applicableViews = new LinkedHashMap<>();
        
        for (Configuration viewConfig : configuration.getChildren("metadata-set"))
        {
            String name = viewConfig.getAttribute("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 metadata-set '" + name + "' is already defined.", viewConfig);
                getLogger().info("The view metadata-set '" + name + "' is already defined.", viewConfig);
            }
            else
            {
                applicableViews.put(name, viewConfig);
            }
        }
        
        return applicableViews;
    }
    
    /**
     * Parses the own content type's views
     * @param viewConfigurations the configuration that contains the views
     * @param superTypeIds the super content-types identifiers
     * @throws ConfigurationException if the configuration is invalid
     * @return the views as a <code>Map</code> with a boolean that determines if the view is internal or not
     */
    protected Map<String, View> _parseViews(Collection<Configuration> viewConfigurations, String[] superTypeIds) throws ConfigurationException
    {
        Map<String, View> views = new LinkedHashMap<>();
        
        for (Configuration viewConfiguration : viewConfigurations)
        {
            View view = _parseView(viewConfiguration, superTypeIds);
            views.put(view.getName(), view);
        }
        
        return views;
    }

    /**
     * Parses a view configuration to create a {@link View} object.
     * @param viewConfiguration the configuration of the view to parse
     * @param superTypeIds the super types identifiers
     * @return the view
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected View _parseView(Configuration viewConfiguration, String[] superTypeIds) throws ConfigurationException
    {
        View view = new View();

        String name = viewConfiguration.getAttribute("name");
        view.setName(name);
        view.setLabel(_parseI18nizableText(viewConfiguration, "label", name));
        view.setDescription(_parseI18nizableText(viewConfiguration, "description"));
        
        Configuration iconConf = viewConfiguration.getChild("icons");
        
        view.setSmallIcon(_parseIcon(iconConf, "small", null));
        String mediumIcon = _parseIcon(iconConf, "medium", null);
        view.setMediumIcon(mediumIcon);
        view.setLargeIcon(_parseIcon(iconConf, "large", null));
        
        view.setIconGlyph(_parseIconGlyph(iconConf, name, mediumIcon == null ? "ametysicon-column3" : null));
        view.setIconDecorator(iconConf.getChild("decorator").getValue(null));

        _fillViewItems(viewConfiguration, view, superTypeIds);

        return view;
    }
    
    /**
     * Fill the items of the given view
     * @param viewConfiguration the configuration of the view to fill
     * @param view the view to fill
     * @param superTypeIds the super types identifiers
     * @throws ConfigurationException if the configuration is not valid. 
     */
    protected void _fillViewItems(Configuration viewConfiguration, View view, String[] superTypeIds) throws ConfigurationException
    {
        for (Configuration itemConfiguration : viewConfiguration.getChildren())
        {
            String itemConfigurationName = itemConfiguration.getName();
            
            if ("metadata-ref".equals(itemConfigurationName))
            {
                String itemName = itemConfiguration.getAttribute("name");
                if (view.hasViewItem(itemName))
                {
                    throw new ConfigurationException("The item '" + itemName + "' is already referenced by a super-view or by the view '" + view.getName() + "' itself.", itemConfiguration);
                }
                
                ViewItem modelViewItem = _parseModelViewItem(itemConfiguration, null);
                if (modelViewItem != null)
                {
                    view.addViewItem(modelViewItem);
                }
                else
                {
                    getLogger().warn("The item '" + itemName + "' in the view '" + view.getName() + "' is not defined in content '" + this.getId() + "'");
                }
            }
            else if ("fieldset".equals(itemConfigurationName))
            {
                view.addViewItem(_parseSimpleViewItemGroup(itemConfiguration, view, superTypeIds));
            }
            else if ("dublin-core".equals(itemConfigurationName))
            {
                view.addViewItem(_parseDublinCoreViewItems());
            }
            else if ("include".equals(itemConfigurationName))
            {
                view.includeView(_getViewToInclude(itemConfiguration, view.getName(), superTypeIds));
            }
        }
    }

    /**
     * Parses a model view item
     * @param itemConfiguration configuration of the model view item
     * @param parent parent of the model view item. Can be <code>null</code> if the item has no model item parent
     * @return the model view item
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected ModelViewItem _parseModelViewItem(Configuration itemConfiguration, ModelViewItemGroup parent) throws ConfigurationException
    {
        String modelItemName = itemConfiguration.getAttribute("name");
        
        String modelItemPath = "";
        if (parent != null)
        {
            modelItemPath += parent.getDefinition().getPath() + ModelItem.ITEM_PATH_SEPARATOR;
        }
        modelItemPath += modelItemName;
        
        ModelItem modelItem;
        if (hasModelItem(modelItemPath))
        {
            modelItem = getModelItem(modelItemPath);
        }
        else
        {
            // TODO NEWATTRIBUTEAPI_CONTENT: when all attribute types are implemented, throw a ConfigurationExcpetion. For now, we assume that if the attribute is not found, it has been ignored because of its type
            return null;
        }

        if (modelItem instanceof ModelItemGroup)
        {
            ModelViewItemGroup group = new ModelViewItemGroup();
            group.setDefinition((ModelItemGroup) modelItem);
            
            // Process group children
            for (Configuration childConfiguration : itemConfiguration.getChildren())
            {
                String childConfigurationName = childConfiguration.getName();
                
                if ("metadata-ref".equals(childConfigurationName))
                {
                    String childName = childConfiguration.getAttribute("name");
                    if (group.hasViewItem(childName))
                    {
                        throw new ConfigurationException("The item '" + childName + "' is already referenced by the group '" + itemConfiguration.getAttribute("name") + "'.", childConfiguration);
                    }
                    
                    ViewItem modelViewItem = _parseModelViewItem(childConfiguration, group);
                    if (modelViewItem != null)
                    {
                        group.addViewItem(modelViewItem);
                    }
                }
                else
                {
                    getLogger().error("The group '" + itemConfiguration.getAttribute("name") + "' can't contain something else than model view items, configured with 'metadata-ref' elements @ " + childConfiguration.getLocation());
                    // FIXME CMS-9339 throw new ConfigurationException("The group '" + itemConfiguration.getAttribute("name") + "' can't contain something else than model view items, configured with 'metadata-ref' elements.", childConfiguration);
                }
            }
            
            return group;
        }
        else
        {
            ViewElement viewElement = new ViewElement();
            viewElement.setDefinition((ElementDefinition) modelItem);
            return viewElement;
        }
    }

    /**
     * Parses a simple view item group
     * @param itemConfiguration configuration of the simple view item group
     * @param referenceView the reference view for includes 
     * @param superTypeIds the super types identifiers
     * @return the simple view item group
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected SimpleViewItemGroup _parseSimpleViewItemGroup(Configuration itemConfiguration, View referenceView, String[] superTypeIds) throws ConfigurationException
    {
        SimpleViewItemGroup group = new SimpleViewItemGroup();
        group.setRole(itemConfiguration.getAttribute("role", ViewItemGroup.TAB_ROLE));
        group.setName(itemConfiguration.getAttribute("name", null));
        group.setLabel(_parseI18nizableText(itemConfiguration, "label"));
        group.setDescription(_parseI18nizableText(itemConfiguration, "description"));

        for (Configuration childConfiguration : itemConfiguration.getChildren())
        {
            String childConfigurationName = childConfiguration.getName();
            
            if ("metadata-ref".equals(childConfigurationName))
            {
                String childName = childConfiguration.getAttribute("name");
                if (referenceView.hasViewItem(childName))
                {
                    throw new ConfigurationException("The item '" + childName + "' is already referenced by the view '" + referenceView.getName() + "'.", childConfiguration);
                }
                
                if (group.hasViewItem(childName))
                {
                    String groupName = itemConfiguration.getAttribute("name", null);
                    String groupDesignation = groupName != null ? "the current group named '" + groupName + "'" : "the current unnamed group";
                    throw new ConfigurationException("The item '" + childName + "' is already referenced by " + groupDesignation + " in view '" + referenceView.getName() + "'.", childConfiguration);
                }
                
                ViewItem modelViewItem = _parseModelViewItem(childConfiguration, null);
                if (modelViewItem != null)
                {
                    group.addViewItem(modelViewItem);
                }
            }
            else if ("fieldset".equals(childConfigurationName))
            {
                group.addViewItem(_parseSimpleViewItemGroup(childConfiguration, referenceView, superTypeIds));
            }
            else if ("dublin-core".equals(childConfigurationName))
            {
                group.addViewItem(_parseDublinCoreViewItems());
            }
            else if ("include".equals(childConfigurationName))
            {
                group.includeView(_getViewToInclude(childConfiguration, referenceView.getName(), superTypeIds), referenceView);
            }
        }
        
        return group;
    }
    
    /**
     * Retrieves the view included by the given configuration
     * @param itemConfiguration configuration of the item that includes the view
     * @param viewName name of the view containing the item. (the item can be the view itself or a simple view item group inside the view)
     * @param superTypeIds the super types identifiers
     * @return the view included by the given configuration
     * @throws ConfigurationException if the configuration is not valid
     */
    protected View _getViewToInclude(Configuration itemConfiguration, String viewName, String[] superTypeIds) throws ConfigurationException
    {
        String superTypeId = itemConfiguration.getAttribute("from-supertype");
        if ("true".equals(superTypeId))
        {
            View viewToInclude = _contentTypesHelper.getView(viewName, superTypeIds, new String[0]);
            if (viewToInclude == null)
            {
                throw new ConfigurationException("The view '" + viewName + "' in content type '" + getId() + "' includes a super-view not found in its super-types.", itemConfiguration);
            }
            return viewToInclude;
        }
        else
        {
            if (!_contentTypesHelper.getAncestors(getId()).contains(superTypeId))
            {
                throw new ConfigurationException("The view '" + viewName + "' in content type '" + getId() + "' includes the super-view of the type '" + superTypeId + "' that is not a super-type.", itemConfiguration);
            }
            
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (superType == null)
            {
                throw new ConfigurationException("The view '" + viewName + "' in content type '" + getId() + "' includes the super-view of an unknown super-type '" + superTypeId + "'.", itemConfiguration);
            }
            
            View viewToInclude = superType.getView(viewName);
            if (viewToInclude == null)
            {
                throw new ConfigurationException("The view '" + viewName + "' in content type '" + getId() + "' includes the super-view not found in its super-type '" + superTypeId + "'.", itemConfiguration);
            }
            return viewToInclude;
        }
    }

    /**
     * Parses the DublinCore view items.
     * @return the group containing the dublin core view items
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected ModelViewItemGroup _parseDublinCoreViewItems() throws ConfigurationException
    {
        ModelViewItemGroup dublinCoreGroup = new ModelViewItemGroup();
        
        ModelItem modelItemGroup = getModelItem("/dc");
        if (modelItemGroup != null && modelItemGroup instanceof ModelItemGroup)
        {
            dublinCoreGroup.setDefinition((ModelItemGroup) modelItemGroup);    
        }
        else
        {
            throw new ConfigurationException("Unable to include Dublin Core view in a view of the content type '" + getId() + "'. The Dublin Core attributes have not been defined.");
        }
        
        
        Source src = null;
        
        try
        {
            src = _srcResolver.resolveURI("resource://org/ametys/cms/dublincore/dublincore.xml");
            
            if (src.exists())
            {
                try (InputStream is = src.getInputStream())
                {
                    Configuration configuration = new DefaultConfigurationBuilder(true).build(is);
                    Configuration viewConfiguration = configuration.getChild("metadata-set");
                    
                    for (Configuration childConfiguration : viewConfiguration.getChildren("metadata-ref"))
                    {
                        ViewElement viewElement = new ViewElement();
                        String childAttributeName = "/dc" + ModelItem.ITEM_PATH_SEPARATOR + childConfiguration.getAttribute("name");
                        if (hasModelItem(childAttributeName))
                        {
                            ModelItem definition = getModelItem(childAttributeName);
                            if (definition instanceof ElementDefinition)
                            {
                                viewElement.setDefinition((ElementDefinition) definition);
                                dublinCoreGroup.addViewItem(viewElement);
                            }
                            else
                            {
                                throw new ConfigurationException("Unable to include Dublin Core view in a view of the content type '" + getId() + "'. The Dublin Core attribute '" + childAttributeName + "' has not been defined.");
                            }
                        }
                        else
                        {
                            throw new ConfigurationException("Unable to include Dublin Core view in a view of the content type '" + getId() + "'. The Dublin Core attribute '" + childAttributeName + "' has not been defined.");
                        }
                    }
                }
            }
        }
        catch (IOException | SAXException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core view", e);
        }
        finally
        {
            if (src != null)
            {
                _srcResolver.release(src);
            }
        }
        
        return dublinCoreGroup;
    }
    
    /**
     * Configure the global validators for content type
     * @param config The content type configuration
     * @throws ConfigurationException if an error occurs
     */
    @SuppressWarnings("unchecked")
    protected void _configureGlobalValidators (Configuration config) throws ConfigurationException
    {
        _globalValidators = new ArrayList<>();
        List<String> globalValidatorsToLookup = new ArrayList<>();
        
        Configuration globalValidatorsConfig = config.getChild("global-validators", true);
        
        boolean includeSuperTypeValidators = globalValidatorsConfig.getAttributeAsBoolean("include-from-supertype", true);
        if (includeSuperTypeValidators)
        {
            for (String superTypeId : _superTypeIds)
            {
                ContentType cType = _cTypeEP.getExtension(superTypeId);
                _globalValidators.addAll(cType.getGlobalValidators());
            }
        }
        
        int count = 1;
        for (Configuration globalValidatorConfig : globalValidatorsConfig.getChildren("global-validator"))
        {
            String globalValidatorId = __GLOBAL_VALIDATOR_ROLE_PREFIX + count++;
            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);
            }
            
            globalValidatorsToLookup.add(globalValidatorId);
        }
        
        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);
            }
        }
        
    }
    
    /**
     * 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);
        
        _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
     * @param configuration the configuration to use
     * @return the tags
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected Set<String> _parseTags (Configuration configuration)  throws ConfigurationException
    {
        Set<String> tags = new HashSet<>();
        
        Configuration[] children = configuration.getChildren("tag");
        for (Configuration tagConfig : children)
        {
            tags.add(tagConfig.getValue());
        }
        
        return tags;
    }
    
    @Override
    public void postInitialize() throws Exception
    {
        _checkTitleAttribute();
        
        _checkContentAttributes();
        _checkContentMutualReferences();
        
        _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 that content attributes reference a valid content-type.
     * @throws ConfigurationException if a content attributes references an invalid or non-existing content type.
     */
    protected void _checkContentAttributes() throws ConfigurationException
    {
        for (ModelItem modelItem : getModelItems())
        {
            _checkContentAttribute(modelItem);
        }
    }
    
    /**
     * Recursively check that content attributes reference a valid content-type.
     * @param modelItem the attribute definition.
     * @throws ConfigurationException if a content attribute references an invalid or non-existing content type.
     */
    protected void _checkContentAttribute(ModelItem modelItem) throws ConfigurationException
    {
        if (ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(modelItem.getType().getId()))
        {
            ContentAttributeDefinition currentDefinition = (ContentAttributeDefinition) modelItem;
            String contentTypeId = currentDefinition.getContentTypeId();
            
            if (StringUtils.isNotBlank(contentTypeId) && !_cTypeEP.hasExtension(contentTypeId))
            {
                throw new ConfigurationException("The content attribute of path " + currentDefinition.getPath() + " in content type " + getId() + " references a non-existing content-type: '" + contentTypeId + "'");
            }
        }
        
        // Check sub-attributes
        if (modelItem instanceof ModelItemGroup)
        {
            for (ModelItem subItem : ((ModelItemGroup) modelItem).getModelItems())
            {
                _checkContentAttribute(subItem);
            }
        }
    }
    
    /**
     * Check content type mutual reference declarations.
     * @throws ConfigurationException if there is a problem with mutual reference declarations.
     */
    protected void _checkContentMutualReferences() throws ConfigurationException
    {
        for (ModelItem modelItem : getModelItems())
        {
            _checkContentMutualReferences(modelItem, 0);
        }
    }
    
    /**
     * Recursively check a content type mutual reference declarations.
     * @param modelItem the model item.
     * @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 declarations.
     */
    protected void _checkContentMutualReferences(ModelItem modelItem, int repeaterLevel) throws ConfigurationException
    {
        if (ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(modelItem.getType().getId()))
        {
            ContentAttributeDefinition currentDefinition = (ContentAttributeDefinition) modelItem;
            String contentTypeId = currentDefinition.getContentTypeId();
            String invertRelationPath = currentDefinition.getInvertRelationPath();
            
            if (StringUtils.isNotEmpty(invertRelationPath))
            {
                String currentAttributePath = currentDefinition.getPath();
                
                if (repeaterLevel > 0 && currentDefinition.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
                {
                    ContentType contentType = _cTypeEP.getExtension(contentTypeId);
                    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);
                }
            }
        }
        
        // We are in a repeater if we were already in a repeater at the previous level, or if the current attribute definition is a repeater.
        int newRepeaterLevel = (modelItem instanceof org.ametys.plugins.repository.model.RepeaterDefinition) ? repeaterLevel + 1 : repeaterLevel;
        
        // Check sub-attributes
        if (modelItem instanceof ModelItemGroup)
        {
            for (ModelItem subItem : ((ModelItemGroup) modelItem).getModelItems())
            {
                _checkContentMutualReferences(subItem, newRepeaterLevel);
            }
        }
    }
    
    /**
     * 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 = null;
                            if (references.containsKey(cTypeId))
                            {
                                cTypeRefs = references.get(cTypeId);
                            }
                            else
                            {
                                cTypeRefs = new HashMap<>();
                                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 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 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"))
                {
                    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;
            }
            
            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), _getDefaultCatalogue());
        }
        
        @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;
        }
    }
    
    @Override
    public MetadataDefinition getParentMetadata()
    {
        return _parentMetadataName != null ? _metadata.get(_parentMetadataName) : null;
    }
    
    public Collection<ModelItem> getModelItems()
    {
        return Collections.unmodifiableCollection(_modelItems.values());
    }
    
    public Set<String> getViewNames()
    {
        return Collections.unmodifiableSet(_views.keySet());
    }
    
    public View getView(String viewName)
    {
        return _views.get(viewName);
    }
    
    public String getFamilyId()
    {
        return ContentTypeExtensionPoint.ROLE;
    }
}