/*
 *  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.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.transformation.RichTextTransformer;
import org.ametys.cms.transformation.docbook.DocbookOutgoingReferencesExtractor;
import org.ametys.cms.transformation.docbook.DocbookTransformer;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.AbstractParameterParser;
import org.ametys.runtime.parameter.Enumerator;
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;
import com.opensymphony.workflow.spi.Step;

/**
 * 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<>();
    /** 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 workflow provider */
    protected WorkflowProvider _workflowProvider;
    /** The rights manager. */
    protected RightManager _rightManager;
    /** Current user provider. */
    protected CurrentUserProvider _currentUserProvider;
    /** 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;
    
    // ComponentManager pour les Validator
    private ThreadSafeComponentManager<Validator> _validatorManager;
    
    // ComponentManager pour les Global Validators
    private ThreadSafeComponentManager<ContentValidator> _globalValidatorsManager;
    
    //ComponentManager pour les Enumerator
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    // ComponentManager pour les CustomIndexingField
    private ThreadSafeComponentManager<CustomIndexingField> _customFieldManager;

    // ComponentManager pour les CustomMetadataIndexingField
    private ThreadSafeComponentManager<CustomMetadataIndexingField> _customMetadataIndexingFieldManager;

    private boolean _isSimple;

    private boolean _isMultilingual;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _manager = manager;
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _richTextTransformer = (RichTextTransformer) manager.lookup(DocbookTransformer.ROLE);
        _richTextOutgoingReferencesExtractor = (RichTextOutgoingReferencesExtractor) manager.lookup(DocbookOutgoingReferencesExtractor.ROLE);
        _richTextUpdater = (RichTextUpdater) manager.lookup(DocbookRichTextUpdater.ROLE);
        _hierarchicalSimpleContentsHelper = (HierarchicalReferenceTablesHelper) manager.lookup(HierarchicalReferenceTablesHelper.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()
    {
        _validatorManager.dispose();
        _validatorManager = null;
        
        _globalValidatorsManager.dispose();
        _globalValidatorsManager = 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
    {
        _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);
        
        _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;
            }
        }
        
        // Metadata definitions
        _configureMetadataDefinitions (rootConfiguration);
        
        // Parent content type
        _configureParentContentType(rootConfiguration);
        
        // Metadata sets
        _configureMetadataSets (rootConfiguration);
        
        if (!_abstract && !hasTag(TAG_MIXIN))
        {
            if (!_allMetadataSetsForView.containsKey("details"))
            {
                throw new ConfigurationException("Mandatory metadata-set for view named 'details' is missing for content type " + _id);
            }
            if (!_allMetadataSetsForView.containsKey("main"))
            {
                throw new ConfigurationException("Mandatory metadata-set for view named 'main' is missing for content type " + _id);
            }
            if (!_allMetadataSetsForEdition.containsKey("main"))
            {
                throw new ConfigurationException("Mandatory metadata-set for edition named 'main' is missing for content type " + _id);
            }
        }
        
        // Global validators
        _configureGlobalValidators (rootConfiguration);
        
        // Indexing model
        _configureIndexingModel (rootConfiguration);
    }
    
    /**
     * Configure metadata definitions
     * @param mainConfig The content type configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureMetadataDefinitions (Configuration mainConfig) throws ConfigurationException
    {
        MetadataAndRepeaterDefinitionParser defParser = new MetadataAndRepeaterDefinitionParser(_enumeratorManager, _validatorManager);
        
        // First, get metadata from super type if applicable.
        _metadata.putAll(_contentTypesHelper.getMetadataDefinitions(_superTypeIds));
        
        Map<String, Configuration> metadataConfiguration = new LinkedHashMap<>();
        
        _getApplicableMetadata(mainConfig, metadataConfiguration, false);
        
        Configuration overriddenConfig = getOverridenConfiguration();
        if (overriddenConfig != null)
        {
            _getApplicableMetadata(overriddenConfig, metadataConfiguration, true);
        }
        
        // Then, parse own metadata
        _parseAllMetadatas(metadataConfiguration, defParser);
        
        try
        {
            defParser.lookupComponents();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to lookup parameter local components", overriddenConfig, e);
        }
        
    }
    
    /**
     * 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
     */
    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 global validators for content type
     * @param config The content type configuration
     * @throws ConfigurationException if an error occured
     */
    @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);
            }
        }
        
    }
    
    /**
     * Fill a map of the applicable metadata configurations.
     * @param config the content type configuration.
     * @param metadataConfigurations the Map of metadata {@link Configuration}, indexed by name.
     * @param allowOverride if true, encountering a metadata 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 _getApplicableMetadata(Configuration config, Map<String, Configuration> metadataConfigurations, boolean allowOverride) throws ConfigurationException
    {
        for (Configuration childConfiguration : config.getChildren())
        {
            String childName = childConfiguration.getName();
            
            if (childName.equals("metadata") || childName.equals("repeater"))
            {
                String metadataName = childConfiguration.getAttribute("name", "");
                
                if (!allowOverride && metadataConfigurations.containsKey(metadataName))
                {
                    throw new ConfigurationException("Metadata with name '" + metadataName + "' is already defined", childConfiguration);
                }
                else if (allowOverride && metadataConfigurations.containsKey(metadataName))
                {
                    _checkMetadataTypes (metadataConfigurations.get(metadataName), childConfiguration);
                }
                
                metadataConfigurations.put(metadataName, childConfiguration);
            }
            else if (childName.equals("dublin-core"))
            {
                metadataConfigurations.put("dc", childConfiguration);
            }
        }
    }
    
    /**
     * Parse all metadata configurations.
     * @param metadataConfigurations the metadata configurations.
     * @param defParser the metadata definition parser.
     * @throws ConfigurationException if the configuration is invalid.
     */
    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
     */
    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
     */
    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 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 _checkMetadataTypes (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)
                    {
                        _checkMetadataTypes (childConfig1, childConfig2);
                    }
                }
            }
        }
    }
    
    /**
     * 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
     */
    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
     */
    protected void _parseDublinCoreMetadata (MetadataAndRepeaterDefinitionParser defParser) throws ConfigurationException
    {
        Source src = null;
        
        try
        {
            src = _srcResolver.resolveURI("resource://org/ametys/cms/dublincore/dublincore.xml");
            
            if (src.exists())
            {
                Configuration configuration = null;
                try (InputStream is = src.getInputStream())
                {
                    configuration = new DefaultConfigurationBuilder(true).build(is);
                }
                
                MetadataDefinition metadataDefinition = new MetadataDefinition();
                metadataDefinition.setReferenceContentType(_id);
                metadataDefinition.setId("/dc"); // FIXME ?
                metadataDefinition.setLabel(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_LABEL"));
                metadataDefinition.setDescription(new I18nizableText("plugin.cms", "PLUGINS_CMS_DUBLINCORE_DESC"));
                metadataDefinition.setName("dc");
                metadataDefinition.setType(MetadataType.COMPOSITE);
                
                for (Configuration childConfiguration : configuration.getChildren())
                {
                    String childName = childConfiguration.getName();
                    
                    if (childName.equals("metadata"))
                    {
                        MetadataDefinition metaDef = defParser.parseParameter(_manager, _pluginName, childConfiguration);
                        metaDef.setReferenceContentType(_id);
                        String metadataName = metaDef.getName();
                        metaDef.setId("/dc/" + metadataName);  // FIXME ?
                        
                        if (metaDef.getEnumerator() == null && _dcProvider.isEnumerated(metadataName))
                        {
                            StaticEnumerator enumerator = new StaticEnumerator();
                            
                            Map<String, I18nizableText> entries = _dcProvider.getEntries(metadataName);
                            if (entries != null)
                            {
                                for (String value : entries.keySet())
                                {
                                    enumerator.add(entries.get(value), value);
                                }
                               
                            }
                            metaDef.setEnumerator(enumerator);
                        }
                        
                        metadataDefinition.addMetadata(metaDef);
                    }
                }
                
                _metadata.put("dc", metadataDefinition);
            }
        }
        catch (IOException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core metadata", e);
        }
        catch (SAXException e)
        {
            throw new ConfigurationException("Unable to parse Dublin Core metadata", e);
        }
        finally
        {
            if (src != null)
            {
                _srcResolver.release(src);
            }
        }
    }
    
    /**
     * Configure the 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
    {
        _checkContentMetadatas();
        _checkContentMutualReferences();
        
        _computeIndexingModelReferences();
    }
    
    /**
     * Check that content and sub-content metadatas reference a valid content-type.
     * @throws ConfigurationException if a content (or sub-content) metadata references an invalid or non-existing content type.
     */
    protected void _checkContentMetadatas() throws ConfigurationException
    {
        for (MetadataDefinition metadataDef : _metadata.values())
        {
            _checkContentMetadata(metadataDef, metadataDef.getName());
        }
    }
    
    /**
     * Recursively check that content and sub-content metadatas reference a valid content-type.
     * @param metadataDef the metadata definition.
     * @param metadataPath the metadata path.
     * @throws ConfigurationException if a content (or sub-content) metadata references an invalid or non-existing content type.
     */
    protected void _checkContentMetadata(MetadataDefinition metadataDef, String metadataPath) throws ConfigurationException
    {
        if (metadataDef.getType() == MetadataType.CONTENT || metadataDef.getType() == MetadataType.SUB_CONTENT)
        {
            String cTypeId = metadataDef.getContentType();
            
            if (StringUtils.isNotBlank(cTypeId) && !_cTypeEP.hasExtension(cTypeId))
            {
                throw new ConfigurationException("The content metadata of path " + metadataPath + " in content type " + getId() + " references a non-existing content-type: '" + cTypeId + "'");
            }
        }
        
        // Check sub-metadatas.
        for (String subMetaName : metadataDef.getMetadataNames())
        {
            MetadataDefinition subMetaDef = metadataDef.getMetadataDefinition(subMetaName);
            String subMetaPath = metadataPath + "/" + subMetaName;
            
            _checkContentMetadata(subMetaDef, subMetaPath);
        }
    }
    
    /**
     * Check content type mutual reference declarations.
     * @throws ConfigurationException if there is a problem with mutual reference declarations.
     */
    protected void _checkContentMutualReferences() throws ConfigurationException
    {
        for (MetadataDefinition metadataDef : _metadata.values())
        {
            _checkContentMutualReferences(metadataDef, metadataDef.getName(), 0);
        }
    }
    
    /**
     * Recursively check a content type mutual reference declarations.
     * @param metadataDef the metadata definition.
     * @param metadataPath the metadata path.
     * @param repeaterLevel the current nested level of repeaters, 0 if the current metadata isn't in a repeater.
     * @throws ConfigurationException if there is a problem with mutual reference declarations.
     */
    protected void _checkContentMutualReferences(MetadataDefinition metadataDef, String metadataPath, int repeaterLevel) throws ConfigurationException
    {
        if (metadataDef.getType() == MetadataType.CONTENT)
        {
            String cTypeId = metadataDef.getContentType();
            String invertRelationPath = metadataDef.getInvertRelationPath();
            
            if (StringUtils.isNotEmpty(invertRelationPath))
            {
                ContentType cType = _cTypeEP.getExtension(cTypeId);
                MetadataDefinition invertMetadataDef = cType.getMetadataDefinitionByPath(invertRelationPath);
                
                if (repeaterLevel > 0 && metadataDef.isMultiple())
                {
                    throw new ConfigurationException("The metadata at path '" + metadataPath + "' 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 metadata at path '" + metadataPath + "' in content type " + getId() + " is declared as a mutual relationship, it can't be in two levels of repeaters.");
                }
                
                // Ensure the metadata presence.
                if (invertMetadataDef == null)
                {
                    throw new ConfigurationException("Mutual relationship: the metadata at path '" + invertRelationPath + "' doesn't exist for type " + cTypeId);
                }
                
                // Ensure that the referenced metadata is a Content.
                if (invertMetadataDef.getType() != MetadataType.CONTENT)
                {
                    throw new ConfigurationException("Mutual relationship: the metadata at path '" + invertRelationPath + "' of type " + cTypeId + " is not of type Content.");
                }
                
                String invertCTypeId = invertMetadataDef.getContentType();
                String invertPath = invertMetadataDef.getInvertRelationPath();
                
                // Ensure that the referenced metadata's content type is compatible with the current type.
                if (!_cTypeEP.isSameOrDescendant(getId(), invertCTypeId))
                {
                    throw new ConfigurationException("Mutual relationship: the metadata at path " + invertRelationPath + " of type " + cTypeId + " references an incompatible type: " + StringUtils.defaultString(invertCTypeId, "<null>"));
                }
                
                // Ensure that the referenced metadata references this metadata.
                if (!metadataPath.equals(invertPath))
                {
                    throw new ConfigurationException("Mutual relationship: the metadata at path " + metadataPath + " of type " + getId() + " references the metadata '" + invertRelationPath + "' of type " + cTypeId + " but the latter does not reference it back.");
                }
            }
        }
        
        // We are in a repeater if we were already in a repeater at the previous level, or if the current metadata definition is a repeater.
        int newRepeaterLevel = (metadataDef instanceof RepeaterDefinition) ? repeaterLevel + 1 : repeaterLevel;
        
        // Check sub-metadatas.
        for (String subMetaName : metadataDef.getMetadataNames())
        {
            MetadataDefinition subMetaDef = metadataDef.getMetadataDefinition(subMetaName);
            String subMetaPath = metadataPath + ContentConstants.METADATA_PATH_SEPARATOR + subMetaName;
            
            _checkContentMutualReferences(subMetaDef, subMetaPath, 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);
        
        if (restrictions == null)
        {
            return true;
        }
            
        if (restrictions._cannotRead)
        {
            return false;
        }
        
        if (content == null)
        {
            // Unable to check right (content is not yet created), assume user has right 
            return true;
        }
        
        boolean hasRights = _hasRights(content, restrictions._readRights);
        
        if (!hasRights)
        {
            return false;
        }
        
        if (content instanceof WorkflowAwareContent)
        {
            hasRights = _isInWorkflowStep((WorkflowAwareContent) content, restrictions._readWfSteps);
            
            if (!hasRights)
            {
                return false;
            }
        }
        
        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);
        
        if (restrictions == null)
        {
            return true;
        }
    
        if (restrictions._cannotWrite)
        {
            return false;
        }
     
        if (content == null)
        {
            // Unable to check right (content is not yet created), assume user has right 
            return true;
        }
        
        boolean hasRights = _hasRights(content, restrictions._writeRights);
        
        if (!hasRights)
        {
            return false;
        }
        
        if (content instanceof WorkflowAwareContent)
        {
            hasRights = _isInWorkflowStep((WorkflowAwareContent) content, restrictions._writeWfSteps);
            
            if (!hasRights)
            {
                return false;
            }
        }
        
        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;
    }

    /**
     * Check if current user has the given rights.
     * @param rightLimitations the right limitations.
     * @param content the content.
     * @return <code>true</code> if it is on at least one step,
     *         <code>false</code> otherwise.
     */
    protected boolean _hasRights(Content content, Set<String> rightLimitations)
    {
        if (rightLimitations.isEmpty())
        {
            return true;
        }

        UserIdentity user = _currentUserProvider.getUser();

        for (String rightId : rightLimitations)
        {
            if (_rightManager.hasRight(user, rightId, content) == RightResult.RIGHT_ALLOW)
            {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if the workflow of the content is in a given current step.
     * @param workflowLimitations the workflow limitations.
     * @param content the content.
     * @return <code>true</code> if it is on at least one step,
     *         <code>false</code> otherwise.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected boolean _isInWorkflowStep(WorkflowAwareContent content, Set<Integer> workflowLimitations) throws AmetysRepositoryException
    {
        if (workflowLimitations.isEmpty())
        {
            return true;
        }
        
        AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(content);
        
        List<Step> workflowCurrentSteps = workflow.getCurrentSteps(content.getWorkflowId());
        
        for (Step step : workflowCurrentSteps)
        {
            for (int stepId : workflowLimitations)
            {
                if (step.getStepId() == stepId)
                {
                    return true;
                }
            }
        }

        // No match
        return false;
    }
    
    @Override
    public String toString()
    {
        return "'" + getId() + "'";
    }
    
    /**
     * Restrictions provided with a metadata definition.
     */
    protected static class Restrictions
    {
        /** Cannot read status. */
        protected boolean _cannotRead;
        /** Cannot write status. */
        protected boolean _cannotWrite;
        /** Read right ids. */
        protected Set<String> _readRights = new HashSet<>();
        /** Write right ids. */
        protected Set<Integer> _readWfSteps = new HashSet<>();
        /** Read workflow step ids. */
        protected Set<String> _writeRights = new HashSet<>();
        /** Write workflow step ids. */
        protected Set<Integer> _writeWfSteps = new HashSet<>();
    }
    
    /**
     * Restricted definition.
     */
    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.
     */
    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.
     */
    protected static class RestrictedRichTextDefinition extends RichTextMetadataDefinition  implements RestrictedDefinition
    {
        /** Restrictions. */
        protected Restrictions _restrictions = new Restrictions();
        
        @Override
        public Restrictions getRestrictions()
        {
            return _restrictions;
        }
    }
    
    /**
     * Internal {@link RepeaterDefinition} storage contains instances of this class.
     */
    protected static class RestrictedRepeaterDefinition extends RepeaterDefinition implements RestrictedDefinition
    {
        /** Restrictions. */
        protected Restrictions _restrictions = new Restrictions();
        
        @Override
        public Restrictions getRestrictions()
        {
            return _restrictions;
        }
    }
    
    /**
     * {@link RestrictedMetadataDefinition} and {@link RestrictedRepeaterDefinition} parser.
     */
    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<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 RepeaterDefinition)
            {
                RepeaterDefinition repeaterDefinition = (RepeaterDefinition) metadataDefinition;
                
                _parseRepeaterDefinition(manager, pluginName, metadataConfiguration, repeaterDefinition);
            }
            
            if (metadataDefinition instanceof AnnotableDefinition)
            {
                AnnotableDefinition definitionWithSemAnnotations = (AnnotableDefinition) metadataDefinition;
                
                _parseDefinitionWithAnnotations(manager, pluginName, metadataConfiguration, definitionWithSemAnnotations);
            }
            
            _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, 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;
        }

        /**
         * Populates the restrictions into a metadata definition.
         * @param metadataConfiguration the metadata configuration to use.
         * @param restrictions the restrictions.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _populateRestrictions(Configuration metadataConfiguration, Restrictions restrictions) throws ConfigurationException
        {
            Configuration restrictToConf = metadataConfiguration.getChild("restrict-to", true);

            _populateNegativeRestrictions(restrictToConf, restrictions);
            _populateRightRestrictions(restrictToConf, restrictions);
            _populateWorkflowRestrictions(restrictToConf, restrictions);
        }

        /**
         * Populates the negative restrictions.
         * @param restrictionsConfig the restrictions configuration to use.
         * @param restrictions the restrictions.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _populateNegativeRestrictions(Configuration restrictionsConfig, Restrictions restrictions) throws ConfigurationException
        {
            for (Configuration noRightConfig : restrictionsConfig.getChildren("cannot"))
            {
                boolean isRead = _parseAccessType(noRightConfig);
                
                if (isRead)
                {
                    restrictions._cannotRead = true;
                }
                else
                {
                    restrictions._cannotWrite = true;
                }
            }
        }

        /**
         * Parses type attribute from a configuration.
         * @param configuration the configuration.
         * @return <code>true</code> for <code>read</code> type,
         *         <code>false</code> for <code>write</code> type.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected boolean _parseAccessType(Configuration configuration) throws ConfigurationException
        {
            String type = configuration.getAttribute("read-write-direction");
            
            if ("read".equalsIgnoreCase(type))
            {
                return  true;
            }
            else if ("write".equalsIgnoreCase(type))
            {
                return false;
            }
            else
            {
                throw new ConfigurationException("Attribute 'type' must be 'read' or 'write'.", configuration);
            }
        }

        /**
         * Populates the rights restrictions.
         * @param restrictionsConfig the restrictions configuration to use.
         * @param restrictions the restrictions.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _populateRightRestrictions(Configuration restrictionsConfig, Restrictions restrictions) throws ConfigurationException
        {
            for (Configuration rightConfig : restrictionsConfig.getChildren("right"))
            {
                String rightId = rightConfig.getAttribute("id", null);
                
                if (rightId == null)
                {
                    throw new ConfigurationException("Attribute 'id' is mandatory on 'right' element in a content tye configuration.", rightConfig);
                }

                boolean isRead = _parseAccessType(rightConfig);
                
                if (isRead)
                {
                    restrictions._readRights.add(rightId);
                }
                else
                {
                    restrictions._writeRights.add(rightId);
                }
            }
        }

        /**
         * Populates the workflows restrictions.
         * @param restrictionsConfig the restrictions configuration to use.
         * @param restrictions the restrictions.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected void _populateWorkflowRestrictions(Configuration restrictionsConfig, Restrictions restrictions) throws ConfigurationException
        {
            for (Configuration workflowConfig : restrictionsConfig.getChildren("workflow"))
            {
                String stepId = workflowConfig.getAttribute("step", null);
                int stepIdValue = -1;
                
                if (stepId != null)
                {
                    try
                    {
                        stepIdValue = Integer.valueOf(stepId);
                    }
                    catch (NumberFormatException e)
                    {
                        // Handled just below
                    }
                }
                
                if (stepIdValue == -1)
                {
                    throw new ConfigurationException("Attribute 'step' is mandatory and must be an integer on 'workflow' element in a content type configuration.", workflowConfig);
                }

                boolean isRead = _parseAccessType(workflowConfig);
                
                if (isRead)
                {
                    restrictions._readWfSteps.add(stepIdValue);
                }
                else
                {
                    restrictions._writeWfSteps.add(stepIdValue);
                }
            }
        }
    }
    
    @Override
    public MetadataDefinition getParentMetadata()
    {
        return _parentMetadataName != null ? _metadata.get(_parentMetadataName) : null;
    }
}