/*
 *  Copyright 2015 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.content.indexing.solr;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
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.concurrent.Future;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
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.service.Serviceable;
import org.apache.cocoon.Constants;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.collections4.IterableUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrResponse;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.request.CoreAdminRequest;
import org.apache.solr.client.solrj.request.CoreAdminRequest.Create;
import org.apache.solr.client.solrj.request.schema.FieldTypeDefinition;
import org.apache.solr.client.solrj.request.schema.SchemaRequest;
import org.apache.solr.client.solrj.request.schema.SchemaRequest.Update;
import org.apache.solr.client.solrj.response.CoreAdminResponse;
import org.apache.solr.client.solrj.response.SolrResponseBase;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.client.solrj.response.schema.SchemaRepresentation;
import org.apache.solr.client.solrj.response.schema.SchemaResponse;
import org.apache.solr.client.solrj.util.ClientUtils;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.CoreAdminParams;
import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.NamedList;
import org.slf4j.Logger;

import org.ametys.cms.data.ametysobject.IndexableAmetysObject;
import org.ametys.cms.indexing.IndexingException;
import org.ametys.cms.indexing.solr.AbstractIndexerCallable;
import org.ametys.cms.indexing.solr.AdditionalDataIndexer;
import org.ametys.cms.indexing.solr.AdditionalDataIndexerExtensionPoint;
import org.ametys.cms.indexing.solr.IndexationResult;
import org.ametys.cms.indexing.solr.ReloadAclCacheRequest;
import org.ametys.cms.indexing.solr.ThreadIndexerHelper;
import org.ametys.cms.indexing.solr.UpdateAclCacheRequest;
import org.ametys.cms.indexing.solr.UpdateCorePropertyRequest;
import org.ametys.cms.model.CMSDataContext;
import org.ametys.cms.model.properties.Property;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.rights.solrchecking.ReadAccessHelper;
import org.ametys.cms.search.model.IndexationAwareElementDefinition;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.query.ContentAttachmentQuery;
import org.ametys.cms.search.query.DocumentTypeQuery;
import org.ametys.cms.search.query.OrQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.ResourceLocationQuery;
import org.ametys.cms.search.solr.NoAutoCommitUpdateClient;
import org.ametys.cms.search.solr.SolrClientProvider;
import org.ametys.cms.search.solr.schema.SchemaDefinition;
import org.ametys.cms.search.solr.schema.SchemaDefinitionProvider;
import org.ametys.cms.search.solr.schema.SchemaDefinitionProviderExtensionPoint;
import org.ametys.cms.search.solr.schema.SchemaFields;
import org.ametys.cms.search.solr.schema.SchemaHelper;
import org.ametys.cms.trash.element.DefaultTrashElement;
import org.ametys.cms.trash.element.TrashElementFactory;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.right.AllowedUsers;
import org.ametys.core.schedule.progression.ContainerProgressionTracker;
import org.ametys.core.schedule.progression.ProgressionTrackerFactory;
import org.ametys.core.schedule.progression.SimpleProgressionTracker;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.provider.AbstractRepository;
import org.ametys.plugins.repository.provider.JackrabbitRepository;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Solr indexer.
 */
public class SolrIndexer extends AbstractLogEnabled implements Component, Serviceable, Initializable, Contextualizable
{
    /** The component role. */
    public static final String ROLE = SolrIndexer.class.getName();
    
    private static final String _CONFIGSET_NAME_PREFIX = "configset-";
    
    private static final List<String> _READ_ONLY_FIELDS = Arrays.asList("id", "_version_", "_text_");
    private static final List<String> _READ_ONLY_FIELDTYPES = Arrays.asList("string", "plong", "text_general");
    
    private static final int __SOLR_STRING_NB_BYTES_LIMIT = 32766;
    
    /** The service manager. */
    protected ServiceManager _manager;
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    /** The schema definition provider extension point. */
    protected SchemaDefinitionProviderExtensionPoint _schemaDefProviderEP;
    /** The schema helper. */
    protected SchemaHelper _schemaHelper;
    /** Solr Ametys contents indexer */
    protected SolrContentIndexer _solrContentIndexer;
    /** Solr workflow indexer. */
    protected SolrWorkflowIndexer _solrWorkflowIndexer;
    /** Solr resource indexer. */
    protected SolrResourceIndexer _solrResourceIndexer;
    /** Solr trash element indexer. */
    protected SolrTrashElementIndexer _solrTrashElementIndexer;
    
    /** The Solr client provider */
    protected SolrClientProvider _solrClientProvider;
    
    /** The solr core prefix. */
    protected String _solrCorePrefix;
    /** The Ametys internal URL used by Solr to query Ametys */
    protected String _ametysInternalUrl;
    
    /** The workspace selector. */
    protected WorkspaceSelector _workspaceSelector;
    /** The JCR repository */
    protected JackrabbitRepository _repository;
    /** The helper for read access */
    protected ReadAccessHelper _readAccessHelper;
    /** The thread indexer helper */
    protected ThreadIndexerHelper _threadIndexerHelper;
    
    /** The avalon context */
    protected Context _context;
    /** Cocoon Context */
    protected org.apache.cocoon.environment.Context _cocoonContext;

    /** The additional data indexer extension point */
    protected AdditionalDataIndexerExtensionPoint _additionalDataIndexerEP;

    /**
     * Truncates (if needed) the given string in order to be indexed without <i>immense term</i> error by Solr.
     * Only the {@value #__SOLR_STRING_NB_BYTES_LIMIT} first bytes of the String will be kept.
     * @param value The string value to index
     * @param logger The logger for logging in WARN level in case the given string is too long and will be truncated. Can be null if you do not want to log.
     * @param documentId The id of the document being indexed. Can be null if you do not want to log.
     * @param fieldName The name of the field being indexed. Can be null if you do not want to log.
     * @return The given string value, or its truncation if it is too long (greater than {@value #__SOLR_STRING_NB_BYTES_LIMIT} bytes)
     */
    public static String truncateUtf8StringValue(String value, Logger logger, String documentId , String fieldName)
    {
        if (value.length() * 4 <= __SOLR_STRING_NB_BYTES_LIMIT)
        {
            // With UTF-8, a character is encoded using 1, 2, 3 or 4 bytes, so (value.length() <= value.getBytes().length <= 4 * value.length())
            // As a result, value.getBytes().length <= limit
            return value;
        }
        
        // There is a doubt, the string may need to be truncated (or not)
        byte[] valueBytes = value.getBytes(StandardCharsets.UTF_8);
        int bytesLength = valueBytes.length;
        if (bytesLength <= __SOLR_STRING_NB_BYTES_LIMIT)
        {
            return value;
        }
        
        if (ObjectUtils.allNotNull(logger, documentId, fieldName))
        {
            logger.warn("The string value for document '{}' and field name '{}' is longer ({}) than the max bytes length {}. It will be truncated to prevent Solr error, but you should consider verifying why this string is so long.", documentId, fieldName, bytesLength, __SOLR_STRING_NB_BYTES_LIMIT);
        }
        
        // Need a truncation (inspired by https://stackoverflow.com/questions/119328/how-do-i-truncate-a-java-string-to-fit-in-a-given-number-of-bytes-once-utf-8-en#answer-35148974)
        CharBuffer charBuffer = CharBuffer.allocate(__SOLR_STRING_NB_BYTES_LIMIT);
        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder()
                                                       .onMalformedInput(CodingErrorAction.IGNORE);
        decoder.decode(ByteBuffer.wrap(valueBytes, 0, __SOLR_STRING_NB_BYTES_LIMIT), charBuffer, true);
        decoder.flush(charBuffer);
        return new String(charBuffer.array(), 0, charBuffer.position());
    }
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _manager = serviceManager;
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _schemaDefProviderEP = (SchemaDefinitionProviderExtensionPoint) serviceManager.lookup(SchemaDefinitionProviderExtensionPoint.ROLE);
        _schemaHelper = (SchemaHelper) serviceManager.lookup(SchemaHelper.ROLE);
        _solrContentIndexer = (SolrContentIndexer) serviceManager.lookup(SolrContentIndexer.ROLE);
        _solrWorkflowIndexer = (SolrWorkflowIndexer) serviceManager.lookup(SolrWorkflowIndexer.ROLE);
        _solrResourceIndexer = (SolrResourceIndexer) serviceManager.lookup(SolrResourceIndexer.ROLE);
        _solrTrashElementIndexer = (SolrTrashElementIndexer) serviceManager.lookup(SolrTrashElementIndexer.ROLE);
        _solrClientProvider = (SolrClientProvider) serviceManager.lookup(SolrClientProvider.ROLE);
        _workspaceSelector = (WorkspaceSelector) serviceManager.lookup(WorkspaceSelector.ROLE);
        _readAccessHelper = (ReadAccessHelper) serviceManager.lookup(ReadAccessHelper.ROLE);
        _repository = (JackrabbitRepository) serviceManager.lookup(AbstractRepository.ROLE);
        _threadIndexerHelper = (ThreadIndexerHelper) serviceManager.lookup(ThreadIndexerHelper.ROLE);
        _additionalDataIndexerEP = (AdditionalDataIndexerExtensionPoint) serviceManager.lookup(AdditionalDataIndexerExtensionPoint.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        Config config = Config.getInstance();
        _solrCorePrefix = config.getValue("cms.solr.core.prefix");
        
        _ametysInternalUrl = config.getValue("cms.solr.core.ametys.internal.url");
        if (StringUtils.isBlank(_ametysInternalUrl))
        {
            // fallback to CMS URL as internal URL is an optional parameter
            _ametysInternalUrl = config.getValue("cms.url");
        }
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    /**
     * Gets the 'autocommit' Solr client
     * @param workspaceName The name of the workspace
     * @return the Solr client
     */
    protected SolrClient _getAutoCommitSolrClient(String workspaceName)
    {
        return _solrClientProvider.getUpdateClient(workspaceName, true);
    }
    
    /**
     * Gets the 'no autocommit' Solr client
     * @param workspaceName The name of the workspace
     * @return the Solr client
     */
    protected SolrClient _getNoAutoCommitSolrClient(String workspaceName)
    {
        return _solrClientProvider.getUpdateClient(workspaceName, false);
    }
    
    // for admin operations
    private SolrClient _defaultSolrClient()
    {
        return _solrClientProvider.getUpdateClient(RepositoryConstants.DEFAULT_WORKSPACE);
    }
    
    /**
     * Get the names of the Solr cores.
     * @return The names of the Solr cores.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    public Set<String> getCoreNames() throws IOException, SolrServerException
    {
        Set<String> coreNames = new HashSet<>();
        
        getLogger().debug("Getting core list.");
        
        CoreAdminRequest req = new CoreAdminRequest();
        req.setAction(CoreAdminAction.STATUS);
        
        NamedList<NamedList<Object>> status = req.process(_defaultSolrClient()).getCoreStatus();
        for (Map.Entry<String, NamedList<Object>> core : status)
        {
            String fullName = (String) core.getValue().get("name");
            if (fullName.startsWith(_solrCorePrefix))
            {
                coreNames.add(fullName.substring(_solrCorePrefix.length()));
            }
        }
        
        return coreNames;
    }
    
    /**
     * Get the names of the Solr cores.
     * @return The names of the Solr cores.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    protected Set<String> getRealCoreNames() throws IOException, SolrServerException
    {
        Set<String> coreNames = new HashSet<>();
        
        getLogger().debug("Getting core list.");
        
        CoreAdminResponse response = new CoreAdminRequest().process(_defaultSolrClient());
        
        NamedList<NamedList<Object>> status = response.getCoreStatus();
        for (Map.Entry<String, NamedList<Object>> core : status)
        {
            String fullName = (String) core.getValue().get("name");
            if (fullName.startsWith(_solrCorePrefix))
            {
                coreNames.add(fullName.substring(_solrCorePrefix.length()));
            }
        }
        
        return coreNames;
    }
    
    /**
     * Create a Solr core.
     * @param name The name of the core to create.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    public void createCore(String name) throws IOException, SolrServerException
    {
        Set<String> cores = getCoreNames();
        if (!cores.contains(name))
        {
            String fullName = _solrCorePrefix + name;
            String configsetName = _CONFIGSET_NAME_PREFIX + (_solrCorePrefix.endsWith("-") ? _solrCorePrefix.substring(0, _solrCorePrefix.length() - 1) : _solrCorePrefix);
            _createConfigset(configsetName);
            
            getLogger().info("Creating core '{}' (full name: '{}').", name, fullName);
            
            Create createRequest = new Create() {
                @Override
                public SolrParams getParams()
                {
                    ModifiableSolrParams params = new ModifiableSolrParams();
                    
                    params.set(CoreAdminParams.ACTION, CoreAdminAction.CREATE.toString());
                    params.set(CoreAdminParams.NAME, fullName);
                    params.set(CoreAdminParams.CONFIGSET, configsetName);
                    params.set("property.ametys.url", _ametysInternalUrl);
                    
                    return params;
                }
            };
            
            NamedList<?> results = createRequest.process(_defaultSolrClient()).getResponse();
            
            NamedList<?> error = (NamedList<?>) results.get("error");
            if (error != null)
            {
                throw new IOException("Error creating the core: " + error.get("msg"));
            }
        }
        else
        {
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Core '" + name + "' already exists, skipping it.");
            }
        }
    }
    
    /**
     * Updates the ametys.url property of the Solr cores.
     */
    public void updateAmetysUrlCoreProperty()
    {
        Set<String> coreNames;
        try
        {
            coreNames = getCoreNames();
        }
        catch (SolrServerException | IOException e)
        {
            getLogger().error("Cannot get Solr core names. As a result, the internal Ametys URL could not be updated on Solr server.", e);
            return;
        }
        
        for (String coreName : coreNames)
        {
            String collection = _solrClientProvider.getCollectionName(coreName);
            SolrResponseBase response;
            try
            {
                response = new UpdateCorePropertyRequest("ametys.url", _ametysInternalUrl).process(_getAutoCommitSolrClient(coreName), collection);
            }
            catch (SolrServerException | IOException e)
            {
                getLogger().error("'core.properties' file updating for workspace '{}' did not succeed as expected.", coreName, e);
                continue;
            }
            
            NamedList<Object> responseParams = response.getResponse();
            if ("ok".equals(responseParams.get("result")))
            {
                Boolean valueChanged = responseParams.getBooleanArg("valueChanged");
                if (valueChanged)
                {
                    getLogger().info("'core.properties' file updated with the up-to-date Ametys URL for workspace '{}'", coreName);
                }
                else
                {
                    getLogger().info("'core.properties' file already has the up-to-date Ametys URL for workspace '{}', it was not modified.", coreName);
                }
            }
            else
            {
                getLogger().error("'core.properties' file updating for workspace '{}' did not succeed as expected.", coreName);
            }
        }
    }
    
    private void _createConfigset(String name) throws IOException, SolrServerException
    {
        getLogger().info("Creating (if necessary) configset '{}'", name);
        
        // This request handler will check if configset exists. If not it will be created.
        CoreAdminRequest request = new CoreAdminRequest() {
            @Override
            public SolrParams getParams()
            {
                ModifiableSolrParams params = new ModifiableSolrParams();
                params.set(CoreAdminParams.ACTION, "createConfigset");
                params.set(CoreAdminParams.NAME, name);
                return params;
            }
        };
        
        NamedList<?> results = request.process(_defaultSolrClient()).getResponse();
        
        NamedList<?> error = (NamedList<?>) results.get("error");
        if (error != null)
        {
            throw new IOException("Error creating the core: " + error.get("msg"));
        }
    }
    
    /**
     * Delete a Solr core.
     * @param name The name of the core to delete.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    public void deleteCore(String name) throws IOException, SolrServerException
    {
        String fullName = _solrCorePrefix + name;
        
        getLogger().info("Deleting core '{}' (full name: '{}').", name, fullName);
        
        CoreAdminResponse response = CoreAdminRequest.unloadCore(fullName, true, true, _defaultSolrClient());
        NamedList<?> results = response.getResponse();
        
        NamedList<?> error = (NamedList<?>) results.get("error");
        if (error != null)
        {
            throw new IOException("Error deleting core" + name + ": " + error.get("msg"));
        }
    }
    
    /**
     * Send the schema.
     * @throws IOException If a communication error occurs.
     * @throws SolrServerException If a solr error occurs.
     */
    public void sendSchema() throws IOException, SolrServerException
    {
        getLogger().info("Computing and sending the schema to the solr server.");
        
        String workspaceName = _workspaceSelector.getWorkspace();
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        
//        SchemaRepresentation staticSchema = _schemaHelper.getStaticSchema();
        SchemaRepresentation staticSchema = _schemaHelper.getSchema("resource://org/ametys/cms/search/solr/schema/schema.xml");
        
        // TODO Clear the schema except fields marked ametysReadOnly="true".
        
        // Clear the current schema.
        clearSchema(solrClient, collection);
        
        SchemaRequest schemaRequest = new SchemaRequest();
        SchemaResponse schemaResponse = schemaRequest.process(solrClient, collection);
        
        // The cleared schema contains only the basic fields which can't be deleted.
        SchemaRepresentation clearedSchema = schemaResponse.getSchemaRepresentation();
        SchemaFields schemaFields = new SchemaFields(clearedSchema);
        
        getLogger().debug("Schema after clear: \n{}", schemaFields.toString());
        
        // Add the static schema types and fields.
        List<SchemaRequest.Update> updates = new ArrayList<>();
        
        // Set "add field" definitions from the static schema to the update list.
        addStaticSchemaUpdates(updates, staticSchema, schemaFields);
        
        getLogger().debug("Temporary schema after static add: \n{}", schemaFields.toString());
        
        // Set "add field" definitions from the static schema to the update list.
        addCustomUpdates(updates, schemaFields);
        
        updates.sort(new SchemaRequestComparator());
        
        SchemaRequest.MultiUpdate multiUpdate = new SchemaRequest.MultiUpdate(updates);
        SchemaResponse.UpdateResponse updateResponse = multiUpdate.process(solrClient, collection);
        
        getLogger().debug("Send schema response: {}", updateResponse.toString());
        Object errors = updateResponse.getResponse().get("errors");
        if (errors != null && errors instanceof List && !((List) errors).isEmpty())
        {
            String msg = "An error occured with the sent schema to Solr, it contains errors:\n" + errors.toString();
            throw new SolrServerException(msg);
        }
    
        getLogger().info("Schema sent to the solr server.");
        
        reloadCores();
    }
    
    /**
     * Compute the list of {@link Update} directives from the static schema.
     * @param updates The list of {@link Update} directives to fill.
     * @param staticSchema The static schema representation.
     * @param schemaFields The current schema fields, used to track the existing fields (to be filled).
     */
    protected void addStaticSchemaUpdates(List<SchemaRequest.Update> updates, SchemaRepresentation staticSchema, SchemaFields schemaFields)
    {
        List<FieldTypeDefinition> fieldTypes = staticSchema.getFieldTypes();
        for (FieldTypeDefinition fieldType : fieldTypes)
        {
            String name = (String) fieldType.getAttributes().get("name");
            if (!schemaFields.hasFieldType(name))
            {
                updates.add(new SchemaRequest.AddFieldType(fieldType));
                schemaFields.addFieldType(name);
            }
        }
        for (Map<String, Object> field : staticSchema.getFields())
        {
            String name = (String) field.get("name");
            if (!schemaFields.hasField(name))
            {
                updates.add(new SchemaRequest.AddField(field));
                schemaFields.addField(name);
            }
        }
        for (Map<String, Object> field : staticSchema.getDynamicFields())
        {
            String name = (String) field.get("name");
            if (!schemaFields.hasDynamicField(name))
            {
                updates.add(new SchemaRequest.AddDynamicField(field));
                schemaFields.addDynamicField(name);
            }
        }
        for (Map<String, Object> field : staticSchema.getCopyFields())
        {
            String source = (String) field.get("source");
            String dest = (String) field.get("dest");
            if (!schemaFields.hasCopyField(source, dest))
            {
                updates.add(new SchemaRequest.AddCopyField(source, Arrays.asList(dest)));
                schemaFields.addCopyField(source, dest);
            }
        }
    }
    
    /**
     * Compute the list of custom {@link Update} directives.
     * @param updates The list of {@link Update} directives to fill.
     * @param schemaFields The current schema fields, used to track the existing fields (to be filled).
     */
    protected void addCustomUpdates(List<SchemaRequest.Update> updates, SchemaFields schemaFields)
    {
        // Add all our property-managed fields.
        for (String providerId : _schemaDefProviderEP.getExtensionsIds())
        {
            SchemaDefinitionProvider definitionProvider = _schemaDefProviderEP.getExtension(providerId);
            
            for (SchemaDefinition definition : definitionProvider.getDefinitions())
            {
                if (!definition.exists(schemaFields))
                {
                    SchemaRequest.Update update = definition.getSchemaUpdate();
                    if (update != null)
                    {
                        updates.add(update);
                    }
                }
            }
        }
    }
    
    /**
     * Delete all the fields of the existing schema in the given collection.
     * @param solrClient The Solr client
     * @param collection The collection.
     * @throws IOException If a communication error occurs.
     * @throws SolrServerException If a solr error occurs.
     */
    protected void clearSchema(SolrClient solrClient, String collection) throws IOException, SolrServerException
    {
        try
        {
            getLogger().info("Clearing the existing schema on the solr server.");
            
            SchemaRequest schemaRequest = new SchemaRequest();
            SchemaResponse schemaResponse = schemaRequest.process(solrClient, collection);
            
            SchemaRepresentation schema = schemaResponse.getSchemaRepresentation();
            
            List<SchemaRequest.Update> deletions = new ArrayList<>();
            
            // First the copy fields, then dynamic and simple fields, and field types in the end.
            for (Map<String, Object> field : schema.getCopyFields())
            {
                String source = (String) field.get("source");
                String dest = (String) field.get("dest");
                deletions.add(new SchemaRequest.DeleteCopyField(source, Arrays.asList(dest)));
            }
            for (Map<String, Object> field : schema.getDynamicFields())
            {
                String name = (String) field.get("name");
                deletions.add(new SchemaRequest.DeleteDynamicField(name));
            }
            for (Map<String, Object> field : schema.getFields())
            {
                String name = (String) field.get("name");
                if (!_READ_ONLY_FIELDS.contains(name))
                {
                    deletions.add(new SchemaRequest.DeleteField(name));
                }
            }
            for (FieldTypeDefinition fieldType : schema.getFieldTypes())
            {
                String name = (String) fieldType.getAttributes().get("name");
                if (!_READ_ONLY_FIELDTYPES.contains(name))
                {
                    deletions.add(new SchemaRequest.DeleteFieldType(name));
                }
            }
            
            SchemaRequest.MultiUpdate multiUpdate = new SchemaRequest.MultiUpdate(deletions);
            SchemaResponse.UpdateResponse updateResponse = multiUpdate.process(solrClient, collection);
            
            Object errors = updateResponse.getResponse().get("errors");
            if (errors != null && errors instanceof List && !((List) errors).isEmpty())
            {
                String msg = "An error occured when clearing Solr schema, it contains errors:\n" + errors.toString();
                throw new SolrServerException(msg);
            }
            else
            {
                getLogger().debug("Clear schema response: {}", updateResponse.toString());
            }
            
            getLogger().info("Solr schema cleared.");
        }
        catch (SolrServerException | IOException e)
        {
            getLogger().error("Error clearing schema in collection " + collection, e);
            throw e;
        }
    }
    
    /**
     * Reload the solr cores.
     * @throws IOException If a communication error occurs.
     * @throws SolrServerException If a solr error occurs.
     */
    protected void reloadCores() throws IOException, SolrServerException
    {
        getLogger().info("Reloading solr cores.");
        
        for (String coreName : getCoreNames())
        {
            String fullName = _solrCorePrefix + coreName;
            
            CoreAdminResponse reloadResponse = CoreAdminRequest.reloadCore(fullName, _defaultSolrClient());
            
            getLogger().debug("Reload core response: {}", reloadResponse.toString());
        }
        
        getLogger().info("All cores reloaded.");
    }
    
    /**
     * Reloads the ACL Solr cache for all users
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     * @throws RepositoryException If a repository exception occurs when retrieving workspaces.
     */
    public void reloadAclCache() throws IOException, SolrServerException, RepositoryException
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            reloadAclCache(workspaceName);
        }
    }
    
    /**
     * Reloads the ACL Solr cache for all users
     * @param workspaceName The workspace name
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    public void reloadAclCache(String workspaceName) throws IOException, SolrServerException
    {
        reloadAclCache(workspaceName, false);
    }
    
    /**
     * Reloads the ACL Solr cache for all users
     * @param workspaceName The workspace name
     * @param checkIfNecessary true to check if the reload is necessary for each segment (i.e. reload only the segments not already in cache)
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     */
    public void reloadAclCache(String workspaceName, boolean checkIfNecessary) throws IOException, SolrServerException
    {
        getLogger().info("Reloading read ACL Solr cache for workspace '{}' (checkIfNecessary={})", workspaceName, checkIfNecessary);
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        SolrResponseBase responseBase = new ReloadAclCacheRequest(checkIfNecessary).process(_getAutoCommitSolrClient(workspaceName), collection);
        NamedList<Object> responseObj = responseBase.getResponse();
        
        if ("ok".equals(responseObj.get("result")))
        {
            getLogger().info("Read-ACL Solr cache reloaded for workspace '{}' (checkIfNecessary={})", workspaceName, checkIfNecessary);
        }
        else
        {
            Object error = responseObj.get("error");
            getLogger().error("The reloading of Read-ACL Solr Cache for workspace '{}' (checkIfNecessary={}) did not succeed as expected.\n Error code is the following: {}", workspaceName, checkIfNecessary, error);
        }
    }
    
    /**
     * Updates the ACL Solr cache for some {@link AmetysObject}s for all workspaces.
     * @param objects the {@link AmetysObject}s to update.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     * @throws RepositoryException If a repository exception occurs when retrieving workspaces.
     */
    public void updateAclCache(Iterable<? extends AmetysObject> objects) throws IOException, SolrServerException, RepositoryException
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            updateAclCache(objects, workspaceName);
        }
    }
    
    /**
     * Updates the ACL Solr cache for some {@link AmetysObject}s.
     * @param objects the {@link AmetysObject}s to update.
     * @param workspaceName The workspace name
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a Solr error occurs.
     * @throws RepositoryException If a repository exception occurs when retrieving workspaces.
     */
    public void updateAclCache(Iterable<? extends AmetysObject> objects, String workspaceName) throws IOException, SolrServerException, RepositoryException
    {
        Map<String, Map<String, Object>> solrParams = new HashMap<>();
        
        for (AmetysObject object : objects)
        {
            AllowedUsers allowedUsers = _readAccessHelper.allowedUsers(object);
            
            solrParams.put(object.getId(), Map.of("anonymous", allowedUsers.isAnonymousAllowed(),
                                                  "anyConnectedUser", allowedUsers.isAnyConnectedUserAllowed(),
                                                  "allowedUsers", allowedUsers.getAllowedUsers().stream().map(UserIdentity::userIdentityToString).collect(Collectors.toList()),
                                                  "deniedUsers", allowedUsers.getDeniedUsers().stream().map(UserIdentity::userIdentityToString).collect(Collectors.toList()),
                                                  "allowedGroups", allowedUsers.getAllowedGroups().stream().map(GroupIdentity::groupIdentityToString).collect(Collectors.toList()),
                                                  "deniedGroups", allowedUsers.getDeniedGroups().stream().map(GroupIdentity::groupIdentityToString).collect(Collectors.toList())));
        }
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        SolrResponse response = new UpdateAclCacheRequest(solrParams).process(_getAutoCommitSolrClient(workspaceName), collection);
        NamedList<Object> responseObj = response.getResponse();
        
        if ("ok".equals(responseObj.get("result")))
        {
            getLogger().info("Read-ACL Solr cache updated for workspace '{}' and objects {}", workspaceName, solrParams.keySet());
        }
        else
        {
            @SuppressWarnings("unchecked")
            List<String> unHandledObjects = (List<String>) responseObj.get("unhandled-objects");
            getLogger().info("The updating of Read-ACL Solr Cache for workspace '{}' did not succeed as expected.\n Following objects have not been updated: {}", workspaceName, unHandledObjects);
        }
    }
    
    /**
     * Index all the contents in a given workspace.
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @return The indexation result as a Map.
     * @throws Exception if an error occurs while indexing.
     */
    public Map<String, Object> indexAllContents(String workspaceName, boolean indexAttachments, SolrClient solrClient) throws Exception
    {
        return indexAllContents(workspaceName, indexAttachments, solrClient, ProgressionTrackerFactory.createSimpleProgressionTracker("Index all contents", getLogger()));
    }
    
    /**
     * Index all the contents in a given workspace.
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return The indexation result as a Map.
     * @throws Exception if an error occurs while indexing.
     */
    public Map<String, Object> indexAllContents(String workspaceName, boolean indexAttachments, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().info("Starting the indexation of all contents for workspace {}", workspaceName);
            
            long start = System.currentTimeMillis();
            
            // Delete all contents
            unindexAllContents(workspaceName, indexAttachments, solrClient);

            String query = ContentQueryHelper.getContentXPathQuery(null);
            AmetysObjectIterable<Content> contents = _resolver.query(query);
            
            IndexationResult result = doIndexContents(contents, workspaceName, indexAttachments, solrClient, progressionTracker);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} contents indexed without error in {} milliseconds.", result.successCount(), end - start);
            }
            else
            {
                getLogger().info("Content indexation ended, the process took {} milliseconds. {} contents were not indexed successfully, please review the error logs above for more details.", end - start, result.errorCount());
            }
            
            Map<String, Object> results = new HashMap<>();
            results.put("successCount", result.successCount());
            if (result.hasErrors())
            {
                results.put("errorCount", result.errorCount());
            }
            
            return results;
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index all contents in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Unindex all content documents.
     * @param workspaceName The workspace name
     * @param unindexAttachments also unindex content attachments
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while unindexing.
     */
    protected void unindexAllContents(String workspaceName, boolean unindexAttachments, SolrClient solrClient) throws Exception
    {
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        
        Query contents = new DocumentTypeQuery(SolrFieldNames.TYPE_CONTENT);
        Query query;
        if (unindexAttachments)
        {
            Query contentResourceAttachments = new DocumentTypeQuery(SolrFieldNames.TYPE_CONTENT_ATTACHMENT_RESOURCE);
            Query contentResourceAttributes = new DocumentTypeQuery(SolrFieldNames.TYPE_CONTENT_ATTRIBUTE_RESOURCE);
            query = new OrQuery(contentResourceAttachments, contentResourceAttributes, contents);
        }
        else
        {
            query = contents;
        }
        
        Query additionalQuery = unindexAllAdditionnalData(AdditionalDataIndexer.TYPE_CONTENT);
        if (additionalQuery != null)
        {
            query = new OrQuery(query, additionalQuery);
        }
        
        solrClient.deleteByQuery(collection, query.build());
    }
    
    /**
     * Add or update a content into Solr index on all workspaces and commit
     * @param contentId The id of the content to index
     * @param indexAttachments to index content attachments
     * @throws Exception if an error occurs while indexing.
     */
    public void indexContent(String contentId, boolean indexAttachments) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
            indexContent(contentId, workspaceName, indexAttachments, solrClient);
        }
    }
    
    /**
     * Add or update a content into Solr index
     * @param contentId The id of the content to index
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @throws Exception if an error occurs while indexing.
     */
    public void indexContent(String contentId, String workspaceName, boolean indexAttachments) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        indexContent(contentId, workspaceName, indexAttachments, solrClient);
    }
    
    /**
     * Add or update a content into Solr index
     * @param contentId The id of the content to index
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    public void indexContent(String contentId, String workspaceName, boolean indexAttachments, SolrClient solrClient) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            if (_resolver.hasAmetysObjectForId(contentId))
            {
                Content content = _resolver.resolveById(contentId);
                _doIndexContent(content, workspaceName, indexAttachments, solrClient);
            }
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    private void _doIndexContent(Content content, String workspaceName, boolean indexAttachments, SolrClient solrClient) throws IndexingException
    {
        try
        {
            long time_0 = System.currentTimeMillis();
            
            getLogger().debug("Indexing content {} into Solr for workspace {}", content.getId(), workspaceName);
            
            deleteRepeaterDocs(content.getId(), workspaceName, solrClient);
            doIndexContent(content, workspaceName, solrClient);
            doIndexContentWorkflow(content, workspaceName, solrClient);
            if (indexAttachments)
            {
                indexContentAttachments(content.getRootAttachments(), content, solrClient);
            }
            
            getLogger().debug("Successfully indexed content {} in Solr in {} ms", content.getId(), System.currentTimeMillis() - time_0);
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index content %s in workspace %s", content.getId(), workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
    }
    
    /**
     * Send a collection of contents for indexation in the solr server on all workspaces and commit
     * @param contents the collection of contents to index.
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexContents(Iterable<Content> contents) throws Exception
    {
        return indexContents(contents, ProgressionTrackerFactory.createContainerProgressionTracker("Index contents", getLogger()));
    }
    
    
    /**
     * Send a collection of contents for indexation in the solr server on all workspaces and commit
     * @param contents the collection of contents to index.
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexContents(Iterable<Content> contents, ContainerProgressionTracker progressionTracker) throws Exception
    {
        IndexationResult result = new IndexationResult(0, 0);
        
        String[] workspaceNames = _repository.getWorkspaces();
        
        for (String workspaceName : workspaceNames)
        {
            progressionTracker.addSimpleStep(workspaceName, new I18nizableText("plugin.cms", "PLUGINS_CMS_SCHEDULER_GLOBAL_INDEXATION_CONTENT_WORKSPACE_STEP_LABEL", List.of(workspaceName)));
        }
        
        for (String workspaceName : workspaceNames)
        {
            SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
            IndexationResult wResult = indexContents(contents, workspaceName, true, solrClient, progressionTracker.getStep(workspaceName));
            
            result = new IndexationResult(result.successCount() + wResult.successCount(), result.errorCount() + wResult.errorCount());
        }
        
        return result;
    }
    
    /**
     * Send a collection of contents for indexation in the solr server.
     * @param contents the collection of contents to index.
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexContents(Iterable<Content> contents, String workspaceName, boolean indexAttachments, SolrClient solrClient) throws Exception
    {
        return indexContents(contents, workspaceName, indexAttachments, solrClient, ProgressionTrackerFactory.createSimpleProgressionTracker("Index contents for workspace " + workspaceName, getLogger()));
    }
    
    /**
     * Send a collection of contents for indexation in the solr server.
     * @param contents the collection of contents to index.
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexContents(Iterable<Content> contents, String workspaceName, boolean indexAttachments, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().info("Starting indexation of several contents for workspace {}", workspaceName);
            
            long start = System.currentTimeMillis();
            
            List<Content> contentsInWorkspace = StreamSupport.stream(contents.spliterator(), false)
                .map(Content::getId)
                .map(this::_resolveSilently)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
            
            IndexationResult result = doIndexContents(contentsInWorkspace, workspaceName, indexAttachments, solrClient, progressionTracker);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} contents indexed without error in {} milliseconds.", result.successCount(), end - start);
            }
            else
            {
                getLogger().info("Content indexation ended, the process took {} milliseconds. {} contents were not indexed successfully, please review the error logs above for more details.", end - start, result.errorCount());
            }
            
            return result;
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index several contents in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    private Content _resolveSilently(String contentId)
    {
        try
        {
            return _resolver.resolveById(contentId);
        }
        catch (UnknownAmetysObjectException e)
        {
            return null;
        }
    }
    
    /**
     * Send some contents for indexation in the solr server.
     * @param contents the contents to index.
     * @param workspaceName The workspace name
     * @param indexAttachments to index content attachments
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs committing the results.
     */
    protected IndexationResult doIndexContents(Iterable<Content> contents, String workspaceName, boolean indexAttachments, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        int numberOfContents = IterableUtils.size(contents);
        progressionTracker.setSize(numberOfContents);
        
        // Add callable for each content to index
        List<Future<Void>> tasks = new ArrayList<>();
        for (Content content : contents)
        {
            tasks.add(_threadIndexerHelper.submitCallable(new ContentIndexerCallable(content, workspaceName, indexAttachments, solrClient, progressionTracker)));
        }
        
        // Now that everything is submitted, we can iterate and wait for result
        return IndexationResult.fromTasks(tasks, getLogger());
    }
    
    /**
     * Update the value of a specific system property in a ametys object document.
     * @param ao The ametys object to update.
     * @param propertyId The system property ID.
     * @param workspaceName The workspace name
     * @throws Exception if an error occurs while indexing.
     */
    public void updateSystemProperty(IndexableAmetysObject ao, String propertyId, String workspaceName) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        updateSystemProperty(ao, propertyId, workspaceName, solrClient);
    }
    
    /**
     * Update the value of a specific system property in a ametys object document.
     * @param ao The ametys object to update.
     * @param propertyId The system property ID.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    public void updateSystemProperty(IndexableAmetysObject ao, String propertyId, String workspaceName, SolrClient solrClient) throws Exception
    {
        getLogger().debug("Updating the system property '{}' for ametys object {} into Solr.", propertyId, ao);
        
        SolrInputDocument document = new SolrInputDocument();
        boolean hasUpdate = populatePartialSystemProperty(ao, propertyId, document);
        
        if (!hasUpdate)
        {
            getLogger().debug("Did not index '{}' system property for ametys object {} in Solr because no update to apply.", propertyId, ao);
            return;
        }
        
        int status = _pushSolrDocument(document, workspaceName, solrClient);
        if (status != 0)
        {
            throw new IOException("Indexing of system property '" + propertyId + "': got status code '" + status + "'.");
        }
        
        getLogger().debug("Succesfully indexed '{}' system property for ametys object {} in Solr.", propertyId, ao);
    }
    
    /**
     * Populate a Solr input document by adding fields for a single system property.
     * @param ao The ametys object to index
     * @param propertyId The system property ID.
     * @param document The solr document
     * @return true if there are partial update to apply
     * @throws Exception if an error occurred
     */
    public boolean populatePartialSystemProperty(IndexableAmetysObject ao, String propertyId, SolrInputDocument document) throws Exception
    {
        Optional<SystemProperty> property = ao.getSystemPropertyExtensionPoint()
            .filter(s -> s.hasExtension(propertyId))
            .map(s -> s.getExtension(propertyId));
        
        if (property.isEmpty())
        {
            throw new IllegalStateException("The system property '" + propertyId + "' can't be indexed for ametys object with id '" + ao.getId() + "' as it does not exist.");
        }
        
        return populatePartialProperty(ao, property.get(), document);
    }
    
    /**
     * Populate a Solr input document by adding fields for a single property.
     * @param ao The ametys object to index
     * @param propertyId The property ID.
     * @param document The solr document
     * @return true if there are partial update to apply
     * @throws Exception if an error occurred
     */
    public boolean populatePartialProperty(IndexableAmetysObject ao, String propertyId, SolrInputDocument document) throws Exception
    {
        ModelItem modelItem = ao.getDefinition(propertyId);
        if (modelItem instanceof Property property)
        {
            return populatePartialProperty(ao, property, document);
        }
        
        return false;
    }
    
    /**
     * Populate a Solr input document by adding fields for a single property.
     * @param ao The ametys object to index
     * @param property The property to index.
     * @param document The solr document
     * @return true if there are partial update to apply
     * @throws Exception if an error occurred
     */
    @SuppressWarnings("unchecked")
    public boolean populatePartialProperty(IndexableAmetysObject ao, Property property, SolrInputDocument document) throws Exception
    {
        SolrInputDocument tempDocument = new SolrInputDocument();
        
        if (property instanceof IndexationAwareElementDefinition indexationAwareElementDefinition)
        {
            indexationAwareElementDefinition.indexValue(tempDocument, ao, CMSDataContext.newInstance());
        }
        
        if (tempDocument.isEmpty())
        {
            // Does not have any partial update to apply, avoid to erase all the existing fields on the Solr document corresponding to this content (it would be lost)
            return false;
        }
        
        // Copy the indexed values as partial updates.
        for (String fieldName : tempDocument.getFieldNames())
        {
            Collection<Object> fieldValues = tempDocument.getFieldValues(fieldName);
            
            Map<String, Object> partialUpdate = new HashMap<>();
            partialUpdate.put("set", fieldValues);
            document.addField(fieldName, partialUpdate);
        }
        
        document.addField("id", ao.getId());
        
        return true;
    }
    
    /**
     * Update the value of a specific property in a content document.
     * @param content The content to update.
     * @param propertyId The system property ID.
     * @param workspaceName The workspace name
     * @throws Exception if an error occurs while indexing.
     */
    public void updateProperty(Content content, String propertyId, String workspaceName) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        updateProperty(content, propertyId, workspaceName, solrClient);
    }
    
    /**
     * Update the value of a specific property in a content document.
     * @param content The content to update.
     * @param propertyId The system property ID.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    public void updateProperty(Content content, String propertyId, String workspaceName, SolrClient solrClient) throws Exception
    {
        getLogger().debug("Updating the property '{}' for content {} into Solr.", propertyId, content);
        
        SolrInputDocument document = new SolrInputDocument();
        boolean hasUpdate = populatePartialProperty(content, propertyId, document);
        
        if (!hasUpdate)
        {
            getLogger().debug("Did not index '{}' property for content {} in Solr because no update to apply.", propertyId, content);
            return;
        }
        
        int status = _pushSolrDocument(document, workspaceName, solrClient);
        if (status != 0)
        {
            throw new IOException("Indexing of property '" + propertyId + "': got status code '" + status + "'.");
        }
        
        getLogger().debug("Succesfully indexed '{}' property for content {} in Solr.", propertyId, content);
    }
    
    private int _pushSolrDocument(SolrInputDocument document, String workspaceName, SolrClient solrClient) throws Exception
    {
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        UpdateResponse solrResponse = solrClient.add(collection, document);
        return solrResponse.getStatus();
    }
    
    /**
     * Remove a content from Solr index for all workspaces and commit
     * @param contentId The id of content to unindex
     * @param unindexAttachments also unindex content attachments
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexContent(String contentId, boolean unindexAttachments) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            unindexContent(contentId, workspaceName, unindexAttachments);
        }
    }
    
    /**
     * Remove a content from Solr index
     * @param contentId The id of content to unindex
     * @param workspaceName The workspace where to work in
     * @param unindexAttachments also unindex content attachments
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexContent(String contentId, String workspaceName, boolean unindexAttachments) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        unindexContent(contentId, workspaceName, unindexAttachments, solrClient);
    }
    
    /**
     * Remove a content from Solr index
     * @param contentId The id of content to unindex
     * @param workspaceName The workspace where to work in
     * @param unindexAttachments also unindex content attachments
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexContent(String contentId, String workspaceName, boolean unindexAttachments, SolrClient solrClient) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().debug("Unindexing content {} from Solr for workspace {}", contentId, workspaceName);
            
            deleteRepeaterDocs(contentId, workspaceName, solrClient);
            doUnindexDocument(contentId, workspaceName, solrClient);
            if (unindexAttachments)
            {
                doUnindexContentAttachments(contentId, workspaceName, solrClient);
            }
            _solrWorkflowIndexer.unindexAmetysObjectWorkflow(contentId, workspaceName, solrClient);
            unindexAdditionnalData("content", contentId, workspaceName, solrClient);
            
            getLogger().debug("Succesfully deleted content {} from Solr.", contentId);
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex content %s in workspace %s", contentId, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore workspace
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Remove a content from Solr index for all workspaces and commit
     * @param contentIds The id of content to unindex
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexContents(Collection<String> contentIds) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            unindexContents(contentIds, workspaceName);
        }
    }
    
    /**
     * Remove a content from Solr index
     * @param contentIds The id of content to unindex
     * @param workspaceName The workspace where to work in
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexContents(Collection<String> contentIds, String workspaceName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
            
            getLogger().debug("Unindexing several contents from Solr.");
            
            for (String contentId : contentIds)
            {
                deleteRepeaterDocs(contentId, workspaceName, solrClient);
                doUnindexDocument(contentId, workspaceName, solrClient);
                _solrWorkflowIndexer.unindexAmetysObjectWorkflow(contentId, workspaceName, solrClient);
                unindexAdditionnalData("content", contentId, workspaceName, solrClient);
            }
            
            getLogger().debug("Succesfully unindexed content from Solr.");
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex several contents in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore workspace
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Add or update a content into Solr index
     * @param content The content to index
     * @param workspaceName The workspace where to index
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void doIndexContent(Content content, String workspaceName, SolrClient solrClient) throws Exception
    {
        long time_0 = System.currentTimeMillis();
        
        SolrInputDocument document = new SolrInputDocument();
        List<SolrInputDocument> additionalDocuments = _solrContentIndexer.indexContent(content, document);
        
        long time_1 = System.currentTimeMillis();
        getLogger().debug("Populate indexing fields for content {} for workspace {} in {} ms", content.getId(), workspaceName, time_1 - time_0);
        
        indexAclInitValues(content, document);
        
        long time_2 = System.currentTimeMillis();
        getLogger().debug("Populate ACL for content {} for workspace {} in {} ms", content.getId(), workspaceName, time_2 - time_1);
        
        List<SolrInputDocument> documents = new ArrayList<>(additionalDocuments);
        documents.add(document);
        
        UpdateResponse solrResponse = solrClient.add(_solrClientProvider.getCollectionName(workspaceName), documents);
        int status = solrResponse.getStatus();
        
        long time_3 = System.currentTimeMillis();
        getLogger().debug("Update document for content {} for workspace {} in {} ms", content.getId(), workspaceName, time_3 - time_2);
        
        if (status != 0)
        {
            throw new IOException("Content indexation: got status code '" + status + "'.");
        }
    }
    
    /**
     * Indexes read-ACl initial values for object
     * @param ametysObject The object
     * @param document The Solr document
     */
    public void indexAclInitValues(AmetysObject ametysObject, SolrInputDocument document)
    {
        // Indexation of AmetysObject property
        document.addField(SolrFieldNames.IS_AMETYS_OBJECT, true);
        
        // Indexation of initValues for AllowedUsers
        AllowedUsers allowedUsers = _readAccessHelper.allowedUsers(ametysObject);
        document.addField(SolrFieldNames.ACL_INIT_VALUE_ANONYMOUS, allowedUsers.isAnonymousAllowed());
        document.addField(SolrFieldNames.ACL_INIT_VALUE_ANYCONNECTED, allowedUsers.isAnyConnectedUserAllowed());
        _addField(document, SolrFieldNames.ACL_INIT_VALUE_ALLOWED_USERS, allowedUsers.getAllowedUsers(), UserIdentity::userIdentityToString);
        _addField(document, SolrFieldNames.ACL_INIT_VALUE_DENIED_USERS, allowedUsers.getDeniedUsers(), UserIdentity::userIdentityToString);
        _addField(document, SolrFieldNames.ACL_INIT_VALUE_ALLOWED_GROUPS, allowedUsers.getAllowedGroups(), GroupIdentity::groupIdentityToString);
        _addField(document, SolrFieldNames.ACL_INIT_VALUE_DENIED_GROUPS, allowedUsers.getDeniedGroups(), GroupIdentity::groupIdentityToString);
    }
    
    private <T> void _addField(SolrInputDocument document, String fieldName, Set<T> values, Function<T, String> stringifier)
    {
        if (values == null)
        {
            return;
        }
        
        for (T value : values)
        {
            document.addField(fieldName, stringifier.apply(value));
        }
    }
    
    /**
     * Index the whole workflow of a content.
     * @param content The content.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void doIndexContentWorkflow(Content content, String workspaceName, SolrClient solrClient) throws Exception
    {
        if (content instanceof WorkflowAwareContent)
        {
            _solrWorkflowIndexer.indexAmetysObjectWorkflow((WorkflowAwareContent) content, workspaceName, solrClient);
        }
    }
    
    /**
     * Index content attachments as new entries in the idnex
     * @param collection the collection of attachments
     * @param content the content whose attachments will be indexed
     * @throws Exception if something goes wrong when indexing the attachments of the content
     */
    public void indexContentAttachments(ResourceCollection collection, Content content) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        indexContentAttachments(collection, content, solrClient);
    }
    
    /**
     * Index content attachments as new entries in the idnex
     * @param collection the collection of attachments
     * @param content the content whose attachments will be indexed
     * @param solrClient The solr client to use
     * @throws Exception if something goes wrong when indexing the attachments of the content
     */
    public void indexContentAttachments(ResourceCollection collection, Content content, SolrClient solrClient) throws Exception
    {
        if (collection == null)
        {
            return;
        }
        
        try (AmetysObjectIterable<AmetysObject> children = collection.getChildren())
        {
            for (AmetysObject object : children)
            {
                if (object instanceof ResourceCollection)
                {
                    indexContentAttachments((ResourceCollection) object, content, solrClient);
                }
                else if (object instanceof Resource)
                {
                    Resource resource = (Resource) object;
                    indexContentAttachment(resource, content, solrClient);
                }
            }
        }
    }
    
    /**
     * Index a content attachment
     * @param resource the content attachment as a {@link Resource}
     * @param content the content whose attachment is going to be indexed
     * @throws Exception if something goes wrong when processing the indexation of the content attachment
     */
    public void indexContentAttachment(Resource resource, Content content) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        indexContentAttachment(resource, content, solrClient);
    }
    
    /**
     * Index a content attachment
     * @param resource the content attachment as a {@link Resource}
     * @param content the content whose attachment is going to be indexed
     * @param solrClient The solr client to use
     * @throws Exception if something goes wrong when processing the indexation of the content attachment
     */
    public void indexContentAttachment(Resource resource, Content content, SolrClient solrClient) throws Exception
    {
        SolrInputDocument document = new SolrInputDocument();
        
        // Prepare resource doc
        List<SolrInputDocument> additionalDocuments = _indexContentAttachment(resource, document, content);
        List<SolrInputDocument> documents = new ArrayList<>(additionalDocuments);
        documents.add(document);
        
        // Indexation of the document
        _indexResourceDocument(resource, documents, solrClient);
    }
    
    private List<SolrInputDocument> _indexContentAttachment(Resource resource, SolrInputDocument document, Content content) throws Exception
    {
        String language = content.getLanguage();
        
        List<SolrInputDocument> additionalDocuments = _solrResourceIndexer.indexResource(resource, document, SolrFieldNames.TYPE_CONTENT_ATTACHMENT_RESOURCE, language);
        
        // Need the id of the content for unindexing attachment during the unindexing of the content
        document.addField(SolrFieldNames.ATTACHMENT_CONTENT_ID, content.getId());
        
        return additionalDocuments;
    }
    
    /**
     * Index a populated solr input document of type Resource.
     * @param resource the resource from which the input document is created
     * @param documents the input documents
     * @param solrClient The solr client to use
     * @throws SolrServerException if there is an error on the server
     * @throws IOException if there is a communication error with the server
     */
    protected void _indexResourceDocument(Resource resource, List<SolrInputDocument> documents, SolrClient solrClient) throws SolrServerException, IOException
    {
        String resourceId = resource.getId();
        
        // Retrieve appropriate collection name
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        
        // Add document
        UpdateResponse solrResponse = solrClient.add(collectionName, documents);
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys resource indexing - Expecting status code of '0' in the Solr response but got : '" + status + "'. Resource id : " + resourceId);
        }
        
        getLogger().debug("Successful resource indexing. Resource identifier : {}", resourceId);
    }
    
    /**
     * Delete repeater documents of a specified content.
     * @param workspaceName The workspace name
     * @param contentId the content ID.
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void deleteRepeaterDocs(String contentId, String workspaceName, SolrClient solrClient) throws Exception
    {
        long time_0 = System.currentTimeMillis();
        
        // _documentType:repeater AND id:content\://xxx/*
        StringBuilder query = new StringBuilder();
        query.append(SolrFieldNames.DOCUMENT_TYPE).append(':').append(SolrFieldNames.TYPE_REPEATER)
             .append(" AND id:").append(ClientUtils.escapeQueryChars(contentId)).append("/*");
        
        solrClient.deleteByQuery(_solrClientProvider.getCollectionName(workspaceName), query.toString());
        
        getLogger().debug("Successfully delete repeaters documents for content {} in {} ms", contentId, System.currentTimeMillis() - time_0);
    }
    
    /**
     * Index all the resources in a given workspace.
     * @param workspaceName The workspace where to index
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return The indexation result as a Map.
     * @throws Exception if an error occurs while indexing.
     */
    public Map<String, Object> indexAllResources(String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().info("Starting the indexation of all resources for workspace {}", workspaceName);
            
            long start = System.currentTimeMillis();
            
            // Delete all resources
            _unindexAllResources(workspaceName, solrClient);
            
            Map<String, Object> results = new HashMap<>();
            
            try
            {
                TraversableAmetysObject resourceRoot = _resolver.resolveByPath(RepositoryConstants.NAMESPACE_PREFIX + ":resources");
                AmetysObjectIterable<Resource> resources = resourceRoot.getChildren();
                
                IndexationResult result = doIndexResources(resources, SolrFieldNames.TYPE_RESOURCE, resourceRoot, workspaceName, solrClient, progressionTracker);
                
                long end = System.currentTimeMillis();
                
                if (!result.hasErrors())
                {
                    getLogger().info("{} resources indexed without error in {} milliseconds.", result.successCount(), end - start);
                }
                else
                {
                    getLogger().info("Resource indexation ended, the process took {} milliseconds. {} resources were not indexed successfully, please review the error logs above for more details.", end - start, result.errorCount());
                }
                
                results.put("successCount", result.successCount());
                if (result.hasErrors())
                {
                    results.put("errorCount", result.errorCount());
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().info("There is no root for resources in current workspace.");
                progressionTracker.setSize(0);
            }
            
            return results;
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index all resources in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Send a collection of contents for indexation in the solr server.
     * @param resources the collection of contents to index.
     * @param documentType The document type of the resource
     * @param workspaceName The workspace where to index
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexResources(Iterable<AmetysObject> resources, String documentType, String workspaceName) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        return indexResources(resources, documentType, null, workspaceName, solrClient);
    }
    
    /**
     * Send a collection of contents for indexation in the solr server.
     * @param resources the collection of contents to index.
     * @param documentType The document type of the resource
     * @param resourceRoot The resource root, can be null. In that case, it will be computed for each resource.
     * @param workspaceName The workspace where to index
     * @param solrClient The solr client to use
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexResources(Iterable<? extends AmetysObject> resources, String documentType, TraversableAmetysObject resourceRoot, String workspaceName, SolrClient solrClient) throws Exception
    {
        return indexResources(resources, documentType, resourceRoot, workspaceName, solrClient, ProgressionTrackerFactory.createSimpleProgressionTracker("Index resources", getLogger()));
    }
    
    /**
     * Send a collection of contents for indexation in the solr server.
     * @param resources the collection of contents to index.
     * @param documentType The document type of the resource
     * @param resourceRoot The resource root, can be null. In that case, it will be computed for each resource.
     * @param workspaceName The workspace where to index
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs while indexing.
     */
    public IndexationResult indexResources(Iterable<? extends AmetysObject> resources, String documentType, TraversableAmetysObject resourceRoot, String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().info("Starting indexation of several resources for workspace {}", workspaceName);
            
            long start = System.currentTimeMillis();
            
            IndexationResult result = doIndexResources(resources, documentType, resourceRoot, workspaceName, solrClient, progressionTracker);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} resources indexed without error in {} milliseconds.", result.successCount(), end - start);
            }
            else
            {
                getLogger().info("Resource indexation ended, the process took {} milliseconds. {} resources were not indexed successfully, please review the error logs above for more details.", end - start, result.errorCount());
            }
            
            return result;
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index several resources in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Send some resources for indexation in the solr server.
     * @param resources the resources to index.
     * @param documentType The document type of the resource
     * @param resourceRoot The resource root, can be null. In that case, it will be computed for each resource.
     * @param workspaceName The workspace where to index
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs committing the results.
     */
    protected IndexationResult doIndexResources(Iterable<? extends AmetysObject> resources, String documentType, TraversableAmetysObject resourceRoot, String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        try
        {
            // Add callable for each content to index
            List<Future<Void>> tasks = new ArrayList<>();
            for (AmetysObject resource : resources)
            {
                tasks.addAll(_asyncIndexExplorerItem(resource, documentType, resourceRoot, solrClient));
            }
            
            // Now that everything is submitted, we can iterate and wait for result
            return IndexationResult.fromTasks(tasks, getLogger());
        }
        finally
        {
            progressionTracker.increment();
        }
    }
    
    /**
     * Add or update a resource into Solr index
     * @param resource The resource to index
     * @param documentType The document type of the resource
     * @param workspaceName The workspace where to index
     * @throws Exception if an error occurs while indexing.
     */
    public void indexResource(Resource resource, String documentType, String workspaceName) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        doIndexResources(Collections.singleton(resource), documentType, null, workspaceName, solrClient, ProgressionTrackerFactory.createSimpleProgressionTracker("Index resource", getLogger()));
    }
    
    private void _unindexAllResources(String workspaceName, SolrClient solrClient) throws Exception
    {
        getLogger().debug("Unindexing all resources from Solr.");
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        solrClient.deleteByQuery(collection, SolrFieldNames.DOCUMENT_TYPE + ':' + SolrFieldNames.TYPE_RESOURCE);
        
        getLogger().debug("Succesfully deleted all resource documents from Solr.");
    }
    
    /**
     * Delete all resource documents at a given path for all workspaces and commit
     * @param rootId The resource root ID, must not be null.
     * @param path The resource path relative to the given root, must start with a slash.
     * @throws Exception If an error occurs while unindexing.
     */
    public void unindexResourcesByPath(String rootId, String path) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            unindexResourcesByPath(rootId, path, workspaceName);
        }
    }
    
    /**
     * Delete all resource documents at a given path.
     * @param rootId The resource root ID, must not be null.
     * @param path The resource path relative to the given root, must start with a slash.
     * @param workspaceName The workspace where to work in
     * @throws Exception If an error occurs while unindexing.
     */
    public void unindexResourcesByPath(String rootId, String path, String workspaceName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().debug("Unindexing all resources at path {} in root {}", path, rootId);
            
            Query query = new ResourceLocationQuery(rootId, path);
            
            String collection = _solrClientProvider.getCollectionName(workspaceName);
            _getAutoCommitSolrClient(workspaceName).deleteByQuery(collection, query.build());
            
            // unindexAdditionnalDataIndexer("resources", ???, workspaceName, solrClient);

            getLogger().debug("Succesfully deleted resource document from Solr.");
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex resource %s in workspace %s", path, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore workspace
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Remove a resource from Solr index for all workspaces and commit
     * @param resourceId The id of resource to unindex
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexResource(String resourceId) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            unindexResource(resourceId, workspaceName);
        }
    }
    
    /**
     * Remove a resource from the Solr index.
     * @param resourceId The id of resource to unindex
     * @param workspaceName The workspace where to work in
     * @throws Exception if an error occurs while unindexing.
     */
    public void unindexResource(String resourceId, String workspaceName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
            
            getLogger().debug("Unindexing resource {} from Solr.", resourceId);
            
            doUnindexDocument(resourceId, workspaceName, solrClient);
            unindexAdditionnalData("resource", resourceId, workspaceName, solrClient);
            
            getLogger().debug("Succesfully deleted resource {} from Solr.", resourceId);
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex resource  %s in workspace %s", resourceId, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore workspace
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    private List<Future<Void>> _asyncIndexExplorerItem(AmetysObject node, String documentType, TraversableAmetysObject resourceRoot, SolrClient solrClient) throws Exception
    {
        List<Future<Void>> tasks = new ArrayList<>();
        
        if (node instanceof ResourceCollection resourceCollection)
        {
            try (AmetysObjectIterable<AmetysObject> children = resourceCollection.getChildren())
            {
                for (AmetysObject child : children)
                {
                    tasks.addAll(_asyncIndexExplorerItem(child, documentType, resourceRoot, solrClient));
                }
            }
            catch (Throwable t)
            {
                getLogger().error("Failed to index resource collection {}. Skipping it.", resourceCollection.getId(), t);
            }
        }
        else if (node instanceof Resource resource)
        {
            tasks.add(_threadIndexerHelper.submitCallable(new ResourceIndexerCallable(resource, _workspaceSelector.getWorkspace(), documentType, resourceRoot, solrClient)));
        }
        
        return tasks;
    }
    
    /**
     * Process a Solr commit operation in all workspaces.
     * <br>Use this only after a long operation with updates sent via {@link NoAutoCommitUpdateClient}
     * @throws SolrServerException if there is an error on the server
     * @throws IOException if there is a communication error with the server
     */
    public void commit() throws SolrServerException, IOException
    {
        String[] workspaceNames;
        try
        {
            workspaceNames = _repository.getWorkspaces();
            for (String workspaceName : workspaceNames)
            {
                SolrClient solrClient = _getNoAutoCommitSolrClient(workspaceName);
                commit(workspaceName, solrClient);
            }
        }
        catch (RepositoryException e)
        {
            throw new RuntimeException("An exception occured while retrieving JCR workspaces. Cannot commited to Solr.", e);
        }
    }
    
    /**
     * Process a Solr commit operation in given workspace.
     * @param workspaceName The workspace's name
     * @param solrClient The solr client to use
     * @throws SolrServerException if there is an error on the server
     * @throws IOException if there is a communication error with the server
     */
    public void commit(String workspaceName, SolrClient solrClient) throws SolrServerException, IOException
    {
        long time_0 = System.currentTimeMillis();
        
        // Commit
        UpdateResponse solrResponse = solrClient.commit(_solrClientProvider.getCollectionName(workspaceName));
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys indexing: Solr commit operation - Expecting status code of '0' in the Solr response but got : '" + status + "'.");
        }
        
        getLogger().debug("Successful Solr commit operation during an Ametys indexing process in {} ms", System.currentTimeMillis() - time_0);
    }
    
    /**
     * Launch a solr index optimization.
     * @param workspaceName The workspace's name
     * @param solrClient The solr client to use
     * @throws SolrServerException if there is an error on the server
     * @throws IOException if there is a communication error with the server
     */
    public void optimize(String workspaceName, SolrClient solrClient) throws SolrServerException, IOException
    {
        UpdateResponse solrResponse = solrClient.optimize(_solrClientProvider.getCollectionName(workspaceName));
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys indexing: Solr optimize operation - Expecting status code of '0' in the Solr response but got : '" + status + "'.");
        }
        
        getLogger().debug("Successful Solr optimize operation during an Ametys indexing process.");
    }
    
    /**
     * Delete all documents from the solr index.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while unindexing.
     */
    public void unindexAllDocuments(String workspaceName, SolrClient solrClient) throws Exception
    {
        getLogger().debug("Deleting all documents from Solr.");
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        solrClient.deleteByQuery(collection, "*:*");
        
        getLogger().debug("Successfully deleted all documents from Solr.");
    }
    
    /**
     * Delete a document from the Solr server.
     * @param id The id of the document to delete from Solr
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void doUnindexDocument(String id, String workspaceName, SolrClient solrClient) throws Exception
    {
        UpdateResponse solrResponse = solrClient.deleteById(_solrClientProvider.getCollectionName(workspaceName), id);
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Deletion of document " + id + ": got status code '" + status + "'.");
        }
    }
    
    /**
     * Delete content attachments documents of a given content from the Solr server.
     * @param contentId The id of the content
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void doUnindexContentAttachments(String contentId, String workspaceName, SolrClient solrClient) throws Exception
    {
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        
        Query query = new ContentAttachmentQuery(contentId);
        UpdateResponse solrResponse = solrClient.deleteByQuery(collectionName, query.build());
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Deletion of content attachments of content " + contentId + ": got status code '" + status + "'.");
        }
    }

    /**
     * Add or update a trash element into Solr index on all workspaces and commit
     * @param trashElementId The id of the trash element to index
     * @throws Exception if an error occurs while indexing.
     */
    public void indexTrashElement(String trashElementId) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            indexTrashElement(trashElementId, workspaceName);
        }
    }

    /**
     * Add or update a trash element into Solr index
     * @param trashElementId The id of the trash element to index
     * @param workspaceName the workspace where to index
     * @throws Exception if an error occurs while indexing.
     */
    public void indexTrashElement(String trashElementId, String workspaceName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);

        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            if (_resolver.hasAmetysObjectForId(trashElementId))
            {
                DefaultTrashElement trashElement = _resolver.resolveById(trashElementId);
                doIndexTrashElements(Collections.singleton(trashElement), workspaceName, solrClient, ProgressionTrackerFactory.createSimpleProgressionTracker("Index trash element", getLogger()));
            }
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }

    /**
     * Index all the trash elements in a given workspace.
     * @param workspaceName the workspace where to index
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return The indexation result as a Map.
     * @throws Exception if an error occurs while indexing.
     */
    public Map<String, Object> indexAllTrashElements(String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            getLogger().info("Starting the indexation of all trash elements for workspace {}", workspaceName);
            
            long start = System.currentTimeMillis();
            
            // Delete all trash elements
            unindexAllTrashElements(workspaceName, solrClient);

            String query = QueryHelper.getXPathQuery(null, TrashElementFactory.TRASH_ELEMENT_NODETYPE, null);
            AmetysObjectIterable<DefaultTrashElement> trashElements = _resolver.query(query);
            
            IndexationResult result = doIndexTrashElements(trashElements, workspaceName, solrClient, progressionTracker);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} trash elements indexed without error in {} milliseconds.", result.successCount(), end - start);
            }
            else
            {
                getLogger().info("Trash elements indexation ended, the process took {} milliseconds. {} trash elements were not indexed successfully, please review the error logs above for more details.", end - start, result.errorCount());
            }
            
            Map<String, Object> results = new HashMap<>();
            results.put("successCount", result.successCount());
            if (result.hasErrors())
            {
                results.put("errorCount", result.errorCount());
            }
            
            return results;
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index all trash elements in workspace %s", workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }

    /**
     * Remove a trash element from Solr index for all workspaces and commit
     * @param trashElementId The id of trash element to unindex
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexTrashElement(String trashElementId) throws Exception
    {
        String[] workspaceNames = _repository.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            unindexTrashElement(trashElementId, workspaceName);
        }
    }

    /**
     * Remove a trash element from Solr index
     * @param trashElementId The id of trash element to unindex
     * @param workspaceName The workspace where to work in
     * @throws Exception if an error occurs while indexing.
     */
    public void unindexTrashElement(String trashElementId, String workspaceName) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);

        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            
            UpdateResponse solrResponse = solrClient.deleteById(_solrClientProvider.getCollectionName(workspaceName), trashElementId);
            int status = solrResponse.getStatus();
            
            if (status != 0)
            {
                throw new IOException("Deletion of document " + trashElementId + ": got status code '" + status + "'.");
            }
            
            unindexResourcesByPath("trashelement", trashElementId, workspaceName);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Unindex all trash elements documents.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @throws Exception if an error occurs while unindexing.
     */
    protected void unindexAllTrashElements(String workspaceName, SolrClient solrClient) throws Exception
    {
        getLogger().debug("Unindexing all trash elements from Solr.");
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        Query query = new DocumentTypeQuery(SolrFieldNames.TYPE_TRASH_ELEMENT);
        
        Query unindexAllAdditionnalDataIndexer = unindexAllAdditionnalData("trashelement");
        if (unindexAllAdditionnalDataIndexer != null)
        {
            query = new OrQuery(query, unindexAllAdditionnalDataIndexer);
        }
        
        solrClient.deleteByQuery(collection, query.build());
        
        getLogger().debug("Succesfully deleted all trash elements documents from Solr.");
    }
    
    /**
     * Send some trash elements for indexation in the solr server.
     * @param trashElements the trash elements to index.
     * @param workspaceName The workspace name
     * @param solrClient The solr client to use
     * @param progressionTracker The progression of the indexation
     * @return the indexation result.
     * @throws Exception if an error occurs committing the results.
     */
    protected IndexationResult doIndexTrashElements(Iterable<DefaultTrashElement> trashElements, String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker) throws Exception
    {
        int numberOfTrashElements = IterableUtils.size(trashElements);
        progressionTracker.setSize(numberOfTrashElements);
        
        // Add callable for each content to index
        List<Future<Void>> tasks = new ArrayList<>();
        for (DefaultTrashElement trashElement : trashElements)
        {
            tasks.add(_threadIndexerHelper.submitCallable(new TrashElementIndexerCallable(trashElement, workspaceName, solrClient, progressionTracker)));
        }
        
        // Now that everything is submitted, we can iterate and wait for result
        return IndexationResult.fromTasks(tasks, getLogger());
    }
    
//    /**
//     * Get the collection to use.
//     * @return The name of the collection to index into.
//     */
//    protected String getCollection()
//    {
//        return _solrCorePrefix + _workspaceSelector.getWorkspace();
//    }

    
    /**
     * Unindex additional data indexed by additional data indexers.
     * @param type The type of the additional data indexer
     * @param ametysObjectId The id of the ametys object to unindex
     * @param workspaceName The workspace where to work in
     * @param solrClient The solr client to use
     * @throws Exception If an error occurs while unindexing.
     */
    protected void unindexAdditionnalData(String type, String ametysObjectId, String workspaceName, SolrClient solrClient) throws Exception
    {
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        
        List<Query> queries = new ArrayList<>();
        
        Collection<AdditionalDataIndexer> indexers = _additionalDataIndexerEP.getIndexers(type);
        for (AdditionalDataIndexer indexer : indexers)
        {
            queries.addAll(indexer.getUnindexObjectQuery(ametysObjectId));
        }
        
        if (queries.isEmpty())
        {
            return;
        }
        
        Query query = new OrQuery(queries);
        UpdateResponse solrResponse = solrClient.deleteByQuery(collectionName, query.build());
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Deletion of additionnal data of ametys object " + ametysObjectId + ": got status code '" + status + "'.");
        }
    }
    
    /**
     * Get the query to unindex all additional data indexed by additional data indexers for a given type.
     * @param type The type of the additional data indexer
     * @return The query to unindex all additional data indexed by additional data indexers for the given type.
     * @throws Exception If an error occurs while unindexing.
     */
    protected Query unindexAllAdditionnalData(String type) throws Exception
    {
        List<Query> queries = new ArrayList<>();
        
        Collection<AdditionalDataIndexer> indexers = _additionalDataIndexerEP.getIndexers(type);
        for (AdditionalDataIndexer indexer : indexers)
        {
            queries.add(indexer.getUnindexAllQuery(type));
        }
        
        List<Query> nonNullQueries = queries.stream().filter(Objects::nonNull).toList();
        if (nonNullQueries.isEmpty())
        {
            return null;
        }
        else
        {
            return new OrQuery(nonNullQueries);
        }
    }

    
    private static final class SchemaRequestComparator implements Comparator<SchemaRequest.Update>
    {
        public int compare(SchemaRequest.Update u1, SchemaRequest.Update u2)
        {
            return Integer.compare(_getOrder(u1), _getOrder(u2));
        }
        
        private int _getOrder(SchemaRequest.Update update)
        {
            // Field types are needed first to define fields
            if (update instanceof SchemaRequest.AddFieldType)
            {
                return 1;
            }
            
            // Fields or dynamic fields can be defined at the same time
            if (update instanceof SchemaRequest.AddField || update instanceof SchemaRequest.AddDynamicField)
            {
                return 2;
            }
            
            // Copy fields can be based on fields or dynamic fields
            if (update instanceof SchemaRequest.AddCopyField)
            {
                return 3;
            }
            
            return 0;
        }
    }
    
    private class ContentIndexerCallable extends AbstractIndexerCallable<Content>
    {
        private boolean _indexAttachments;
        private SimpleProgressionTracker _tracker;

        @SuppressWarnings("synthetic-access")
        public ContentIndexerCallable(Content content, String workspaceName, boolean indexAttachments, SolrClient solrClient, SimpleProgressionTracker progressionTracker)
        {
            super(content, workspaceName, solrClient, _manager, _cocoonContext, _resolver, getLogger());
            this._indexAttachments = indexAttachments;
            this._tracker = progressionTracker;
        }

        @Override
        protected void process(Content content) throws Exception
        {
            try
            {
                doIndexContent(content, _workspaceName, _solrClient);
                doIndexContentWorkflow(content, _workspaceName, _solrClient);
                if (_indexAttachments)
                {
                    indexContentAttachments(content.getRootAttachments(), content, _solrClient);
                }
            }
            finally
            {
                _tracker.increment();
            }
        }

        @Override
        protected String getObjectLabel()
        {
            return "content";
        }
    }
    
    private class ResourceIndexerCallable extends AbstractIndexerCallable<Resource>
    {
        private String _documentType;
        private TraversableAmetysObject _resourceRoot;
        
        @SuppressWarnings("synthetic-access")
        public ResourceIndexerCallable(Resource resource, String workspaceName, String documentType, TraversableAmetysObject resourceRoot, SolrClient solrClient)
        {
            super(resource, workspaceName, solrClient, _manager, _cocoonContext, _resolver, getLogger());
            this._documentType = documentType;
            this._resourceRoot = resourceRoot;
        }
        
        @Override
        protected void process(Resource resource) throws Exception
        {
            SolrInputDocument document = new SolrInputDocument();
            
            List<SolrInputDocument> additionalDocuments = _solrResourceIndexer.indexResource(resource, document, _documentType, _resourceRoot);
            List<SolrInputDocument> documents = new ArrayList<>(additionalDocuments);
            documents.add(document);
            
            UpdateResponse solrResponse = _solrClient.add(_solrClientProvider.getCollectionName(_workspaceName), documents);
            int status = solrResponse.getStatus();
            
            if (status != 0)
            {
                throw new IOException("Resource indexation: got status code '" + status + "'.");
            }
        }

        @Override
        protected String getObjectLabel()
        {
            return "resource";
        }
    }
    
    private class TrashElementIndexerCallable extends AbstractIndexerCallable<DefaultTrashElement>
    {
        private SimpleProgressionTracker _tracker;

        @SuppressWarnings("synthetic-access")
        public TrashElementIndexerCallable(DefaultTrashElement trashElement, String workspaceName, SolrClient solrClient, SimpleProgressionTracker progressionTracker)
        {
            super(trashElement, workspaceName, solrClient, _manager, _cocoonContext, _resolver, getLogger());
            this._tracker = progressionTracker;
        }

        @Override
        protected void process(DefaultTrashElement trashElement) throws Exception
        {
            try
            {
                SolrInputDocument document = new SolrInputDocument();
                List<SolrInputDocument> additionalDocuments = _solrTrashElementIndexer.indexTrashElement(trashElement, document);
                
                List<SolrInputDocument> documents = new ArrayList<>(additionalDocuments);
                documents.add(document);
                
                UpdateResponse solrResponse = _solrClient.add(_solrClientProvider.getCollectionName(_workspaceName), documents);
                int status = solrResponse.getStatus();
                
                if (status != 0)
                {
                    throw new IOException("Trash element indexation: got status code '" + status + "'.");
                }
            }
            finally
            {
                _tracker.increment();
            }
        }

        @Override
        protected String getObjectLabel()
        {
            return "trashElement";
        }
    }
}