/*
 *  Copyright 2010 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.contenttype;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

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

import org.ametys.cms.content.references.RichTextOutgoingReferencesExtractor;
import org.ametys.cms.content.referencetable.HierarchicalReferenceTablesHelper;
import org.ametys.cms.contenttype.ContentTypesHelper.ViewConfigurations;
import org.ametys.cms.contenttype.ContentTypesHelper.ViewConfigurationsByType;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.data.type.ModelItemTypeExtensionPoint;
import org.ametys.cms.model.ContentRestrictedCompositeDefinition;
import org.ametys.cms.model.parsing.ContentRestrictedCompositeDefinitionParser;
import org.ametys.cms.model.parsing.ContentRestrictedRepeaterDefinitionParser;
import org.ametys.cms.model.properties.ElementRefProperty;
import org.ametys.cms.model.properties.Property;
import org.ametys.cms.model.restrictions.ContentRestrictedModelItemHelper;
import org.ametys.cms.model.restrictions.RestrictedModelItem;
import org.ametys.cms.model.restrictions.Restrictions;
import org.ametys.cms.repository.Content;
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.ModelHelper.ConfigurationAndPluginName;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.ModelItemGroup;
import org.ametys.runtime.model.TemporaryViewReference;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

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

    /** Model items */
    protected Map<String, ModelItem> _modelItems = new LinkedHashMap<>();
    /** The properties references as: Impacted ContentType -> local IndexingField name -> path to impacted content. */
    protected Map<String, Map<String, List<String>>> _propertiesReferences = new HashMap<>();
    /** The right needed to create a content of this type, or null if no right is needed. */
    protected String _right;
    /** The abstract property */
    protected boolean _abstract;
    /** Configured workflow names of the content type or its supertypes, can be empty */
    protected Set<String> _configuredWorkflowNames;
    /** Default workflow name. */
    protected Optional<String> _defaultWorkflowName;
    /** The tags */
    protected Set<String> _tags;
    /** The inheritable tags */
    protected Set<String> _inheritableTags;
    /** The parent attribute definition */
    protected ContentAttributeDefinition _parentAttributeDefinition;
    /** Service manager. */
    protected ServiceManager _manager;
    /** Avalon Context. */
    protected Context _context;
    /** Cocoon Context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    /** The restrictions helper */
    protected ContentRestrictedModelItemHelper _restrictedModelItemHelper;
    /** Default rich text transformer. */
    protected RichTextTransformer _richTextTransformer;
    /** Docbook (rich text) outgoing references extractor. */
    protected RichTextOutgoingReferencesExtractor _richTextOutgoingReferencesExtractor;
    /** Potential global validators. */
    protected List<ContentValidator> _globalValidators;
    /** Potentiel richtext updater */
    protected RichTextUpdater _richTextUpdater;
    /** The helper component for hierarchical simple contents */
    protected HierarchicalReferenceTablesHelper _hierarchicalSimpleContentsHelper;
    /** List of overridden attributes */
    protected List<String> _overriddenModelItems = new ArrayList<>();
    /** List of overridden views */
    protected List<String> _overriddenViews = new ArrayList<>();
    /** All content type's views */    
    protected Map<String, View> _views = new LinkedHashMap<>();
    /** All configurations of content type's views */
    protected Map<String, ViewConfigurations> _viewConfigurations;
    
    /** The parser for content attribute's definitions */
    protected ContentAttributeDefinitionParser _attributeDefinitionParser;
    /** The parser for content compisite's definitions */
    protected ContentRestrictedCompositeDefinitionParser _compositeDefinitionParser;
    /** The parser for content repeater's definitions */
    protected ContentRestrictedRepeaterDefinitionParser _repeaterDefinitionParser;
    /** The parser for dublin core attribute's definitions */
    protected DublinCoreAttributeDefinitionParser _dublinCoreAttributeDefinitionParser;
    
    // ComponentManager for validators
    private ThreadSafeComponentManager<Validator> _validatorManager;
    
    // ComponentManager for Global Validators
    private ThreadSafeComponentManager<ContentValidator> _globalValidatorsManager;
    
    private ContentTypeReservedAttributeNameExtensionPoint _contentTypeReservedAttributeNameExtensionPoint; 
    
    // ComponentManager for enumerators
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    // ComponentManager for properties
    private ThreadSafeComponentManager<Property> _propertiesManager;
    // Roles of properties to instanciate via the propertiesManager, with the property's parent
    private Map<String, Optional<ModelItemGroup>> _propertyRoles = new HashMap<>();
    // Index to avoid properties with same role
    private int _propertiesIndex;
    
    // Content attribute types extension point
    private ModelItemTypeExtensionPoint _contentAttributeTypeExtensionPoint;
    
    // Content properties types extension point
    private ModelItemTypeExtensionPoint _contentPropertyTypeExtensionPoint;
    
    private boolean _isSimple;

    private boolean _isMultilingual;
    
    private ContentTypeOverridesExtensionPoint _contentTypeOverridesExtensionPoint;
    
    @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 = (ModelItemTypeExtensionPoint) manager.lookup(ModelItemTypeExtensionPoint.ROLE_CONTENT_ATTRIBUTE);
        _contentPropertyTypeExtensionPoint = (ModelItemTypeExtensionPoint) manager.lookup(ModelItemTypeExtensionPoint.ROLE_CONTENT_PROPERTY);
        _contentTypeOverridesExtensionPoint = (ContentTypeOverridesExtensionPoint) manager.lookup(ContentTypeOverridesExtensionPoint.ROLE);
    }
    
    /**
     * Get the ContentTypeReservedAttributeNameExtensionPoint instance
     * @return the instance
     */
    protected ContentTypeReservedAttributeNameExtensionPoint _getContentTypeReservedAttributeNameExtensionPoint()
    {
        if (_contentTypeReservedAttributeNameExtensionPoint == null)
        {
            try
            {
                _contentTypeReservedAttributeNameExtensionPoint = (ContentTypeReservedAttributeNameExtensionPoint) _manager.lookup(ContentTypeReservedAttributeNameExtensionPoint.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        return _contentTypeReservedAttributeNameExtensionPoint;
    }

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

    @Override
    protected Configuration getRootConfiguration(Configuration configuration)
    {
        return configuration.getChild("content-type");
    }
    
    /**
     * Get the override configurations both from _override folder and extensions
     * @return The list of the override configurations
     * @throws ConfigurationException If an error occurs
     */
    protected List<ConfigurationAndPluginName> getOverrideConfigurations() throws ConfigurationException
    {
        List<ConfigurationAndPluginName> overrideConfigurations = getOverrideConfigurationsFromExtensions();
        getOverrideConfigurationFomFolder().ifPresent(overrideConfigurations::add);
        return overrideConfigurations;
    }
    
    /**
     * Get the override configuration from _override folder
     * @return the optional override configuration from _override folder
     * @throws ConfigurationException if an error occurred
     */
    protected Optional<ConfigurationAndPluginName> getOverrideConfigurationFomFolder() throws ConfigurationException
    {
        Optional<ConfigurationAndPluginName> overrideConfiguration = Optional.empty();
        File ctFile = new File(_cocoonContext.getRealPath("/WEB-INF/param/content-types/_override/" + _id + ".xml"));
        
        if (ctFile.exists())
        {
            try (InputStream is = new FileInputStream(ctFile))
            {
                Configuration configuration = new DefaultConfigurationBuilder(true).build(is);
                overrideConfiguration = Optional.of(new ConfigurationAndPluginName(configuration, _pluginName));
            }
            catch (Exception ex)
            {
                Configuration configuration = overrideConfiguration.map(ConfigurationAndPluginName::configuration)
                                                                   .orElse(null);
                throw new ConfigurationException("Unable to parse overridden configuration for content type '" + _id + "' at WEB-INF/param/content-types/_override/" + _id + ".xml", configuration, ex);
            }
        }
        
        return overrideConfiguration;
    }
    
    /**
     * Get the override configurations from extensions
     * @return The list of the override configurations from extensions
     * @throws ConfigurationException If an error occurs
     */
    protected List<ConfigurationAndPluginName> getOverrideConfigurationsFromExtensions() throws ConfigurationException
    {
        return _contentTypeOverridesExtensionPoint.getOverrideConfigurations(_id);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _validatorManager = new ThreadSafeComponentManager<>();
        _validatorManager.setLogger(getLogger());
        _validatorManager.contextualize(_context);
        _validatorManager.service(_manager);
        
        _globalValidatorsManager = new ThreadSafeComponentManager<>();
        _globalValidatorsManager.setLogger(getLogger());
        _globalValidatorsManager.contextualize(_context);
        _globalValidatorsManager.service(_manager);
        
        _enumeratorManager = new ThreadSafeComponentManager<>();
        _enumeratorManager.setLogger(getLogger());
        _enumeratorManager.contextualize(_context);
        _enumeratorManager.service(_manager);
        
        _propertiesManager = new ThreadSafeComponentManager<>();
        _propertiesManager.setLogger(getLogger());
        _propertiesManager.contextualize(_context);
        _propertiesManager.service(_manager);
        
        Configuration rootConfiguration = getRootConfiguration(configuration);
        
        _abstract = rootConfiguration.getAttributeAsBoolean("abstract", false);
        
        _configureSuperTypes(rootConfiguration);
        
        _configureLabels(rootConfiguration);
        _configureIcons(rootConfiguration);
        
        _configureCSSFiles(rootConfiguration);
        
        // Tags
        _tags = new HashSet<>();
        _inheritableTags = new HashSet<>();
        
        if (rootConfiguration.getChild("tags", false) != null)
        {
            if (rootConfiguration.getChild("tags").getAttributeAsBoolean("inherited", false))
            {
                // Get tags from super types
                for (String superTypeId : _superTypeIds)
                {
                    ContentType superType = _cTypeEP.getExtension(superTypeId);
                    _tags.addAll(superType.getInheritableTags());
                    _inheritableTags.addAll(superType.getInheritableTags());
                }
            }
            
            _configureLocalTags(rootConfiguration.getChild("tags"));
        }
        
        // Rights
        _right = rootConfiguration.getChild("right").getValue(null);
        
        _isSimple = true;
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (superType == null)
            {
                throw new ConfigurationException("The content type '" + this.getId() + "' cannot extends the unexisting type '" + superTypeId + "'");
            }
            if (!superType.isSimple())
            {
                _isSimple = false;
                break;
            }
        }
        
        _configureDefaultWorkflowName(rootConfiguration);
        
        _isMultilingual = false;
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            if (superType.isMultilingual())
            {
                _isMultilingual = true;
                break;
            }
        }
        
        // Attribute definitions
        _configureModelItems(rootConfiguration);
        
        // Parent content type
        _configureParentContentType(rootConfiguration);
        
        // Views configurations
        _configureViewConfigurations(rootConfiguration);
        
        _checkForReservedAttributeName();
        
        // Global validators
        _configureGlobalValidators (rootConfiguration);
    }
    
    private void _checkForReservedAttributeName() throws ConfigurationException
    {
        Set<String> reservedNames = _getContentTypeReservedAttributeNameExtensionPoint().getExtensionsIds();
        
        List<String> usedReservedKeywords = new ArrayList<>(reservedNames);
        usedReservedKeywords.retainAll(_modelItems.keySet());
        
        if (!usedReservedKeywords.isEmpty())
        {
            throw new ConfigurationException("In content type '" + _id + "', one or more attributes are named with a reserved keyword: " + StringUtils.join(usedReservedKeywords, ", ") 
            + ". The reserved keywords are: {" + StringUtils.join(reservedNames, ", ") + "}");
        }
    }
    
    /**
     * Configure attribute definitions
     * @param mainConfig The content type configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureModelItems (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);
        
        try
        {
            // First, get attributes from super type if applicable.
            _modelItems.putAll(_contentTypesHelper.getModelItemsIndexedByName(_superTypeIds));
        }
        catch (IllegalArgumentException e)
        {
            throw new ConfigurationException("A model item is defined in several co-super-types '", mainConfig, e);
        }
        
        Map<String, ConfigurationAndPluginName> modelItemConfigurations = new LinkedHashMap<>();
        _getApplicableModelItems(new ConfigurationAndPluginName(mainConfig, _pluginName), modelItemConfigurations, false);
        
        List<ConfigurationAndPluginName> overrideConfigurations = getOverrideConfigurations();
        _getApplicableModelItems(overrideConfigurations, modelItemConfigurations, true);
        
        // Then, parse own model items
        _parseAllModelItems(modelItemConfigurations);
        
        try
        {
            _attributeDefinitionParser.lookupComponents();
            _lookupProperties();
//            _dublinCoreAttributeDefinitionParser.lookupComponents();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to lookup parameter local components", mainConfig, e);
        }
    }
    
    /**
     * Fill a map of the applicable model item configurations.
     * @param configs the list of content type configurations.
     * @param modelItemConfigurations 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 _getApplicableModelItems(List<ConfigurationAndPluginName> configs, Map<String, ConfigurationAndPluginName> modelItemConfigurations, boolean allowOverride) throws ConfigurationException 
    {
        for (ConfigurationAndPluginName configuration : configs)
        {
            _getApplicableModelItems(configuration, modelItemConfigurations, allowOverride);
        }
    }
    
    /**
     * Fill a map of the applicable attribute configurations.
     * @param config the content type configuration.
     * @param modelItemConfigurations the Map of model item {@link Configuration}s, indexed by name.
     * @param allowOverride if true, encountering a model item 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 _getApplicableModelItems(ConfigurationAndPluginName config, Map<String, ConfigurationAndPluginName> modelItemConfigurations, boolean allowOverride) throws ConfigurationException
    {
        for (Configuration childConfiguration : config.configuration().getChildren())
        {
            String childName = childConfiguration.getName();
            
            if (childName.equals("metadata") || childName.equals("repeater") || childName.equals("property"))
            {
                String modelItemName = childConfiguration.getAttribute("name", "");
                
                if (!allowOverride && modelItemConfigurations.containsKey(modelItemName))
                {
                    throw new ConfigurationException("Model item with name '" + modelItemName + "' is already defined", childConfiguration);
                }
                else if (allowOverride && modelItemConfigurations.containsKey(modelItemName))
                {
                    _checkModelItemsTypeAndCardinality(modelItemConfigurations.get(modelItemName).configuration(), childConfiguration);
                }
                
                if (allowOverride)
                {
                    this._overriddenModelItems.add(modelItemName);
                }
                
                modelItemConfigurations.put(modelItemName, new ConfigurationAndPluginName(childConfiguration, config.pluginName()));
            }
            else if (childName.equals("dublin-core"))
            {
                modelItemConfigurations.put("dc", new ConfigurationAndPluginName(childConfiguration, config.pluginName()));
            }
        }
    }
    
    public List<String> getOverriddenModelItems()
    {
        return this._overriddenModelItems;
    }
    
    /**
     * Check if all model item's types defined in first configuration are equals to those defined in second configuration
     * @param modelItemConf1 The first configuration to compare
     * @param modelItemConf2 The second configuration to compare
     * @throws ConfigurationException if the types are not equals
     */
    protected void _checkModelItemsTypeAndCardinality (Configuration modelItemConf1, Configuration modelItemConf2) throws ConfigurationException
    {
        String type = modelItemConf1.getAttribute("type", "");
        String overridenType = modelItemConf2.getAttribute("type", "");
        if (!overridenType.equals(type))
        {
            throw new ConfigurationException("The type of model item '" + modelItemConf1.getAttribute("name") + "' (" + type + ") cannot be overridden to: " + overridenType);
            
        }
        boolean cardinality = modelItemConf1.getAttributeAsBoolean("multiple", false);
        boolean overriddenCardinality = modelItemConf2.getAttributeAsBoolean("multiple", false);
        if (cardinality != overriddenCardinality)
        {
            throw new ConfigurationException("The cardinality of model item '" + modelItemConf1.getAttribute("name") + "' (" + (cardinality ? "multiple" : "not multiple") + ") defined in content type '" + _id + "', can not be overridden to cardinality: " + (overriddenCardinality ? "multiple" : "not multiple"));
        }
        
        if ("composite".equals(type) || modelItemConf1.getName().equals("repeater"))
        {
            for (Configuration childConfig1 : modelItemConf1.getChildren())
            {
                String childName = childConfig1.getName();
                if (childName.equals("metadata") || childName.equals("repeater") || childName.equals("property"))
                {
                    Configuration childConfig2 = null;
                    for (Configuration conf : modelItemConf2.getChildren(childName))
                    {
                        if (childConfig1.getAttribute("name").equals(conf.getAttribute("name")))
                        {
                            childConfig2 = conf;
                            break;
                        }
                    }
                    
                    if (childConfig2 != null)
                    {
                        _checkModelItemsTypeAndCardinality (childConfig1, childConfig2);
                    }
                }
            }
        }
    }
    
    /**
     * Parse all attribute configurations.
     * @param attributeConfigurations the attribute configurations.
     * @throws ConfigurationException if the configuration is invalid.
     */
    protected void _parseAllModelItems(Map<String, ConfigurationAndPluginName> attributeConfigurations) throws ConfigurationException
    {
        for (ConfigurationAndPluginName childConfiguration : attributeConfigurations.values())
        {
            String childConfigName = childConfiguration.configuration().getName();
            
            if (childConfigName.equals("metadata") || childConfigName.equals("repeater") || childConfigName.equals("property"))
            {
                ModelItem child = _parseModelItem(childConfiguration, null);
                if (child != null)
                {
                    final String childName = child.getName();
                    if (_modelItems.containsKey(childName))
                    {
                        _checkModelItemsTypeAndCardinality(_modelItems.get(childName), child);
                    }
                    
                    _checkContentTypeSimplicity(child);
                    _modelItems.put(childName, child);
                }
            }
            else if (childConfigName.equals("dublin-core"))
            {
                _parseDublinCoreAttributes();
            }
        }
    }
    
    /**
     * Parses a model item
     * @param itemConfigurationAndPluginName 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(ConfigurationAndPluginName itemConfigurationAndPluginName, ModelItemGroup parent) throws ConfigurationException
    {
        ModelItem modelItem = null;
        Configuration itemConfiguration = itemConfigurationAndPluginName.configuration();
        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, itemConfigurationAndPluginName.pluginName(), itemConfiguration, this, parent);
            }
            else
            {
                modelItem = _attributeDefinitionParser.parse(_manager, itemConfigurationAndPluginName.pluginName(), itemConfiguration, this, parent);
            }
        }
        else if ("repeater".equals(itemConfigName))
        {
            modelItem = _repeaterDefinitionParser.parse(_manager, itemConfigurationAndPluginName.pluginName(), itemConfiguration, this, parent);
        }
        else if ("property".equals(itemConfigName))
        {
            String propertyRole = _parseProperty(itemConfiguration, ++_propertiesIndex);
            _propertyRoles.put(propertyRole, Optional.ofNullable(parent));
            
            // unable to lookup to the property component yet, all properties have to be initialized at one time
            // retrieve a null item
        }
        
        if (modelItem != null && modelItem instanceof ModelItemGroup)
        {
            for (Configuration childConfiguration : itemConfiguration.getChildren())
            {
                _parseModelItem(new ConfigurationAndPluginName(childConfiguration, itemConfigurationAndPluginName.pluginName()), (ModelItemGroup) modelItem);
            }
        }
        
        return modelItem;
    }
    
    /**
     * Parses a property
     * @param propertyConfiguration configuration of the property to parse
     * @param propertyIndex index to use in the role to be able to use several times a property with the same class in a content-type.
     * @return the role of the parsed property component
     * @throws ConfigurationException if an error occurs while the property is parsed
     */
    @SuppressWarnings("unchecked")
    protected String _parseProperty(Configuration propertyConfiguration, int propertyIndex) throws ConfigurationException
    {
        String className = propertyConfiguration.getAttribute("class", null);
        String path = propertyConfiguration.getAttribute("path", null);
        if (className == null && path == null)
        {
            throw new ConfigurationException("A property defined in content type '" + this.getId() + "' does not specifiy a class not attribute path.", propertyConfiguration);
        }

        Class<? extends Property> propertyClass;
        String propertyRole;
        if (className != null)
        {
            try
            {
                propertyClass = (Class<? extends Property>) Class.forName(className);
                propertyRole = getId() + "-" + className + "-" + propertyIndex;
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to instanciate property for class: " + className, propertyConfiguration, e);
            }
        }
        else
        {
            propertyClass = ElementRefProperty.class;
            propertyRole = getId() + "-" + path + "-" + propertyIndex;
        }
            
        _propertiesManager.addComponent(_pluginName, null, propertyRole, propertyClass, propertyConfiguration);
        return propertyRole;
    }
    
    /**
     * Check if all model item types defined in first model item are equals to those defined in second one
     * @param item1 The first item to compare
     * @param item2 The second item to compare
     * @throws ConfigurationException if the types are not equals
     */
    protected void _checkModelItemsTypeAndCardinality (ModelItem item1, ModelItem item2) throws ConfigurationException
    {
        if (item1 instanceof ElementDefinition elementDefinition1)
        {
            final String item1TypeId = elementDefinition1.getType().getId();
            final String item2TypeId = item2.getType().getId();
            if (!(item2 instanceof ElementDefinition elementDefinition2) || !item1TypeId.equals(item2TypeId))
            {
                throw new ConfigurationException("The type of model item '" + elementDefinition1.getPath() + "' (" + item1TypeId + ") defined in content type '" + _id + "', can not be overridden to type: " + item2TypeId);
            }
            else
            {
                final boolean item1Cardinality = elementDefinition1.isMultiple();
                final boolean item2Cardinality = elementDefinition2.isMultiple();
                
                if (item1Cardinality != item2Cardinality)
                {
                    throw new ConfigurationException("The cardinality of model item '" + elementDefinition1.getPath() + "' (" + (item1Cardinality ? "multiple" : "not multiple") + ") defined in content type '" + _id + "', can not be overridden to cardinality: " + (item2Cardinality ? "multiple" : "not multiple"));
                }
            }
        }
        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 '" + item2.getModel() + "'");
            }

            ModelItemGroup group1 = (ModelItemGroup) item1;
            ModelItemGroup group2 = (ModelItemGroup) item2;
            
            for (ModelItem subItemfromGroup1 : group1.getChildren())
            {
                ModelItem subItemFromGroup2 = group2.getChild(subItemfromGroup1.getName());
                if (subItemFromGroup2 != null)
                {
                    _checkModelItemsTypeAndCardinality(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 one model item 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 ElementDefinition elementDefinition)
        {
            ElementType type = elementDefinition.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"))
                    {
                        // TODO TAC, à faire ?
                        _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);
            }
        }
    }
    
    /**
     * Execute the lookup on all properties
     * @throws ConfigurationException if the configuration is invalid.
     */
    @SuppressWarnings("unchecked")
    protected void _lookupProperties() throws ConfigurationException
    {
        try
        {
            _propertiesManager.initialize();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to initialize properties manager", e);
        }
        
        for (String propertyRole : _propertyRoles.keySet())
        {
            try
            {
                Property property = _propertiesManager.lookup(propertyRole);
                String propertyName = property.getName();
                Optional<ModelItemGroup> optParent = _propertyRoles.get(propertyRole);
                
                property.setModel(this);
                property.setAvailableTypeExtensionPoint(_contentPropertyTypeExtensionPoint);

                // If the property's container already has an item with the same name, check item types
                ModelItemContainer propertyContainer = optParent.map(ModelItemContainer.class::cast)
                                                                .orElse(this);
                if (propertyContainer.hasModelItem(propertyName))
                {
                    ModelItem item = propertyContainer.getModelItem(propertyName);
                    _checkModelItemsTypeAndCardinality(item, property);
                }
                
                _checkContentTypeSimplicity(property);

                // Insert the property at the right place in model items hierarchy
                optParent.ifPresentOrElse(parent -> parent.addChild(property), 
                    () -> _modelItems.put(property.getName(), property));
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Unable to lookup property with role: '" + propertyRole + "' for content type: " + this.getId(), e);
            }
        }
    }
    
    /**
     * Configure the default workflow name from the XML configuration.
     *  - From the overriden configuration
     *  - If not, from the current configuration
     *  - If not, from the supertypes
     *  - If it cannot be determined and the content type is a reference table, then "reference-table"
     *  - Otherwise "content"
     * @param mainConfig The configuration
     * @throws ConfigurationException if an exception occurs
     */
    protected void _configureDefaultWorkflowName(Configuration mainConfig) throws ConfigurationException
    {
        _configuredWorkflowNames = getOverrideConfigurationFomFolder()
            .map(ConfigurationAndPluginName::configuration)
            // Override mode
            .map(oc -> oc.getChild("default-workflow").getValue(null))
            // Normal mode
            .or(() -> Optional.ofNullable(mainConfig.getChild("default-workflow").getValue(null)))
            // Transform it in a singleton set
            .map(Set::of)
            // Inherited mode
            .orElseGet(this::_getDefaultWorkflowNamesFromSupertypes);
        
        _defaultWorkflowName = _configuredWorkflowNames.size() > 1
                // Several workflow names returns undefined
                ? Optional.empty()
                : _configuredWorkflowNames.stream()
                    // One workflow name is directly returned
                    .findFirst()
                    // Otherwise default workflow : reference-table or content
                    .or(() -> Optional.of(isReferenceTable() ? "reference-table" : "content"));
    }
    
    private Set<String> _getDefaultWorkflowNamesFromSupertypes()
    {
        Set<String> defaultWorkflowNames = new HashSet<>();
        
        // Get tags from super types
        for (String superTypeId : _superTypeIds)
        {
            ContentType superType = _cTypeEP.getExtension(superTypeId);
            defaultWorkflowNames.addAll(superType.getConfiguredDefaultWorkflowNames());
        }
        
        if (defaultWorkflowNames.size() > 1)
        {
            getLogger().warn("Several default workflows are defined for content type '{}' : {}.", _id, StringUtils.join(defaultWorkflowNames));
        }
        
        return defaultWorkflowNames;
    }

    /**
     * Configures the "parent" content type. 
     * This must not be confounded with the super types. (See {@link AbstractContentTypeDescriptor#_configureSuperTypes(Configuration)})
     * @param mainConfig The main configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureParentContentType(Configuration mainConfig) throws ConfigurationException
    {
        Configuration parentCTypeConf = mainConfig.getChild("parent-ref", false);
        _parentAttributeDefinition = null;
        
        if (parentCTypeConf != null)
        {
            // Check this content type is a reference table
            if (!isReferenceTable())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' is defined but this feature is only enabled for reference table content types. It will be ignored.", getId());
                return;
            }
            
            String refAttributeName = parentCTypeConf.getAttribute("name");
            // Check valid reference of metadata
            if (!_modelItems.containsKey(refAttributeName))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it does not exist. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            ModelItem modelItem = _modelItems.get(refAttributeName);
            // Check metadata of type "content"
            if (!(modelItem instanceof ContentAttributeDefinition))
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it is not an attribute of type CONTENT. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            ContentAttributeDefinition contentAttributeDefinition = (ContentAttributeDefinition) modelItem;
            if (contentAttributeDefinition.isMultiple())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' but it is a multiple attribute. It will be ignored.", getId(), refAttributeName);
                return;
            }
            
            String parentCTypeName = contentAttributeDefinition.getContentTypeId();
            ContentType parentCType = _cTypeEP.getExtension(parentCTypeName);
            
            if (parentCType == null)
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it does not exist or is not yet initialized. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            // Check parent content type is private AND simple
            else if (!parentCType.isPrivate())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it is not private. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            else if (!parentCType.isReferenceTable())
            {
                getLogger().error("The 'parent-ref' tag for content type '{}' references the attribute '{}' with content-type '{}' but it is not a reference table. It will be ignored.", getId(), refAttributeName, parentCTypeName);
                return;
            }
            
            if (!_hierarchicalSimpleContentsHelper.registerRelation(parentCType, this))
            {
                getLogger().error("The content type '{}' defines a parent hierarchy which is not valid. See previous logs to know more.\nThis error can lead to UI issues.", getId());
                return;
            }
            _parentAttributeDefinition = contentAttributeDefinition;
        }
    }
    
    /**
     * Configure the content type view configurations
     * @param mainConfig The content type configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureViewConfigurations(Configuration mainConfig) throws ConfigurationException
    {
        // Get applicable views configurations

        // 1., get the views configured in the content type extension
        ConfigurationAndPluginName mainConfigurationAndPluginName = new ConfigurationAndPluginName(mainConfig, _pluginName);
        Map<String, ViewConfigurations> viewConfigurationsFromExtensionWithLegacySyntax = _getApplicableViewConfigurations(mainConfigurationAndPluginName, VIEW_TAG_NAME_WITH_LEGACY_SYNTAX);
        Map<String, ViewConfigurations> viewConfigurationsFromExtensionWithClassicSyntax = _getApplicableViewConfigurations(mainConfigurationAndPluginName, VIEW_TAG_NAME);
        Map<String, ViewConfigurations> viewConfigurationsFromExtension = mergeViewConfigurationsWithLegacyAndClassicSyntaxes(viewConfigurationsFromExtensionWithLegacySyntax, viewConfigurationsFromExtensionWithClassicSyntax);
        
        // 2. get the views configured in the content type overrides extensions
        List<ConfigurationAndPluginName> overrideConfigurationsFromExtensions = getOverrideConfigurationsFromExtensions();
        Map<String, ViewConfigurations> viewConfigurationsFromOverrideExtensionWithLegacySyntax = _getApplicableViewConfigurations(overrideConfigurationsFromExtensions, VIEW_TAG_NAME_WITH_LEGACY_SYNTAX);
        Map<String, ViewConfigurations> viewConfigurationsFromOverrideExtensionWithClassicSyntax = _getApplicableViewConfigurations(overrideConfigurationsFromExtensions, VIEW_TAG_NAME);
        Map<String, ViewConfigurations> viewConfigurationsFromOverrideExtension = mergeViewConfigurationsWithLegacyAndClassicSyntaxes(viewConfigurationsFromOverrideExtensionWithLegacySyntax, viewConfigurationsFromOverrideExtensionWithClassicSyntax);
        
        // Merge view configurations from extension and overrides extensions.
        Map<String, ViewConfigurations> viewConfigurationsFromAllExtensions = mergeViewConfigurationsWithOverrides(viewConfigurationsFromExtension, viewConfigurationsFromOverrideExtension);
        
        // 3. get the views configured in the _override folder
        Optional<ConfigurationAndPluginName> optOverrideConfigurationFomFolder = getOverrideConfigurationFomFolder();
        Map<String, ViewConfigurations> viewConfigurationsFromOverrideFolder = Map.of();
        if (optOverrideConfigurationFomFolder.isPresent())
        {
            ConfigurationAndPluginName overrideConfigurationFomFolder = optOverrideConfigurationFomFolder.get();
            Map<String, ViewConfigurations> viewConfigurationsFromOverrideFolderWithLegacySyntax = _getApplicableViewConfigurations(overrideConfigurationFomFolder, VIEW_TAG_NAME_WITH_LEGACY_SYNTAX);
            Map<String, ViewConfigurations> viewConfigurationsFromOverrideFolderWithClassicSyntax = _getApplicableViewConfigurations(overrideConfigurationFomFolder, VIEW_TAG_NAME);
            viewConfigurationsFromOverrideFolder = mergeViewConfigurationsWithLegacyAndClassicSyntaxes(viewConfigurationsFromOverrideFolderWithLegacySyntax, viewConfigurationsFromOverrideFolderWithClassicSyntax);
        }

        // Merge view configurations from extensions and override folder.
        _viewConfigurations = mergeViewConfigurationsWithOverrides(viewConfigurationsFromAllExtensions, viewConfigurationsFromOverrideFolder);
    }
    
    /**
     * Merge view configurations with legacy and classic syntax.
     * Keep the main configuration from the classic syntax if there is one. Concatenate all override configurations 
     * @param viewConfigurationsWithLegacySyntax the view configurations with legacy syntax
     * @param viewConfigurationsWithClassicSyntax the view configurations with legacy syntax
     * @return the merged view configurations
     */
    protected Map<String, ViewConfigurations> mergeViewConfigurationsWithLegacyAndClassicSyntaxes(Map<String, ViewConfigurations> viewConfigurationsWithLegacySyntax, Map<String, ViewConfigurations> viewConfigurationsWithClassicSyntax)
    {
        Map<String, ViewConfigurations> viewConfigurations = viewConfigurationsWithLegacySyntax;
        for (String viewName : viewConfigurationsWithClassicSyntax.keySet())
        {
            if (viewConfigurations.containsKey(viewName))
            {
                ViewConfigurations currentViewConfigurationsWithClassicSyntax = viewConfigurationsWithClassicSyntax.get(viewName);
                
                // Keep the main configuration from the classic syntax if there is one
                Optional<ConfigurationAndPluginName> mainConfiguration = currentViewConfigurationsWithClassicSyntax.mainConfiguration()
                                                                                                      .or(() -> viewConfigurations.get(viewName).mainConfiguration());
                
                // Concatenate all override configurations
                List<ConfigurationAndPluginName> allOverrides = viewConfigurations.get(viewName).overrides();
                allOverrides.addAll(currentViewConfigurationsWithClassicSyntax.overrides());

                viewConfigurations.put(viewName, new ViewConfigurations(viewName, mainConfiguration, allOverrides));
            }
            else
            {
                // Add the nonexistent view configurations
                viewConfigurations.put(viewName, viewConfigurationsWithClassicSyntax.get(viewName));
            }
        }
        
        return viewConfigurations;
    }
    
    /**
     * Merge view configurations with overrides
     * If there is a main configuration in overrides, do not keep configurations (main or overrides) of the original view configurations. Otherwise, concatenate all override configurations
     * @param viewConfigurations the original view configurations
     * @param viewOverrideConfigurations the override view configurations
     * @return @return the merged view configurations 
     */
    protected Map<String, ViewConfigurations> mergeViewConfigurationsWithOverrides(Map<String, ViewConfigurations> viewConfigurations, Map<String, ViewConfigurations> viewOverrideConfigurations)
    {
        Map<String, ViewConfigurations> mergedViewConfigurations = viewConfigurations;
        for (String viewName : viewOverrideConfigurations.keySet())
        {
            if (mergedViewConfigurations.containsKey(viewName))
            {
                ViewConfigurations currentViewOverrideConfigurations = viewOverrideConfigurations.get(viewName);
                if (currentViewOverrideConfigurations.mainConfiguration().isPresent())
                {
                    // If there is a main configuration in overrides, do not keep configurations (main or overrides) of the original view configurations
                    mergedViewConfigurations.put(viewName, viewOverrideConfigurations.get(viewName));
                }
                else
                {
                    // Otherwise, concatenate all override configurations
                    mergedViewConfigurations.get(viewName).overrides().addAll(currentViewOverrideConfigurations.overrides());
                }
            }
            else
            {
                // Add the nonexistent view configurations
                mergedViewConfigurations.put(viewName, viewOverrideConfigurations.get(viewName));
            }
        }
        
        return mergedViewConfigurations;
    }
    
    /**
     * Compute the applicable views from their configurations. (from "_override" folder and from extensions)
     * @param configurationAndPluginNames The content type configuration
     * @param viewTagName The name of the tag containing the view
     * @return the applicable views, indexed by their names. For each view, indicates if the view is configured 
     * @throws ConfigurationException if the configuration is invalid
     */
    protected Map<String, ViewConfigurations> _getApplicableViewConfigurations(List<ConfigurationAndPluginName> configurationAndPluginNames, String viewTagName) throws ConfigurationException 
    {
        Map<String, ViewConfigurations> allApplicableViewConfigurations = new LinkedHashMap<>();
        
        for (ConfigurationAndPluginName configurationAndPluginName : configurationAndPluginNames)
        {
            Map<String, ViewConfigurations> applicableViewConfigurations = _getApplicableViewConfigurations(configurationAndPluginName, viewTagName);
            
            for (String viewName : applicableViewConfigurations.keySet())
            {
                if (allApplicableViewConfigurations.containsKey(viewName))
                {
                    // Concatenate all override configurations
                    allApplicableViewConfigurations.get(viewName).overrides().addAll(applicableViewConfigurations.get(viewName).overrides());
                }
                else
                {
                    // Add the nonexistent view configurations
                    allApplicableViewConfigurations.put(viewName, applicableViewConfigurations.get(viewName));
                }
            }
        }
        
        return allApplicableViewConfigurations;
    }
    
    /**
     * Compute the applicable views from their configurations.
     * @param configurationAndPluginName The content type configuration
     * @param viewTagName The name of the tag containing the view
     * @return the applicable views, indexed by their names. For each view, indicates if the view is configured 
     * @throws ConfigurationException if the configuration is invalid
     */
    protected Map<String, ViewConfigurations> _getApplicableViewConfigurations(ConfigurationAndPluginName configurationAndPluginName, String viewTagName) throws ConfigurationException
    {
        Map<String, ViewConfigurations> applicableViewConfigurations = new LinkedHashMap<>();

        for (Configuration viewConfiguration : configurationAndPluginName.configuration().getChildren(viewTagName))
        {
            String viewName = viewConfiguration.getAttribute("name");
            ViewConfigurations viewConfigurations = applicableViewConfigurations.computeIfAbsent(viewName, configs -> new ViewConfigurations(viewName, Optional.empty(), new ArrayList<>()));
            
            if (viewConfiguration.getAttributeAsBoolean("override", false))
            {
                viewConfigurations.overrides().add(new ConfigurationAndPluginName(viewConfiguration, configurationAndPluginName.pluginName()));
            }
            else
            {
                if (viewConfigurations.mainConfiguration().isPresent())
                {
                    // There is already a main configuration for this view in the same configuration file
                    throw new ConfigurationException("The view named '" + viewName + "' is defined twice in the content type '" + this.getId() + "'.", configurationAndPluginName.configuration());
                }
                else
                {
                    applicableViewConfigurations.put(viewName, new ViewConfigurations(viewName, Optional.of(new ConfigurationAndPluginName(viewConfiguration, configurationAndPluginName.pluginName())), viewConfigurations.overrides()));
                }
            }
        }
        
        return applicableViewConfigurations;
    }
    
    /**
     * Configure the global validators for content type
     * @param config The content type configuration
     * @throws ConfigurationException if an error occurs
     */
    protected void _configureGlobalValidators (Configuration config) throws ConfigurationException
    {
        _globalValidators = new ArrayList<>();
        List<String> globalValidatorsToLookup = new ArrayList<>();
        
        Configuration globalValidatorsConfig = config.getChild("global-validators", true);
        globalValidatorsToLookup.addAll(_parseGlobalValidators(new ConfigurationAndPluginName(globalValidatorsConfig, _pluginName), config.getAttributeAsBoolean("include-from-supertype", true)));
        
        List<ConfigurationAndPluginName> overrideConfigurationAndPluginNames = getOverrideConfigurations();
        // Global validators into an overriden configuration are added to the original global validators
        for (ConfigurationAndPluginName overrideConfigurationAndPluginName : overrideConfigurationAndPluginNames)
        {
            Configuration overrideConfiguration = overrideConfigurationAndPluginName.configuration().getChild("global-validators", true);
            globalValidatorsToLookup.addAll(_parseGlobalValidators(new ConfigurationAndPluginName(overrideConfiguration, overrideConfigurationAndPluginName.pluginName()), false));
        }
        
        try
        {
            _globalValidatorsManager.initialize();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to initialize global validator manager", e);
        }
        
        for (String validatorRole : globalValidatorsToLookup)
        {
            try
            {
                ContentValidator contentValidator = _globalValidatorsManager.lookup(validatorRole);
                contentValidator.setContentType(this);
                
                _globalValidators.add(contentValidator);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Unable to lookup global validator role: '" + validatorRole + "' for content type: " + this.getId(), e);
            }
        }
        
    }
    
    /**
     * Parse the global validators
     * @param configurationAndPluginName the configuration
     * @param includeSuperTypeValidators true to include validators of super types
     * @return the role of global validators to be lookuped
     * @throws ConfigurationException if configuration is incorrect
     */
    @SuppressWarnings("unchecked")
    protected List<String> _parseGlobalValidators(ConfigurationAndPluginName configurationAndPluginName, boolean includeSuperTypeValidators) throws ConfigurationException
    {
        List<String> gvRoles = new ArrayList<>();
        
        if (includeSuperTypeValidators)
        {
            for (String superTypeId : _superTypeIds)
            {
                ContentType cType = _cTypeEP.getExtension(superTypeId);
                _globalValidators.addAll(cType.getGlobalValidators());
            }
        }
        
        for (Configuration globalValidatorConfig : configurationAndPluginName.configuration().getChildren("global-validator"))
        {
            String globalValidatorId = __GLOBAL_VALIDATOR_ROLE_PREFIX + RandomStringUtils.randomAlphanumeric(10);
            String validatorClassName = globalValidatorConfig.getAttribute("class");
            
            try
            {
                Class validatorClass = Class.forName(validatorClassName);
                _globalValidatorsManager.addComponent(configurationAndPluginName.pluginName(), null, globalValidatorId, validatorClass, globalValidatorConfig);
            }
            catch (Exception e)
            {
                throw new ConfigurationException("Unable to instantiate global validator for class: " + validatorClassName, e);
            }
            
            gvRoles.add(globalValidatorId);
        }
        
        return gvRoles;
    }
    
    /**
     * Parse the tags and add it to tags list
     * @param configuration the configuration to use
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _configureLocalTags(Configuration configuration)  throws ConfigurationException
    {
        Configuration[] children = configuration.getChildren("tag");
        for (Configuration tagConfig : children)
        {
            String tagValue = tagConfig.getValue();
            if (tagConfig.getAttributeAsBoolean("inheritable", true))
            {
                _inheritableTags.add(tagValue);
            }
            _tags.add(tagValue);
        }
    }
    
    public void initializeAfterModelItemsInitialization() throws Exception
    {
        _checkTitleAttribute();
        _checkContentAttributes(this, 0);
        
        _computePropertiesReferences(this);
        
        _parseViews();
    }
    
    @SuppressWarnings("static-access")
    private void _checkTitleAttribute() throws ConfigurationException
    {
        if (!isAbstract() && !isMixin())
        {
            ModelItem titleItem = null;
            if (hasModelItem(Content.ATTRIBUTE_TITLE))
            {
                titleItem = getModelItem(Content.ATTRIBUTE_TITLE);
            }
            else
            {
                // The title attribute is mandatory for non abstract content types
                throw new ConfigurationException("An attribute 'title' in content type '" + getId() + "' should be defined.");
            }
            
            // The title attribute should'nt be a group item
            if (!(titleItem instanceof ElementDefinition))
            {
                throw new ConfigurationException("An attribute 'title' in content type '" + getId() + "' should be defined.");
            }
            
            // The title attribute should be a string or a multilingual string
            ElementDefinition titleAttribute = (ElementDefinition) titleItem;
            String typeId = titleAttribute.getType().getId();
            if (!ModelItemTypeConstants.STRING_TYPE_ID.equals(typeId) && !ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID.equals(typeId))
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' is defined with the type '" + typeId + "'. Only '" + ModelItemTypeConstants.STRING_TYPE_ID + "' and '" + ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID + "' are allowed");
            }
            
            // The title attribute should not be multiple
            if (titleAttribute.isMultiple())
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' should not be multiple.");
            }
            
            // The title attribute must be mandatory
            Validator titleValidator = titleAttribute.getValidator();
            if (titleValidator == null || !(boolean) titleValidator.getConfiguration().get("mandatory"))
            {
                throw new ConfigurationException("The attribute 'title' in content type '" + getId() + "' should be mandatory.");
            }
        }
    }
    
    /**
     * Check for each content attribute: the content type id, the mutual references and the default values
     * @param modelItemContainer the {@link ModelItemContainer} to check
     * @param repeaterLevel the current nested level of repeaters, 0 if the current attribute isn't in a repeater.
     * @throws ConfigurationException if a content attribute has an invalid configuration
     */
    protected void _checkContentAttributes(ModelItemContainer modelItemContainer, int repeaterLevel) throws ConfigurationException
    {
        for (ModelItem modelItem : modelItemContainer.getModelItems())
        {
            if (modelItem instanceof ContentAttributeDefinition definition)
            {
                _checkContentTypeId(definition);
                _checkMutualReferences(definition, repeaterLevel);
                definition.checkDefaultValue();
            }
            
            // Check sub-attributes
            if (modelItem instanceof ModelItemContainer)
            {
                // Increment the repeater level if the current attribute is a repeater.
                int newRepeaterLevel = (modelItem instanceof org.ametys.plugins.repository.model.RepeaterDefinition) ? repeaterLevel + 1 : repeaterLevel;
                _checkContentAttributes((ModelItemContainer) modelItem, newRepeaterLevel);
            }
        }
    }
    
    /**
     * Check the content type id of the given content attribute definition
     * @param definition the definition to check
     * @throws ConfigurationException if the given content attribute references an invalid or non-existing content type.
     */
    protected void _checkContentTypeId(ContentAttributeDefinition definition) throws ConfigurationException
    {
        String contentTypeId = definition.getContentTypeId();
        
        if (StringUtils.isNotBlank(contentTypeId) && !_cTypeEP.hasExtension(contentTypeId))
        {
            throw new ConfigurationException("The content attribute of path " + definition.getPath() + " in content type " + getId() + " references a nonexistent content-type: '" + contentTypeId + "'");
        }
    }
    
    /**
     * Check the mutual reference declaration of the given content attribute definition
     * @param definition the definition to check
     * @param repeaterLevel the current nested level of repeaters, 0 if the current attribute isn't in a repeater.
     * @throws ConfigurationException if there is a problem with mutual reference declaration
     */
    protected void _checkMutualReferences(ContentAttributeDefinition definition, int repeaterLevel) throws ConfigurationException
    {
        String contentTypeId = definition.getContentTypeId();
        String invertRelationPath = definition.getInvertRelationPath();

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

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

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

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

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

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

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

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

                // Ensure that the referenced attribute references this attribute.
                if (!currentAttributePath.equals(invertPath))
                {
                    throw new ConfigurationException("Mutual relationship: the attribute at path " + currentAttributePath + " of type " + getId() + " references the attribute '" + invertRelationPath + "' of type " + contentTypeId + " but the latter does not reference it back.");
                }
            }
            catch (UndefinedItemPathException e)
            {
                // Ensure the referenced attribute presence.
                throw new ConfigurationException("Mutual relationship: the attribute at path '" + invertRelationPath + "' doesn't exist for type " + contentTypeId);
            }
        }
    }
    
    /**
     * Parses the content type views
     * @throws ConfigurationException if an error occurred
     */
    protected void _parseViews() throws ConfigurationException
    {
        Map<String, ViewConfigurationsByType> allViewConfigurations = _mergeViewConfigurationsFromCurrentTypeAndSuperTypes();
        for (String viewName : allViewConfigurations.keySet())
        {
            ViewConfigurationsByType viewConfigurationsByType = allViewConfigurations.get(viewName);
            View view = _contentTypesParserHelper.parseView(this, viewConfigurationsByType);
            _views.put(viewName, view);
        }
        
        // Check that mandatory views aren't missing
        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);
            }
        }
    }
    
    /**
     * Retrieves the merge of the view configurations between the current content type and its super types 
     * @return the merge of the view configurations
     * @throws ConfigurationException if an error occurs
     */
    protected Map<String, ViewConfigurationsByType> _mergeViewConfigurationsFromCurrentTypeAndSuperTypes() throws ConfigurationException
    {
        Map<String, ViewConfigurationsByType> applicableViewConfigurationsByType = new HashMap<>();
        
        for (String viewName : _viewConfigurations.keySet())
        {
            ViewConfigurations currentTypeViewConfigurations = _viewConfigurations.get(viewName);
            Map<ContentType, ConfigurationAndPluginName> mainConfiguration = currentTypeViewConfigurations.mainConfiguration().isPresent()
                    ? Map.of(this, currentTypeViewConfigurations.mainConfiguration().get())
                    : Map.of();
            Map<ContentType, List<ConfigurationAndPluginName>> overrides = !currentTypeViewConfigurations.overrides().isEmpty()
                    ? Map.of(this, currentTypeViewConfigurations.overrides())
                    : Map.of();
            ViewConfigurationsByType currentTypeViewConfigurationsByType = new ViewConfigurationsByType(viewName, mainConfiguration, overrides);
            applicableViewConfigurationsByType.put(viewName, currentTypeViewConfigurationsByType);
        }
        
        Map<String, ViewConfigurationsByType> superTypesApplicableViewConfigurations = _contentTypesHelper.getViewConfigurations(_superTypeIds, new String[0]);
        for (String viewName : superTypesApplicableViewConfigurations.keySet())
        {
            if (!_viewConfigurations.containsKey(viewName) || _viewConfigurations.get(viewName).mainConfiguration().isEmpty())
            {
                ViewConfigurationsByType superTypeViewConfigurations = superTypesApplicableViewConfigurations.get(viewName);
                if (_viewConfigurations.containsKey(viewName))
                {
                    superTypeViewConfigurations.overrides()
                                               .put(this, _viewConfigurations.get(viewName).overrides());
                }
                
                applicableViewConfigurationsByType.put(viewName, superTypeViewConfigurations);
            }
        }
        
        return applicableViewConfigurationsByType;
    }
    
    @Override
    public void initializeAfterViewsInitialization() throws Exception
    {
        _resolveViewReferences();
    }
    
    /**
     * Resolve the temporary view references
     * @throws ConfigurationException if a view reference has a configuration error (the content attribute nesting the reference does not specify any content type, the view does not exist, ...)
     */
    protected void _resolveViewReferences() throws ConfigurationException
    {
        for (String viewName : getViewNames())
        {
            View view = getView(viewName);
            _resolveViewReferences(view, viewName);
        }
    }
    
    /**
     * Resolve the temporary view references in the given {@link ViewItemAccessor}
     * @param viewItemAccessor the {@link ViewItemAccessor}
     * @param currentViewName the name of the current view (to avoid views referencing themselves)
     * @throws ConfigurationException if a view reference has a configuration error (the content attribute nesting the reference does not specify any content type, the view does not exist, ...)
     */
    protected void _resolveViewReferences(ViewItemAccessor viewItemAccessor, String currentViewName) throws ConfigurationException
    {
        boolean hasResolvedReferences = false;
        List<ViewItem> viewItemsWithResolvedReferences = new ArrayList<>();
        for (ViewItem viewItem : viewItemAccessor.getViewItems())
        {
            if (viewItem instanceof TemporaryViewReference)
            {
                assert viewItemAccessor instanceof ViewElement;
                
                ElementDefinition definition = ((ViewElement) viewItemAccessor).getDefinition();
                assert definition instanceof ContentAttributeDefinition;
                
                String contentTypeId = ((ContentAttributeDefinition) definition).getContentTypeId();
                if (contentTypeId != null)
                {
                    Set<String> ancestors = _contentTypesHelper.getAncestors(this.getId());
                    if (!(ancestors.contains(contentTypeId) && currentViewName.equals(viewItem.getName())))
                    {
                        ContentType contentType = _cTypeEP.getExtension(contentTypeId);
                        View view = contentType.getView(viewItem.getName());
                        if (view != null)
                        {
                            hasResolvedReferences = true;
                            viewItemsWithResolvedReferences.addAll(view.getViewItems());
                        }
                        else
                        {
                            throw new ConfigurationException("The view '" + viewItem.getName() + "' does not exist in content type '" + contentTypeId + "' referenced by the attribute named '" + definition.getName() + "'.");
                        }
                    }
                    else
                    {
                        throw new ConfigurationException("The view '" + viewItem.getName() + "' cannot make a reference to itself.");
                    }
                }
                else
                {
                    throw new ConfigurationException("The attribute '" + definition.getName() + "' doesn't reference any content type. It is not possible to add the items of the view '" + viewItem.getName() + "'.");
                }
            }
            else
            {
                if (viewItem instanceof ViewItemAccessor)
                {
                    _resolveViewReferences((ViewItemAccessor) viewItem, currentViewName);
                }
                viewItemsWithResolvedReferences.add(viewItem);
            }
        }
        
        if (hasResolvedReferences)
        {
            viewItemAccessor.clear();
            viewItemAccessor.addViewItems(viewItemsWithResolvedReferences);
        }
    }
    
    /**
     * Browses the model items of the given {@link ModelItemContainer} and computes properties references.
     * @param modelItemContainer the model item container
     * @throws ConfigurationException if a property references a model item that does not exist
     */
    protected void _computePropertiesReferences(ModelItemContainer modelItemContainer) throws ConfigurationException
    {
        for (ModelItem modelItem : modelItemContainer.getModelItems())
        {
            if (modelItem instanceof ElementRefProperty elementRefProperty)
            {
                String itemPath = elementRefProperty.getElementPath();
                
                if (!hasModelItem(itemPath) || !(getModelItem(itemPath) instanceof ElementDefinition))
                {
                    throw new ConfigurationException("Property for path '" + itemPath + "' does not correspond to an attribute of this content type");
                }

                List<ModelItem> referencedModelItems = _contentTypesHelper.getModelItemPath(itemPath, this);
                
                List<String> joinPaths = new ArrayList<>();
                boolean localContentType = true;
                StringBuilder currentContentPath = new StringBuilder();
                for (ModelItem referencedModelItem : referencedModelItems)
                {
                    if (currentContentPath.length() > 0)
                    {
                        currentContentPath.append(ModelItem.ITEM_PATH_SEPARATOR);
                    }
                    currentContentPath.append(referencedModelItem.getName());
                    
                    if (ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(referencedModelItem.getType().getId()))
                    {
                        if (!localContentType)
                        {
                            joinPaths.add(currentContentPath.toString());
                            currentContentPath.setLength(0);
                            
                            Map<String, List<String>> cTypeRefs = _propertiesReferences.computeIfAbsent(referencedModelItem.getModel().getId(), __ -> new LinkedHashMap<>());
                            cTypeRefs.put(elementRefProperty.getPath(), new ArrayList<>(joinPaths));
                        }
                        
                        localContentType = false;
                    }
                }
            }
            else if (modelItem instanceof ModelItemGroup group)
            {
                _computePropertiesReferences(group);
            }
        }
    }
    
    @Override
    public List<ContentValidator> getGlobalValidators()
    {
        return Collections.unmodifiableList(_globalValidators);
    }
    
    @Override
    public RichTextUpdater getRichTextUpdater()
    {
        return _richTextUpdater;
    }
    
    @Override
    public Set<String> getTags()
    {
        return Collections.unmodifiableSet(_tags);
    }
    
    @Override
    public Set<String> getInheritableTags()
    {
        return Collections.unmodifiableSet(_inheritableTags);
    }
    
    @Override
    public boolean hasTag(String tagName)
    {
        return _tags.contains(tagName);
    }
    
    @Override
    public boolean isPrivate()
    {
        return hasTag(TAG_PRIVATE);
    }
    
    @Override
    public boolean isAbstract()
    {
        return _abstract;
    }
    
    @Override
    public boolean isSimple()
    {
        return _isSimple;
    }

    @Override
    public boolean isReferenceTable()
    {
        return hasTag(TAG_REFERENCE_TABLE) || hasTag(TAG_RENDERABLE_FERENCE_TABLE);
    }
    
    @Override
    public boolean isMultilingual()
    {
        return _isMultilingual;
    }
    
    @Override
    public boolean isMixin()
    {
        return hasTag(TAG_MIXIN);
    }
    
    @Override
    public Set<String> getConfiguredDefaultWorkflowNames()
    {
        return _configuredWorkflowNames;
    }
    
    @Override
    public Optional<String> getDefaultWorkflowName()
    {
        return _defaultWorkflowName;
    }
    
    @Override
    public String getRight()
    {
        return _right;
    }
    
    @Override
    public void saxContentTypeAdditionalData(org.xml.sax.ContentHandler contentHandler, Content content) throws AmetysRepositoryException, SAXException
    {
        // Nothing
    }
    
    @Override
    public Map<String, Object> getAdditionalData(Content content)
    {
        return new HashMap<>();
    }
    
    @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);
    }
    
    public Optional<ContentAttributeDefinition> getParentAttributeDefinition()
    {
        return Optional.ofNullable(_parentAttributeDefinition);
    }
    
    public Collection<ModelItem> getModelItems()
    {
        return Collections.unmodifiableCollection(_modelItems.values());
    }
    
    public Map<String, Map<String, List<String>>> getPropertiesReferences()
    {
        return _propertiesReferences;
    }
    
    public Set<String> getViewNames(boolean includeInternals)
    {
        if (includeInternals)
        {
            return Collections.unmodifiableSet(_views.keySet());
        }
        else
        {
            return _views.entrySet()
                         .stream()
                         .filter(entry -> !entry.getValue().isInternal())
                         .map(Map.Entry::getKey)
                         .collect(Collectors.toSet());
        }
    }
    
    public View getView(String viewName)
    {
        return _views.get(viewName);
    }
    
    public Map<String, ViewConfigurations> getViewConfigurations()
    {
        return _viewConfigurations;
    }
    
    /**
     * Get the overridden views list
     *  @return the overridden views list
     */
    public List<String> getOverriddenViews()
    {
        return this._overriddenViews;
    }
    
    public Optional<ViewConfigurations> getViewConfigurations(String viewName)
    {
        return Optional.ofNullable(_viewConfigurations.get(viewName));
    }
    
    public String getFamilyId()
    {
        return ContentTypeExtensionPoint.ROLE;
    }
}