/*
 *  Copyright 2019 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.web.frontoffice.search.metamodel.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
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.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.commons.lang3.tuple.Pair;
import org.apache.commons.math3.util.IntegerSequence.Incrementor;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.advanced.AbstractTreeNode;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.ui.model.SearchUICriterion;
import org.ametys.cms.search.ui.model.impl.IndexingFieldSearchUICriterion;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.util.Cacheable;
import org.ametys.core.util.JSONUtils;
import org.ametys.core.util.SizeUtils.ExcludeFromSizeCalculation;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.i18n.I18nizableTextParameter;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;
import org.ametys.web.frontoffice.search.instance.model.FOSearchCriterion;
import org.ametys.web.frontoffice.search.metamodel.AdditionalParameterValueMap;
import org.ametys.web.frontoffice.search.metamodel.Returnable;
import org.ametys.web.frontoffice.search.metamodel.ReturnableExtensionPoint;
import org.ametys.web.frontoffice.search.metamodel.SearchCriterionDefinition;
import org.ametys.web.frontoffice.search.metamodel.Searchable;
import org.ametys.web.frontoffice.search.requesttime.impl.SearchComponentHelper;

/**
 * Abstract class for all {@link Searchable} based on {@link Content}s
 */
public abstract class AbstractContentBasedSearchable extends AbstractParameterAdderSearchable implements Initializable, Contextualizable, Disposable, Cacheable
{
    // Push ids of System Properties you do not want to appear in the list
    private static final List<String> __EXCLUDED_SYSTEM_PROPERTIES = Arrays.asList("site", 
                                                                                    "parents", 
                                                                                    "workflowStep");
    // Push ids of Indexing Fields you do not want to appear in the list (for instance title which is handled separately)
    private static final List<String> __EXCLUDED_INDEXING_FIELD = Arrays.asList("title");
    
    private static final String __SEARCH_CRITERION_CACHE_ID = AbstractContentBasedSearchable.class.getName() + "$SearchCriterionCache";
    /** The id of extension point */
    protected String _id;
    /** The label */
    protected I18nizableText _label;
    /** The criteria position */
    protected int _criteriaPosition;
    /** The page returnable */
    protected Returnable _pageReturnable;
    /** The associated content returnable */
    protected Returnable _associatedContentReturnable;
    
    /** The extension point for content types */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    /** The search component helper */
    protected SearchComponentHelper _searchComponentHelper;

    private Context _context;
    private ReturnableExtensionPoint _returnableEP;
    private SystemPropertyExtensionPoint _systemPropertyEP;
    private AmetysObjectResolver _ametysObjectResolver;
    private TagProviderExtensionPoint _tagProviderEP;
    private JSONUtils _jsonUtils;
    private AbstractCacheManager _abstractCacheManager;
    
    private List<ContentSearchCriterionDefinition> _systemPropertySearchCriterionDefs;
    
    private ContentSearchCriterionDefinition _titleIndexingFieldSearchCriterionDefCache;
    private Set<ThreadSafeComponentManager<?>> _managers;
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        _id = configuration.getAttribute("id");
        _label = I18nizableText.parseI18nizableText(configuration.getChild("label"), "plugin." + _pluginName);
        _criteriaPosition = configuration.getChild("criteriaPosition").getValueAsInteger();
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _returnableEP = (ReturnableExtensionPoint) manager.lookup(ReturnableExtensionPoint.ROLE);
        _pageReturnable = _returnableEP.getExtension(PageReturnable.ROLE);
        _systemPropertyEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _tagProviderEP = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
        _abstractCacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _searchComponentHelper = (SearchComponentHelper) manager.lookup(SearchComponentHelper.ROLE);
    }

    /**
     * Sets {@link #_associatedContentReturnable}. Called during {@link #initialize()}
     */
    protected void _setAssociatedContentReturnable()
    {
        _associatedContentReturnable = _returnableEP.getExtension(associatedContentReturnableRole());
    }
    
    /**
     * The Avalon Role for the associated Content Returnable
     * @return The Avalon Role for the associated Content Returnable
     */
    protected abstract String associatedContentReturnableRole();
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void initialize() throws Exception
    {
        _setAssociatedContentReturnable();
        _managers = new HashSet<>();
        
        _systemPropertySearchCriterionDefs = new ArrayList<>();
        for (String propId : _systemPropertyEP.getSearchProperties())
        {
            if (__EXCLUDED_SYSTEM_PROPERTIES.contains(propId))
            {
                continue;
            }
            
            ContentSearchCriterionDefinition def = _getSystemPropSearchCriterionDef(propId);
            _systemPropertySearchCriterionDefs.add(def);
        }

        createCaches();
    }

    public AbstractCacheManager getCacheManager()
    {
        return _abstractCacheManager;
    }
    
    @Override
    public Collection<SingleCacheConfiguration> getManagedCaches()
    {
        return Arrays.asList(
                SingleCacheConfiguration.of(
                        __SEARCH_CRITERION_CACHE_ID + _id, 
                        _buildI18n("PLUGINS_WEB_SEARCH_CRITERION_CACHE_LABEL"), 
                        _buildI18n("PLUGINS_WEB_SEARCH_CRITERION_CACHE_DESCRIPTION"))
        );
    }

    @Override
    public boolean hasComputableSize()
    {
        return true;
    }
    
    private I18nizableText _buildI18n(String i18Key)
    {
        String catalogue = "plugin.web";
        Map<String, I18nizableTextParameter> params = Map.of("id", _label);
        return new I18nizableText(catalogue, i18Key, params);
    }

    private Cache<String, Collection<CriterionDefinitionAndSourceContentType>> getSearchCriterionCache()
    {
        return getCacheManager().get(__SEARCH_CRITERION_CACHE_ID + _id);
    }
    
    
    private ContentSearchCriterionDefinition _getSystemPropSearchCriterionDef(String propId)
    {
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            
            String role = propId;
            Configuration criteriaConf = _getSystemCriteriaConfiguration(propId);
            searchCriterionManager.addComponent(_pluginName, null, role, SystemSearchUICriterion.class, criteriaConf);
            
            searchCriterionManager.initialize();
            
            SearchUICriterion criterion = searchCriterionManager.lookup(role);
            String id = getSystemPropertyCriterionDefinitionPrefix() + role;
            ContentSearchCriterionDefinition criterionDef = _criterionDefinition(id, criterion);
            return criterionDef;
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving SystemPropertySearchCriterionDefinitions", e);
        }
    }
    
    private ContentSearchCriterionDefinition _criterionDefinition(String id, SearchUICriterion criterion)
    {
        if (criterion instanceof SystemSearchUICriterion)
        {
            SystemSearchUICriterion systemCriterion = (SystemSearchUICriterion) criterion;
            if ("tags".equals(systemCriterion.getSystemPropertyId()))
            {
                return new TagSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty(), _tagProviderEP, _jsonUtils);
            }
        }
        return new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty(), Optional.empty());
    }
    
    /**
     * Gets the prefix for the ids of system property criterion definitions
     * @return the prefix for the ids of system property criterion definitions
     */
    protected String getSystemPropertyCriterionDefinitionPrefix()
    {
        return getCriterionDefinitionPrefix() + "systemProperty$";
    }
    
    /**
     * Gets the prefix for criterion definitions
     * @return the prefix for criterion definitions
     */
    protected abstract String getCriterionDefinitionPrefix();
    
    private Configuration _getSystemCriteriaConfiguration(String propertyId)
    {
        DefaultConfiguration conf = new DefaultConfiguration("criteria");
        
        DefaultConfiguration propConf = new DefaultConfiguration("systemProperty");
        propConf.setAttribute("name", propertyId);
        conf.addChild(propConf);
        
        // By default, SystemSearchUICriterion sets the multiple status to 'false', so here explicitly copy the multiple status from the property itself
        SystemProperty property = _systemPropertyEP.getExtension(propertyId);
        conf.setAttribute("multiple", property.isMultiple());
        
        return conf;
    }
    
    @Override
    public void dispose()
    {
        _systemPropertySearchCriterionDefs
                .forEach(ContentSearchCriterionDefinition::dispose);
        _systemPropertySearchCriterionDefs.clear();
        
        getSearchCriterionCache().asMap().values()
                .stream()
                .flatMap(Collection::stream)
                .map(CriterionDefinitionAndSourceContentType::criterionDefinition)
                .forEach(ContentSearchCriterionDefinition::dispose);
        getSearchCriterionCache().resetCache();
        removeCaches();
        
        _managers.forEach(ThreadSafeComponentManager::dispose);
        _managers.clear();
    }
    
    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }
    
    @Override
    public int criteriaPosition()
    {
        return _criteriaPosition;
    }
    
    @Override
    public Collection<SearchCriterionDefinition> getCriteria(AdditionalParameterValueMap additionalParameterValues)
    {
        Collection<SearchCriterionDefinition> criteria = new ArrayList<>();
        
        // Content types
        Collection<String> contentTypes = getContentTypes(additionalParameterValues);
        
        // Special case for title
        criteria.add(_getTitleIndexingFieldSearchCriterionDef());
        
        // Indexing fields
        Collection<CriterionDefinitionAndSourceContentType> indexingFieldCriterionDefs = _getIndexingFieldSearchCriterionDefs(contentTypes);
        criteria.addAll(_finalIndexingFieldCriterionDefs(indexingFieldCriterionDefs));
        
        // System properties
        criteria.addAll(_systemPropertySearchCriterionDefs);
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("#getCriteria for contentTypes '{}' returned '{}'", 
                    contentTypes, 
                    criteria.stream()
                        .map(SearchCriterionDefinition::getId)
                        .collect(Collectors.toList()));
        }
        
        return criteria;
    }
    
    /**
     * Gets the content types which will be used to retrieve the criteria relative to the Indexing Model
     * @param additionalParameterValues The additional parameter values
     * @return the content types which will be used to retrieve the criteria relative to the Indexing Model
     */
    protected abstract Collection<String> getContentTypes(AdditionalParameterValueMap additionalParameterValues);
    
    private synchronized Collection<CriterionDefinitionAndSourceContentType> _getIndexingFieldSearchCriterionDefs(Collection<String> contentTypeIds)
    {
        return contentTypeIds
                .stream()
                .map(this::_getIndexingFieldSearchCriterionDefs)
                .flatMap(Collection::stream)
                .collect(Collectors.toList());
    }
    
    private Collection<CriterionDefinitionAndSourceContentType> _getIndexingFieldSearchCriterionDefs(String contentTypeId)
    {
        if (getSearchCriterionCache().hasKey(contentTypeId))
        {
            // found in cache
            Collection<CriterionDefinitionAndSourceContentType> defs = getSearchCriterionCache().get(contentTypeId);
            getLogger().info("IndexingFieldSearchUICriteria for '{}' cache hit ({}).", contentTypeId, defs);
            return defs;
        }
        else
        {
            ContentType contentType = _cTypeEP.getExtension(contentTypeId);
            Collection<? extends ModelItem> indexingModelFields = contentType.getModelItems();
            Collection<CriterionDefinitionAndSourceContentType> indexingFieldSearchCriterionDefs = _createIndexingFieldSearchCriterionDefs(indexingModelFields, contentType);
            // add in cache
            getSearchCriterionCache().put(contentTypeId, indexingFieldSearchCriterionDefs);
            getLogger().info("IndexingFieldSearchUICriteria for '{}' cache miss. They will be created and added in cache ({}).", contentTypeId, indexingFieldSearchCriterionDefs);
            return indexingFieldSearchCriterionDefs;
        }
    }
    
    private Collection<CriterionDefinitionAndSourceContentType> _createIndexingFieldSearchCriterionDefs(Collection<? extends ModelItem> indexingModelFields, ContentType requestedContentType)
    {
        List<CriterionDefinitionAndSourceContentType> criteria = new ArrayList<>();
        String requestedContentTypeId = requestedContentType.getId();
        
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            List<Pair<String, ContentType>> searchCriteriaRoles = new ArrayList<>();
            
            for (ModelItem indexingField : indexingModelFields)
            {
                if (__EXCLUDED_INDEXING_FIELD.contains(indexingField.getName()))
                {
                    continue;
                }
                // Get only first-level field (ignore composites and repeaters)
                if (indexingField instanceof ElementDefinition)
                {
                    ContentType fromContentType = Optional.ofNullable(indexingField.getModel())
                                                          .filter(ContentType.class::isInstance)
                                                          .map(ContentType.class::cast)
                                                          .orElse(requestedContentType);
                    
                    final String path = indexingField.getName();
                    final String role = path;
                    Configuration criteriaConf = _getIndexingFieldCriteriaConfiguration(path, Optional.of(requestedContentTypeId));
                    searchCriterionManager.addComponent(_pluginName, null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
                    
                    searchCriteriaRoles.add(Pair.of(role, fromContentType));
                }
            }
            
            searchCriterionManager.initialize();
            
            final String prefix = getIndexingFieldCriterionDefinitionPrefix();
            for (Pair<String, ContentType> roleAndCType : searchCriteriaRoles)
            {
                String searchCriteriaRole = roleAndCType.getLeft();
                ContentType fromContentType = roleAndCType.getRight();
                SearchUICriterion criterion = searchCriterionManager.lookup(searchCriteriaRole);
                String id = prefix + fromContentType.getId() + "$" + searchCriteriaRole;
                Optional<Validator> validator = _getValidator(fromContentType, searchCriteriaRole);
                
                ContentSearchCriterionDefinition criterionDef = _criterionDefinition(id, criterion, fromContentType, validator);
                criteria.add(new CriterionDefinitionAndSourceContentType(criterionDef, fromContentType));
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving IndexingFieldSearchCriterionDefinitions", e);
        }
        
        criteria.sort(Comparator.comparing(
            critDefAndSourceCtype -> critDefAndSourceCtype._contentTypeId, 
            new ContentTypeComparator(requestedContentType, _cTypeEP)
                .reversed()));
        return criteria;
    }
    
    private Optional<Validator> _getValidator(ContentType contentType, String itemPath) 
    {
        if (contentType.hasModelItem(itemPath))
        {
            return Optional.of(contentType.getModelItem(itemPath))
                    .filter(ElementDefinition.class::isInstance)
                    .map(ElementDefinition.class::cast)
                    .filter(ElementDefinition::isEditable)
                    .map(ElementDefinition::getValidator);
        }
        
        return Optional.empty();
    }
    
    private ContentSearchCriterionDefinition _criterionDefinition(String id, SearchUICriterion criterion, ContentType fromContentType, Optional<Validator> validator)
    {
        boolean isAttributeContent = criterion.getType() == MetadataType.CONTENT;
        return isAttributeContent 
                ? new ContentAttributeContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.of(fromContentType), validator, _ametysObjectResolver, _cTypeEP, _contentHelper)
                : new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.of(fromContentType), validator);
    }
    
    @Override
    public Query buildQuery(
            AbstractTreeNode<FOSearchCriterion> criterionTree, 
            Map<String, Object> userCriteria, 
            Collection<Returnable> returnables,
            Collection<Searchable> searchables, 
            AdditionalParameterValueMap additionalParameters, 
            String currentLang, 
            Map<String, Object> contextualParameters)
    {
        return _searchComponentHelper.buildQuery(criterionTree, userCriteria, returnables, searchables, additionalParameters, currentLang, null, contextualParameters);
    }
    
    private static class ContentTypeComparator implements Comparator<String>
    {
        /* The purpose here is to fill a Map with an Integer
         * for each content type id in the hierarchy, and to base
         * the comparator on those values.
         * For instance, if we have the following hierarchy:
         * 
         * _______A______
         * _____/___\____
         * _____B____C___
         * ____/_\___|___
         * ___B1_B2__C1__
         * 
         * which means that <A extends B,C> & <B extends B1,B2> & <C extends C1>
         * then we want to generate the Map:
         * {A=1, B=2, B1=3, B2=4, C=5, C1=6}
         * (which means we do a depth-first search with pre-order i.e. the children are processed after their parent, from left to right)
         * (See also https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR))
         * 
         * Then with this map, we generate the following order:
         * [A, B, B1, B2, C, C1]
         * (which will then be reversed by #_createIndexingFieldSearchCriterionDefs)
         */
        String _baseCTypeId;
        private Map<String, Integer> _orderByContentType;
        
        ContentTypeComparator(ContentType baseContentType, ContentTypeExtensionPoint cTypeEP)
        {
            _baseCTypeId = baseContentType.getId();
            _orderByContentType = new HashMap<>();
            Incrementor incrementor = Incrementor.create()
                    .withStart(0)
                    .withMaximalCount(Integer.MAX_VALUE);
            _fillOrderByContentType(baseContentType, incrementor, cTypeEP);
        }
        
        private void _fillOrderByContentType(ContentType contentType, Incrementor incrementor, ContentTypeExtensionPoint cTypeEP)
        {
            String contentTypeId = contentType.getId();
            incrementor.increment();
            _orderByContentType.put(contentTypeId, incrementor.getCount());
            Arrays.asList(contentType.getSupertypeIds())
                    .stream()
                    .sequential()
                    .filter(id -> !_orderByContentType.containsKey(id)) // do not re-process already encountered content types
                    .map(cTypeEP::getExtension)
                    .filter(Objects::nonNull)
                    .forEachOrdered(childContentType -> _fillOrderByContentType(childContentType, incrementor, cTypeEP));
        }
        
        @Override
        public int compare(String c1ContentTypeId, String c2ContentTypeId)
        {
            if (c1ContentTypeId.equals(c2ContentTypeId))
            {
                return 0;
            }
            
            if (!_orderByContentType.containsKey(c1ContentTypeId) || !_orderByContentType.containsKey(c2ContentTypeId))
            {
                String message = String.format("An unexpected error occured with the ContentType comparator for base '%s', cannot compare '%s' and '%s'.\nThe orderByContentType map is: %s", _baseCTypeId, c1ContentTypeId, c2ContentTypeId, _orderByContentType.toString());
                throw new IllegalStateException(message);
            }
            
            return Integer.compare(_orderByContentType.get(c1ContentTypeId), _orderByContentType.get(c2ContentTypeId));
        }
    }
    
    
    private Collection<ContentSearchCriterionDefinition> _finalIndexingFieldCriterionDefs(Collection<CriterionDefinitionAndSourceContentType> indexingFieldCriterionDefs)
    {
        return indexingFieldCriterionDefs
                .stream()
                // we want to not have duplicates, i.e. having same indexing field brought by two ContentTypes because it is declared in their common super ContentType
                // this is done by calling #distinct(), and thus this is based on the #equals impl of CriterionDefinitionAndSourceContentType
                .distinct()
                .map(CriterionDefinitionAndSourceContentType::criterionDefinition)
                .collect(Collectors.toList());
    }
    
    private synchronized ContentSearchCriterionDefinition _getTitleIndexingFieldSearchCriterionDef()
    {
        if (_titleIndexingFieldSearchCriterionDefCache != null)
        {
            // found in cache
            getLogger().info("'title' IndexingFieldSearchUICriterion cache hit.");
        }
        else
        {
            // add in cache
            _titleIndexingFieldSearchCriterionDefCache = _createTitleIndexingFieldSearchCriterionDef();
            getLogger().info("'title' IndexingFieldSearchUICriterion cache miss. It will be created and added in cache.");
        }
        return _titleIndexingFieldSearchCriterionDefCache;
    }
    
    private ContentSearchCriterionDefinition _createTitleIndexingFieldSearchCriterionDef()
    {
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            
            String searchCriteriaRole = "title";
            Configuration criteriaConf = _getIndexingFieldCriteriaConfiguration(searchCriteriaRole, Optional.empty());
            searchCriterionManager.addComponent(_pluginName, null, searchCriteriaRole, IndexingFieldSearchUICriterion.class, criteriaConf);
            
            searchCriterionManager.initialize();
            
            SearchUICriterion criterion = searchCriterionManager.lookup(searchCriteriaRole);
            String id = getIndexingFieldCriterionDefinitionPrefix() + "_common$" + searchCriteriaRole;
            return new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty(), Optional.empty());
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving IndexingFieldSearchCriterionDefinitions", e);
        }
    }
    
    /**
     * Gets the prefix for the ids of indexing field criterion definitions
     * @return the prefix for the ids of indexing field criterion definitions
     */
    protected String getIndexingFieldCriterionDefinitionPrefix()
    {
        return getCriterionDefinitionPrefix() + "indexingField$";
    }
    
    private Configuration _getIndexingFieldCriteriaConfiguration(String path, Optional<String> contentTypeId)
    {
        DefaultConfiguration criteriaConf = new DefaultConfiguration("criteria");
        DefaultConfiguration metaConf = new DefaultConfiguration("field");
        criteriaConf.addChild(metaConf);
        metaConf.setAttribute("path", path);
        
        DefaultConfiguration cTypesConf = new DefaultConfiguration("contentTypes");
        criteriaConf.addChild(cTypesConf);
        if (contentTypeId.isPresent())
        {
            DefaultConfiguration baseTypeConf = new DefaultConfiguration("baseType");
            baseTypeConf.setAttribute("id", contentTypeId.get());
            cTypesConf.addChild(baseTypeConf);
        }
        
        return criteriaConf;
    }
    
    @Override
    public Collection<Returnable> relationsWith()
    {
        return Arrays.asList(_pageReturnable, _associatedContentReturnable);
    }
    
    // wraps a CriterionDefinition and where it comes from
    private static class CriterionDefinitionAndSourceContentType
    {
        String _contentTypeId;
        @ExcludeFromSizeCalculation
        private ContentSearchCriterionDefinition _critDef;
        private String _critDefId;
        
        CriterionDefinitionAndSourceContentType(ContentSearchCriterionDefinition critDef, ContentType contentType)
        {
            _critDef = critDef;
            _critDefId = critDef.getId();
            _contentTypeId = contentType.getId();
        }
        
        ContentSearchCriterionDefinition criterionDefinition()
        {
            return _critDef;
        }
        
        @Override
        public String toString()
        {
            return _critDefId;
        }

        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((_contentTypeId == null) ? 0 : _contentTypeId.hashCode());
            result = prime * result + ((_critDefId == null) ? 0 : _critDefId.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (!(obj instanceof CriterionDefinitionAndSourceContentType))
            {
                return false;
            }
            CriterionDefinitionAndSourceContentType other = (CriterionDefinitionAndSourceContentType) obj;
            if (_contentTypeId == null)
            {
                if (other._contentTypeId != null)
                {
                    return false;
                }
            }
            else if (!_contentTypeId.equals(other._contentTypeId))
            {
                return false;
            }
            if (_critDefId == null)
            {
                if (other._critDefId != null)
                {
                    return false;
                }
            }
            else if (!_critDefId.equals(other._critDefId))
            {
                return false;
            }
            return true;
        }
    }
}