/*
 *  Copyright 2013 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.search.ui.model;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
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.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.ui.model.impl.IndexingFieldSearchUICriterion;
import org.ametys.cms.search.ui.model.impl.MetadataSearchUIColumn;
import org.ametys.cms.search.ui.model.impl.SystemSearchUIColumn;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * Static implementation of a {@link AbstractSearchUIModel}
 */
public class StaticSearchUIModel extends AbstractSearchUIModel implements Configurable, Disposable
{
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The helper for columns */
    protected ColumnHelper _columnHelper;
    
    /** ComponentManager for {@link SearchUICriterion}s. */
    protected ThreadSafeComponentManager<SearchUICriterion> _searchCriterionManager;
    
    /** ComponentManager for {@link SearchUIColumn}s. */
    protected ThreadSafeComponentManager<SearchUIColumn> _searchColumnManager;
    
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _systemPropEP;
    
    private int _criteriaIndex;
    
    private int _pageSize;
    private String _workspace;
    private String _searchUrl;
    private String _searchUrlPlugin;
    private String _exportCSVUrl;
    private String _exportCSVUrlPlugin;
    private String _exportDOCUrl;
    private String _exportDOCUrlPlugin;
    private String _exportXMLUrl;
    private String _exportXMLUrlPlugin;
    private String _printUrl;
    private String _printUrlPlugin;
    private String _summaryView;
    private boolean _sortOnMultipleJoin;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _columnHelper = (ColumnHelper) manager.lookup(ColumnHelper.ROLE);
        _systemPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        try
        {
            _searchCriterionManager = new ThreadSafeComponentManager<>();
            _searchCriterionManager.setLogger(getLogger());
            _searchCriterionManager.contextualize(_context);
            _searchCriterionManager.service(_manager);
            
            _searchColumnManager = new ThreadSafeComponentManager<>();
            _searchColumnManager.setLogger(getLogger());
            _searchColumnManager.contextualize(_context);
            _searchColumnManager.service(_manager);
            
            Configuration searchConfig = configuration.getChild("SearchModel");
//            _cTypes = _configureContentTypes(searchConfig.getChild("content-types", false));
            _configureContentTypes(searchConfig.getChild("content-types", false));
            
            _summaryView = searchConfig.getChild("summary-view").getValue(null);
            _sortOnMultipleJoin = searchConfig.getChild("allow-sort-on-multiple-join").getValueAsBoolean(super.allowSortOnMultipleJoin());
            
            // Get the base content types and try to find common ancestors.
            Set<String> baseCTypeIds = _configureBaseContentTypes(searchConfig.getChild("content-types"));
            Set<ContentType> commonContentTypes = _cTypeHelper.getCommonAncestors(baseCTypeIds)
                    .stream()
                    .map(_cTypeEP::getExtension)
                    .collect(Collectors.toSet());
            
            _pageSize = searchConfig.getChild("page-size").getValueAsInteger(50);
            if (_pageSize < 0)
            {
                _pageSize = 50;
            }
            _workspace = searchConfig.getChild("workspace").getValue(null);
            
            _configureSearchUrl(searchConfig);
            _configureExportCSVUrl(searchConfig);
            _configureExportDOCUrl(searchConfig);
            _configureExportXMLUrl(searchConfig);
            _configurePrintUrl(searchConfig);
            
            _criteriaIndex = 0;
            List<String> searchCriteriaRoles = new ArrayList<>();
            List<String> facetedSearchUICriterionRoles = new ArrayList<>();
            List<String> advancedSearchUICriterionRoles = new ArrayList<>();
            
            _addCriteriaComponents(commonContentTypes, searchConfig.getChild("simple-search-criteria"), searchCriteriaRoles);
            
            Configuration advancedCriteriaConf = searchConfig.getChild("advanced-search-criteria", false);
            if (advancedCriteriaConf != null)
            {
                _addCriteriaComponents(commonContentTypes, advancedCriteriaConf, advancedSearchUICriterionRoles);
            }
            
            Configuration facetsConf = searchConfig.getChild("facets", false);
            if (facetsConf != null)
            {
                _addFacetCriteriaComponents(commonContentTypes, facetsConf, facetedSearchUICriterionRoles);
            }
            
            _searchCriterionManager.initialize();
            
            _searchCriteria = new LinkedHashMap<>();
            _facetedCriteria = new LinkedHashMap<>();
            _advancedSearchCriteria = new LinkedHashMap<>();
            
            _configureCriteria(_searchCriteria, searchCriteriaRoles, false);
            if (advancedCriteriaConf != null)
            {
                if (advancedSearchUICriterionRoles.isEmpty())
                {
                    // The facet root configuration is present but has no criteria configuration:
                    // copy the simple search criteria.
                    _copyAdvancedCriteria(_advancedSearchCriteria, _searchCriteria.values());
                }
                else
                {
                    _configureCriteria(_advancedSearchCriteria, advancedSearchUICriterionRoles, false);
                }
            }
            
            if (facetsConf != null)
            {
                if (facetedSearchUICriterionRoles.isEmpty())
                {
                    // The facet root configuration is present but has no criteria configuration:
                    // copy the simple search criteria which are facetable.
                    _copyFacetableCriteria(_facetedCriteria, _searchCriteria.values());
                }
                else
                {
                    _configureCriteria(_facetedCriteria, facetedSearchUICriterionRoles, true);
                }
            }
            
            List<String> columnsRolesToLookup = new ArrayList<>();
            
            Configuration columnConfs = searchConfig.getChild("columns").getChild("default");
            _addColumnsComponents(commonContentTypes, columnConfs, columnsRolesToLookup);
            _searchColumnManager.initialize();
            _columns = _configureColumns(columnsRolesToLookup);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to create local component managers.", configuration, e);
        }
    }
    
    @Override
    public void dispose()
    {
        _searchCriterionManager.dispose();
        _searchCriterionManager = null;
        
        _searchColumnManager.dispose();
        _searchColumnManager = null;
    }
    
    @Override
    public Set<String> getContentTypes(Map<String, Object> contextualParameters)
    {
        return Collections.unmodifiableSet(_cTypes);
    }
    
    @Override
    public Set<String> getExcludedContentTypes(Map<String, Object> contextualParameters)
    {
        return Collections.unmodifiableSet(_excludedCTypes);
    }
    
    @Override
    public int getPageSize(Map<String, Object> contextualParameters)
    {
        return _pageSize;
    }
    
    @Override
    public String getWorkspace(Map<String, Object> contextualParameters)
    {
        return _workspace;
    }
    
    @Override
    public String getSearchUrl(Map<String, Object> contextualParameters)
    {
        return _searchUrl;
    }
    
    @Override
    public String getSearchUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _searchUrlPlugin;
    }

    @Override
    public String getExportCSVUrl(Map<String, Object> contextualParameters)
    {
        return _exportCSVUrl;
    }
    
    @Override
    public String getExportCSVUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _exportCSVUrlPlugin;
    }

    @Override
    public String getExportDOCUrl(Map<String, Object> contextualParameters)
    {
        return _exportDOCUrl;
    }

    @Override
    public String getExportDOCUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _exportDOCUrlPlugin;
    }

    @Override
    public String getExportXMLUrl(Map<String, Object> contextualParameters)
    {
        return _exportXMLUrl;
    }

    @Override
    public String getExportXMLUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _exportXMLUrlPlugin;
    }
    
    @Override
    public String getPrintUrl(Map<String, Object> contextualParameters)
    {
        return _printUrl;
    }
    
    @Override
    public String getPrintUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _printUrlPlugin;
    }
    
    @Override
    public String getSummaryView()
    {
        return _summaryView;
    }
    
    @Override
    public boolean allowSortOnMultipleJoin()
    {
        return _sortOnMultipleJoin;
    }

//    @Override
//    public Map<String, SearchUICriterion> getCriteria(Map<String, Object> contextualParameters)
//    {
//        return Collections.unmodifiableMap(_searchCriteria);
//    }
//    
//    @Override
//    public Map<String, SearchUICriterion> getFacetedCriteria(Map<String, Object> contextualParameters)
//    {
//        return Collections.unmodifiableMap(_facetedCriteria);
//    }
//    
//    @Override
//    public Map<String, SearchUICriterion> getAdvancedCriteria(Map<String, Object> contextualParameters)
//    {
//        return Collections.unmodifiableMap(_advancedSearchCriteria);
//    }
//    
//    @Override
//    public List<SearchUIColumn> getResultColumns(Map<String, Object> contextualParameters)
//    {
//        return Collections.unmodifiableList(_columns);
//    }
    
    /**
     * Configure the content type ids
     * @param configuration The content types configuration
     * @throws ConfigurationException If an error occurs
     */
//    protected Set<String> _configureContentTypes(Configuration configuration) throws ConfigurationException
    protected void _configureContentTypes(Configuration configuration) throws ConfigurationException
    {
        _cTypes = new HashSet<>();
        _excludedCTypes = new HashSet<>();
        
        if (configuration != null)
        {
            Configuration excludeConf = configuration.getChild("exclude");
            
            List<String> excludedTags = new ArrayList<>();
            for (Configuration tagCong : excludeConf.getChildren("tag"))
            {
                excludedTags.add(tagCong.getValue());
            }
            
            List<String> excludedCTypes = new ArrayList<>();
            for (Configuration cType : excludeConf.getChildren("content-type"))
            {
                excludedCTypes.add(cType.getValue());
            }
            
            Configuration[] cTypesConfiguration = configuration.getChildren("content-type");
            if (cTypesConfiguration.length == 0)
            {
                // Keep "content types" empty.
                for (String id : _cTypeEP.getExtensionsIds())
                {
                    if (!_isValidContentType(id, excludedTags, excludedCTypes))
                    {
                        _excludedCTypes.add(id);
                    }
                }
            }
            else
            {
                for (Configuration conf : configuration.getChildren("content-type"))
                {
                    String id = conf.getAttribute("id");
                    _cTypes.add(id);
                    if (!_isValidContentType(id, excludedTags, excludedCTypes))
                    {
                        _excludedCTypes.add(id);
                    }
                    
                    for (String subTypeId : _cTypeEP.getSubTypes(id))
                    {
                        if (!_isValidContentType(subTypeId, excludedTags, excludedCTypes))
                        {
                            _excludedCTypes.add(subTypeId);
                        }
                    }
                }
            }
        }
    }
    
    /**
     * Configure the base content type ids.
     * @param configuration The content types configuration
     * @return The set of base content type ids
     * @throws ConfigurationException If an error occurs
     */
    protected Set<String> _configureBaseContentTypes(Configuration configuration) throws ConfigurationException
    {
        Set<String> cTypes = new HashSet<>();
        
        Configuration[] cTypesConfiguration = configuration.getChildren("content-type");
        if (cTypesConfiguration.length == 0)
        {
            cTypes.addAll(_cTypeEP.getExtensionsIds());
        }
        else
        {
            for (Configuration conf : cTypesConfiguration)
            {
                cTypes.add(conf.getAttribute("id"));
            }
        }
        
        return cTypes;
    }
    
    /**
     * Determines if the content type is a valid content type in current configuration 
     * @param id The content type id
     * @param excludedTags The tags to exclude
     * @param excludedContentTypes The content types to exclude
     * @return <code>true</code> if the content type is a valid content type
     */
    protected boolean _isValidContentType (String id, List<String> excludedTags, List<String> excludedContentTypes)
    {
        if (excludedContentTypes.contains(id))
        {
            return false;
        }
        
        ContentType cType = _cTypeEP.getExtension(id);
        for (String tag : excludedTags)
        {
            if (cType.hasTag(tag))
            {
                return false;
            }
        }
        
        return true;
    }
    
    private void _configureSearchUrl(Configuration configuration)
    {
        _searchUrlPlugin = configuration.getChild("search-url").getAttribute("plugin", DEFAULT_URL_PLUGIN);
        _searchUrl = configuration.getChild("search-url").getValue(DEFAULT_SEARCH_URL);
    }
    
    private void _configureExportCSVUrl(Configuration configuration)
    {
        _exportCSVUrlPlugin = configuration.getChild("export-csv-url").getAttribute("plugin", DEFAULT_URL_PLUGIN);
        _exportCSVUrl = configuration.getChild("export-csv-url").getValue(DEFAULT_EXPORT_CSV_URL);
    }
    
    private void _configureExportDOCUrl(Configuration configuration)
    {
        _exportDOCUrlPlugin = configuration.getChild("export-doc-url").getAttribute("plugin", DEFAULT_URL_PLUGIN);
        _exportDOCUrl = configuration.getChild("export-doc-url").getValue(DEFAULT_EXPORT_DOC_URL);
    }

    private void _configureExportXMLUrl(Configuration configuration)
    {
        _exportXMLUrlPlugin = configuration.getChild("export-xml-url").getAttribute("plugin", DEFAULT_URL_PLUGIN);
        _exportXMLUrl = configuration.getChild("export-xml-url").getValue(DEFAULT_EXPORT_XML_URL);
    }
    
    private void _configurePrintUrl(Configuration configuration)
    {
        _printUrlPlugin = configuration.getChild("print-url").getAttribute("plugin", DEFAULT_URL_PLUGIN);
        _printUrl = configuration.getChild("print-url").getValue(DEFAULT_PRINT_URL);
    }
    
    /**
     * Add criteria components to the search criteria manager.
     * @param commonContentTypes the model's common content types.
     * @param configuration the model configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addCriteriaComponents(Set<ContentType> commonContentTypes, Configuration configuration, List<String> searchCriteriaRoles) throws ConfigurationException
    {
        for (Configuration groupConf : configuration.getChildren("group"))
        {
            I18nizableText group = _configureI18nizableText(groupConf.getChild("label", false), null);
            
            _addCriteriaComponents (commonContentTypes, groupConf, searchCriteriaRoles, group);
        }
        
        // Criteria without groups
        _addCriteriaComponents (commonContentTypes, configuration, searchCriteriaRoles, null);
    }
    
    /**
     * Add standard criteria components to the search criteria manager.
     * @param commonContentTypes the model's common content types.
     * @param configuration the model configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @param group the criteria group.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addCriteriaComponents(Set<ContentType> commonContentTypes, Configuration configuration, List<String> searchCriteriaRoles, I18nizableText group) throws ConfigurationException
    {
        for (Configuration conf : configuration.getChildren("criteria"))
        {
            String fieldRef = conf.getAttribute("field-ref", null);
            String systemProperty = conf.getAttribute("system-ref", null);
            String customId = conf.getAttribute("custom-ref", null);
            
            if (StringUtils.isNotEmpty(fieldRef))
            {
                _addIndexingFieldCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, fieldRef, group);
            }
            else if (systemProperty != null)
            {
                _addSystemCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, systemProperty, group);
            }
            else if (customId != null)
            {
                _addCustomCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, customId, group);
            }
        }
    }
    
    /**
     * Add facet criteria components to the search criteria manager.
     * @param commonContentTypes the model's common content types.
     * @param configuration the model configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addFacetCriteriaComponents(Set<ContentType> commonContentTypes, Configuration configuration, List<String> searchCriteriaRoles) throws ConfigurationException
    {
        for (Configuration conf : configuration.getChildren("criteria"))
        {
            String fieldRef = conf.getAttribute("field-ref", null);
            String systemProperty = conf.getAttribute("system-ref", null);
            String customId = conf.getAttribute("custom-ref", null);
            
            if (StringUtils.isNotEmpty(fieldRef))
            {
                _addIndexingFieldCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, fieldRef, null);
            }
            else if (systemProperty != null)
            {
                _addSystemCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, systemProperty, null);
            }
            else if (customId != null)
            {
                _addCustomCriteriaComponents(commonContentTypes, conf, searchCriteriaRoles, customId, null);
            }
        }
    }
    
    /**
     * Add a indexing field criteria component to the manager.
     * @param commonContentTypes the model common content types.
     * @param conf the criteria configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @param fieldRef the field path.
     * @param group The group.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addIndexingFieldCriteriaComponents(Set<ContentType> commonContentTypes, Configuration conf, List<String> searchCriteriaRoles, String fieldRef, I18nizableText group) throws ConfigurationException
    {
        try
        {
            if (commonContentTypes.isEmpty() && (fieldRef.equals("*") || fieldRef.equals(Content.ATTRIBUTE_TITLE)))
            {
                // If no common ancestors, only title attribute is allowed
                String role = Content.ATTRIBUTE_TITLE + _criteriaIndex;
                _criteriaIndex++;
                Configuration criteriaConf = getIndexingFieldCriteriaConfiguration(conf, Set.of(), Content.ATTRIBUTE_TITLE, Operator.EQ, group);
                
                _searchCriterionManager.addComponent("cms", null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
                
                searchCriteriaRoles.add(role);
            }
            else if (!commonContentTypes.isEmpty() && fieldRef.equals("*"))
            {
                Set<String> commonContentTypeIds = commonContentTypes.stream()
                        .map(ContentType::getId)
                        .collect(Collectors.toSet());
                
                for (ContentType commonContentType : commonContentTypes)
                {
                    for (ModelItem modelItem : commonContentType.getModelItems())
                    {
                        // Get only first-level field (ignore composites and repeaters)
                        if (modelItem instanceof ElementDefinition definition)
                        {
                            String role = definition.getName() + _criteriaIndex;
                            _criteriaIndex++;
                            Configuration criteriaConf = getIndexingFieldCriteriaConfiguration(conf, commonContentTypeIds, definition.getName(), null, group);
                            
                            _searchCriterionManager.addComponent("cms", null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
                            
                            searchCriteriaRoles.add(role);
                        }
                    }
                }
            }
            else if (!commonContentTypes.isEmpty())
            {
                Set<String> commonContentTypeIds = commonContentTypes.stream()
                        .map(ContentType::getId)
                        .collect(Collectors.toSet());
                
                // The field ref is the indexing field path.
                String role = fieldRef + _criteriaIndex;
                _criteriaIndex++;
                Configuration criteriaConf = getIndexingFieldCriteriaConfiguration(conf, commonContentTypeIds, fieldRef, null, group);
                
                _searchCriterionManager.addComponent("cms", null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
                
                searchCriteriaRoles.add(role);
            }
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate IndexingFieldSearchUICriterion for field " + fieldRef, conf, e);
        }
    }
    
    /**
     * Add a system criteria component to the manager.
     * @param commonContentTypes the model common content types.
     * @param originalConf the criteria configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @param property the system property id.
     * @param group The group.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addSystemCriteriaComponents(Set<ContentType> commonContentTypes, Configuration originalConf, List<String> searchCriteriaRoles, String property, I18nizableText group) throws ConfigurationException
    {
        try
        {
            Set<String> commonContentTypeIds = commonContentTypes.stream()
                    .map(ContentType::getId)
                    .collect(Collectors.toSet());
            
            if (property.equals("*"))
            {
                for (String propId : _systemPropEP.getSearchProperties())
                {
                    String role = propId + _criteriaIndex;
                    _criteriaIndex++;
                    
                    Configuration criteriaConf = getSystemCriteriaConfiguration(originalConf, commonContentTypeIds, propId, group);
                    _searchCriterionManager.addComponent("cms", null, role, SystemSearchUICriterion.class, criteriaConf);
                    
                    searchCriteriaRoles.add(role);
                }
            }
            else
            {
                String role = property + _criteriaIndex;
                _criteriaIndex++;
                
                Configuration criteriaConf = getSystemCriteriaConfiguration(originalConf, commonContentTypeIds, property, group);
                _searchCriterionManager.addComponent("cms", null, role, SystemSearchUICriterion.class, criteriaConf);
                
                searchCriteriaRoles.add(role);
            }
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate SystemSearchUICriterion for property " + property, originalConf, e);
        }
    }
    
    /**
     * Add a custom criteria component to the manager.
     * @param commonContentTypes the model common content types.
     * @param conf the criteria configuration.
     * @param searchCriteriaRoles the criteria role list to fill.
     * @param searchCriterionId the custom criteria id.
     * @param group The group. Can be null.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addCustomCriteriaComponents(Set<ContentType> commonContentTypes, Configuration conf, List<String> searchCriteriaRoles, String searchCriterionId, I18nizableText group) throws ConfigurationException
    {
        Configuration classConf = conf.getChild("class");
        String className = classConf.getAttribute("name", null);
        
        if (className == null)
        {
            throw new ConfigurationException("The custom search criterion '" + searchCriterionId + "' does not specifiy a class.", conf);
        }
        
        try
        {
            String role = searchCriterionId + _criteriaIndex;
            _criteriaIndex++;
            
            // Common content type or first content type
            String defaultContentTypeId = _searchModelHelper.getAllContentTypes(this, Map.of()).iterator().next();
            Set<String> contentTypeIds = commonContentTypes.isEmpty() ? Set.of(defaultContentTypeId) : commonContentTypes.stream()
                    .map(ContentType::getId)
                    .collect(Collectors.toSet());
            
            Configuration criteriaConf = getCustomCriteriaConfiguration(conf, contentTypeIds, searchCriterionId, group);
            
            @SuppressWarnings("unchecked")
            Class<SearchUICriterion> searchCriteriaClass = (Class<SearchUICriterion>) Class.forName(className);
            _searchCriterionManager.addComponent("cms", null, role, searchCriteriaClass, criteriaConf);
            
            searchCriteriaRoles.add(role);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate custom SearchUICriterion for class: " + className, conf, e);
        }
    }
    
    /**
     * Lookup the previously initialized criteria components and fill the given map with them.
     * @param criteriaMap the criteria map to fill.
     * @param criteriaRoles the roles of the criteria components to lookup.
     * @param checkFacetable true to check if the criteria are facetable.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _configureCriteria(Map<String, SearchUICriterion> criteriaMap, List<String> criteriaRoles, boolean checkFacetable) throws ConfigurationException
    {
        for (String role : criteriaRoles)
        {
            try
            {
                SearchUICriterion criterion = _searchCriterionManager.lookup(role);
                
                if (checkFacetable && !criterion.isFacetable())
                {
                    throw new ConfigurationException("The search criteria of id '" + criterion.getId() + "' is not facetable.");
                }
                
                criteriaMap.put(criterion.getId(), criterion);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Impossible to lookup the search criteria of role: " + role, e);
            }
        }
    }
    
    /**
     * Copy all the allowed search criteria to the given criteria map.
     * @param advancedCriteria the criteria map to fill.
     * @param criteria the source criteria collection.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _copyAdvancedCriteria(Map<String, SearchUICriterion> advancedCriteria, Collection<SearchUICriterion> criteria) throws ConfigurationException
    {
        for (SearchUICriterion criterion : criteria)
        {
            if (_isAdvanced(criterion))
            {
                advancedCriteria.put(criterion.getId(), criterion);
            }
        }
    }
    
    /**
     * Copy all the facetable search criteria to the given criteria map.
     * @param facetedCriteria the criteria map to fill.
     * @param criteria the source criteria collection.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _copyFacetableCriteria(Map<String, SearchUICriterion> facetedCriteria, Collection<SearchUICriterion> criteria) throws ConfigurationException
    {
        for (SearchUICriterion criterion : criteria)
        {
            if (criterion.isFacetable())
            {
                facetedCriteria.put(criterion.getId(), criterion);
            }
        }
    }
    
    /**
     * Test if a search criterion can be used in advanced search mode.
     * For instance: geocode, rich-text, file-typed criterion are not allowed.
     * @param criterion the search criterion to test.
     * @return <code>true</code> if the criterion can be used in advanced search mode, <code>false</code> otherwise.
     */
    protected boolean _isAdvanced(SearchUICriterion criterion)
    {
        boolean isAdvanced = false;
        
        switch (criterion.getType())
        {
            case STRING:
            case MULTILINGUAL_STRING:
            case LONG:
            case DOUBLE:
            case DATE:
            case DATETIME:
            case BOOLEAN:
            case CONTENT:
            case SUB_CONTENT:
            case USER:
            case RICH_TEXT:
                isAdvanced = true;
                break;
            case COMPOSITE:
            case FILE:
            case BINARY:
            case REFERENCE:
            case GEOCODE:
            default:
                // Do nothing.
                break;
        }
        
        return isAdvanced;
    }
    
    /**
     * Add column components to the result column manager.
     * @param commonContentTypes the model's common content types.
     * @param configuration the model configuration.
     * @param columnsRolesToLookup The list of column roles to lookup that will be filled by the method.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addColumnsComponents(Set<ContentType> commonContentTypes, Configuration configuration, List<String> columnsRolesToLookup) throws ConfigurationException
    {
        for (Configuration conf : configuration.getChildren("column"))
        {
            String metadataPath = conf.getAttribute("metadata-ref", null);
            String systemProperty = conf.getAttribute("system-ref", null);
            String customId = conf.getAttribute("custom-ref", null);
            
            if (StringUtils.isNotEmpty(metadataPath))
            {
                _addMetadataColumnComponents(commonContentTypes, conf, metadataPath, columnsRolesToLookup);
            }
            else if (systemProperty != null)
            {
                _addSystemColumnComponent(commonContentTypes, conf, systemProperty, columnsRolesToLookup);
            }
            else if (customId != null)
            {
                _addCustomColumnComponent(commonContentTypes, conf, customId, columnsRolesToLookup);
            }
        }
    }
    
    /**
     * Add a metadata column component to the manager.
     * @param commonContentTypes the model common content types.
     * @param conf the column configuration.
     * @param metadataPath the metadata path, separated by '/'.
     * @param columnsRolesToLookup The list to fill with the column roles to lookup when the manager is initialized.
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addMetadataColumnComponents(Set<ContentType> commonContentTypes, Configuration conf, String metadataPath, List<String> columnsRolesToLookup) throws ConfigurationException
    {
        try
        {
            Set<String> commonContentTypeIds = commonContentTypes.stream()
                        .map(ContentType::getId)
                        .collect(Collectors.toSet());
            
            if (_columnHelper.isWildcardColumn(metadataPath))
            {
                List<String> metadataColumnPaths = _columnHelper.getWildcardAttributeColumnPaths(commonContentTypes, metadataPath);
                columnsRolesToLookup.addAll(_handleMetadataColumns(metadataColumnPaths, commonContentTypeIds, conf));
            }
            else if (!commonContentTypes.isEmpty())
            {
                Configuration columnConf = getMetadataColumnConfiguration(conf, commonContentTypeIds, metadataPath);
                
                _searchColumnManager.addComponent("cms", null, metadataPath, MetadataSearchUIColumn.class, columnConf);
                columnsRolesToLookup.add(metadataPath);
            }
            else if (metadataPath.equals(Content.ATTRIBUTE_TITLE))
            {
                Configuration columnConf = getMetadataColumnConfiguration(conf, Set.of(), metadataPath);
                
                _searchColumnManager.addComponent("cms", null, metadataPath, MetadataSearchUIColumn.class, columnConf);
                columnsRolesToLookup.add(metadataPath);
            }
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate MetadataSearchUIColumn for metadata " + metadataPath, conf, e);
        }
    }
    
    private List<String> _handleMetadataColumns(List<String> metadataColumnPaths, Set<String> contentTypeIds, Configuration conf) throws ConfigurationException
    {
        List<String> columnsRolesToLookup = new ArrayList<>();
        
        for (String metadataPath : metadataColumnPaths)
        {
            Configuration columnConf = getMetadataColumnConfiguration(conf, contentTypeIds, metadataPath);
            _searchColumnManager.addComponent("cms", null, metadataPath, MetadataSearchUIColumn.class, columnConf);
            
            columnsRolesToLookup.add(metadataPath);
        }
        
        return columnsRolesToLookup;
    }
    
    /**
     * Add a system column component to the manager.
     * @param commonContentTypes the model common content types.
     * @param originalConf the column configuration.
     * @param property the system property.
     * @param columnsRolesToLookup The list to fill with the column roles to lookup when the manager is initialized. 
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addSystemColumnComponent(Set<ContentType> commonContentTypes, Configuration originalConf, String property, List<String> columnsRolesToLookup) throws ConfigurationException
    {
        try
        {
            Set<String> commonContentTypeIds = commonContentTypes.stream()
                    .map(ContentType::getId)
                    .collect(Collectors.toSet());
            
            if (_columnHelper.isWildcardColumn(property))
            {
                for (String columnPath : _columnHelper.getWildcardSystemColumnPaths(commonContentTypes, property, false))
                {
                    columnsRolesToLookup.add(_getSystemColumnRole(commonContentTypeIds, originalConf, columnPath));
                }
            }
            else
            {
                columnsRolesToLookup.add(_getSystemColumnRole(commonContentTypeIds, originalConf, property));
            }
            
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate SystemSearchUIColumn for property " + property, originalConf, e);
        }
    }
    
    private String _getSystemColumnRole(Set<String> cTypeIds, Configuration originalConf, String property) throws ConfigurationException
    {
        Configuration conf = getSystemColumnConfiguration(originalConf, cTypeIds, property);
        _searchColumnManager.addComponent("cms", null, property, SystemSearchUIColumn.class, conf);
        return property;
    }
    
    /**
     * Add a custom column component to the manager.
     * @param commonContentTypes the model common content types.
     * @param conf the column configuration.
     * @param customId the custom column id.
     * @param columnsRolesToLookup The list to fill with the column roles to lookup when the manager is initialized. 
     * @throws ConfigurationException if an error occurs.
     */
    protected void _addCustomColumnComponent(Set<ContentType> commonContentTypes, Configuration conf, String customId, List<String> columnsRolesToLookup) throws ConfigurationException
    {
        String className = conf.getChild("class").getAttribute("name", null);
        
        if (className == null)
        {
            throw new ConfigurationException("The custom search column '" + className + "' does not specifiy a class.", conf);
        }
        
        try
        {
            @SuppressWarnings("unchecked")
            Class<SearchUIColumn> columnClass = (Class<SearchUIColumn>) Class.forName(className);
            _searchColumnManager.addComponent("cms", null, customId, columnClass, conf);
            columnsRolesToLookup.add(customId);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate custom SearchUIColumn for class: " + className, conf, e);
        }
    }
    
    /**
     * Lookup all the configured columns in the manager.
     * @param columnRoles The list of column roles added to the component manager. 
     * @return the list of search columns.
     * @throws Exception if an error occurs.
     */
    protected Map<String, SearchUIColumn> _configureColumns(List<String> columnRoles) throws Exception
    {
        Map<String, SearchUIColumn> columns = new LinkedHashMap<>();
        
        for (String columnRole : columnRoles)
        {
            SearchUIColumn column = _searchColumnManager.lookup(columnRole);
            if (column != null)
            {
                columns.put(column.getId(), column);
            }
            else
            {
                getLogger().error("Can't find column for role " + columnRole);
            }
        }
        
        return columns;
    }
    
    private I18nizableText _configureI18nizableText(Configuration config, I18nizableText defaultValue) throws ConfigurationException
    {
        if (config != null)
        {
            return I18nizableText.parseI18nizableText(config, null);
        }
        else
        {
            return defaultValue;
        }
    }
    
}