/*
 *  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.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
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.components.ContextHelper;
import org.apache.cocoon.environment.Request;
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.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.request.CoreAdminRequest;
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.QueryResponse;
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.util.NamedList;
import org.slf4j.Logger;

import org.ametys.cms.indexing.IndexingException;
import org.ametys.cms.indexing.solr.ReloadAclCacheRequest;
import org.ametys.cms.indexing.solr.UpdateCorePropertyRequest;
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.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.CopyFieldDefinition;
import org.ametys.cms.search.solr.schema.FieldDefinition;
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.core.group.GroupIdentity;
import org.ametys.core.right.AllowedUsers;
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.collection.AmetysObjectCollection;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.runtime.config.Config;
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 ThreadLocal<SimpleDateFormat> __DATE_FORMAT = new ThreadLocal<>();
    
    private static final String _CONFIGSET_NAME_PREFIX = "configset-";
    
    private static final List<String> _READ_ONLY_FIELDS = Arrays.asList("id", "_root_", "_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 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;
    
    /** 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 helper for read access */
    protected ReadAccessHelper _readAccessHelper;
    
    /** The avalon context */
    protected Context _context;
    
    /**
     * Returns the formatter for indexing dates. This is used for adding a dates as formatted strings (and not with date object directly) to prevent indexing of the wrong value because of time zone
     * @return The date format for indexing dates
     */
    public static SimpleDateFormat dateFormat()
    {
        if (__DATE_FORMAT.get() == null)
        {
            __DATE_FORMAT.set(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
        }
        return __DATE_FORMAT.get();
    }
    
    /**
     * 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
    {
        _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);
        _solrClientProvider = (SolrClientProvider) serviceManager.lookup(SolrClientProvider.ROLE);
        _workspaceSelector = (WorkspaceSelector) serviceManager.lookup(WorkspaceSelector.ROLE);
        _readAccessHelper = (ReadAccessHelper) serviceManager.lookup(ReadAccessHelper.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;
    }
    
    /**
     * 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.
     */
    @SuppressWarnings("unchecked")
    public Set<String> getCoreNames() throws IOException, SolrServerException
    {
        Set<String> coreNames = new HashSet<>();
        
        getLogger().debug("Getting core list.");
        
        SolrQuery query = new SolrQuery();
        query.setRequestHandler("/admin/cores");
        query.setParam("action", "STATUS");
        
        QueryResponse response = _defaultSolrClient().query(query);
        
        NamedList<NamedList<?>> status = (NamedList<NamedList<?>>) response.getResponse().get("status");
        for (Map.Entry<String, NamedList<?>> 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
    {
        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);
        
        SolrQuery query = new SolrQuery();
        query.setRequestHandler("/admin/cores");
        query.setParam("action", "CREATE");
        query.setParam("name", fullName);
        query.setParam("configSet", configsetName);
        query.setParam("property.ametys.url", _ametysInternalUrl);
        
        QueryResponse response = _defaultSolrClient().query(query);
        NamedList<?> results = response.getResponse();
        
        NamedList<?> error = (NamedList<?>) results.get("error");
        if (error != null)
        {
            throw new IOException("Error creating the core: " + error.get("msg"));
        }
    }
    
    /**
     * 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.
        SolrQuery query = new SolrQuery();
        query.setRequestHandler("/admin/cores");
        query.setParam("action", "createConfigset");
        query.setParam("name", name);
        
        QueryResponse response = _defaultSolrClient().query(query);
        NamedList<?> results = response.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);
        
        SolrQuery query = new SolrQuery();
        query.setRequestHandler("/admin/cores");
        query.setParam("action", "UNLOAD");
        query.setParam("core", fullName);
        query.setParam("deleteInstanceDir", "true");
        
        QueryResponse response = _defaultSolrClient().query(query);
        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);
        
        reorderUpdates(updates);
        
        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 (!definitionExists(definition, schemaFields))
                {
                    SchemaRequest.Update update = getSchemaUpdate(definition);
                    if (update != null)
                    {
                        updates.add(update);
                    }
                }
            }
        }
        
//        for (String propId : _sysPropEP.getExtensionsIds())
//        {
//            Collection<SchemaDefinition> definitions = _sysPropEP.getExtension(propId).getSchemaDefinitions();
//            
//            for (SchemaDefinition definition : definitions)
//            {
//                if (!definitionExists(definition, schemaFields))
//                {
//                    SchemaRequest.Update update = getSchemaUpdate(definition);
//                    if (update != null)
//                    {
//                        updates.add(update);
//                    }
//                }
//            }
//        }
    }
    
    /**
     * Reorder the list of {@link Update} directives.
     * @param updates The list of {@link Update} directives to reorder.
     */
    protected void reorderUpdates(List<SchemaRequest.Update> updates)
    {
        updates.sort(Comparator.comparing(u ->
        {
            if (u instanceof SchemaRequest.AddCopyField)
            {
                // copyField at the end of the list to avoid an exception of an undeclared 'source' or 'dest' whereas it is declared later
                return 1;
            }
            else
            {
                return 0;
            }
        }));
    }
    
    /**
     * Test if the given schema definition exists in the given {@link SchemaFields} reference.
     * @param definition The schema definition to test.
     * @param schemaFields The current schema fields.
     * @return true if the SchemaFields contain the schema definition.
     */
    protected boolean definitionExists(SchemaDefinition definition, SchemaFields schemaFields)
    {
        if (definition instanceof FieldDefinition)
        {
            FieldDefinition fieldDef = (FieldDefinition) definition;
            if (fieldDef.isDynamic())
            {
                return schemaFields.hasField(fieldDef.getName());
            }
            else
            {
                return schemaFields.hasDynamicField(fieldDef.getName());
            }
        }
        else if (definition instanceof CopyFieldDefinition)
        {
            CopyFieldDefinition fieldDef = (CopyFieldDefinition) definition;
            return schemaFields.hasCopyField(fieldDef.getSource(), fieldDef.getDestination());
        }
        
        return false;
    }
    
    /**
     * 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;
        }
    }
    
    /**
     * Get the schema {@link Update} directive from the given schema definition.
     * @param definition The schema definition to add.
     * @return The add {@link Update} directive.
     */
    protected SchemaRequest.Update getSchemaUpdate(SchemaDefinition definition)
    {
        SchemaRequest.Update update = null;
        
        if (definition instanceof FieldDefinition)
        {
            FieldDefinition fieldDef = (FieldDefinition) definition;
            
            // Force indexed and stored attributes to true.
            Map<String, Object> attributes = new HashMap<>();
            attributes.put("name", fieldDef.getName());
            attributes.put("type", fieldDef.getType());
            attributes.put("multiValued", fieldDef.isMultiValued());
            attributes.put("docValues", fieldDef.isDocValues());
            attributes.put("indexed", Boolean.TRUE);
            attributes.put("stored", Boolean.TRUE);
            
            update = new SchemaRequest.AddField(attributes);
        }
        else if (definition instanceof CopyFieldDefinition)
        {
            CopyFieldDefinition fieldDef = (CopyFieldDefinition) definition;
            
            String source = fieldDef.getSource();
            String dest = fieldDef.getDestination();
            
            update = new SchemaRequest.AddCopyField(source, Arrays.asList(dest));
        }
        
        return update;
    }
    
    /**
     * 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 = _workspaceSelector.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);
        }
    }
    
    /**
     * 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
    {
        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);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} contents indexed without error in {} milliseconds.", result.getSuccessCount(), 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.getErrorCount());
            }
            
            Map<String, Object> results = new HashMap<>();
            results.put("successCount", result.getSuccessCount());
            if (result.hasErrors())
            {
                results.put("errorCount", result.getErrorCount());
            }
            
            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;
        }
        solrClient.deleteByQuery(collection, query.build());
    }
    
    /**
     * Add or update the child contents of a {@link AmetysObjectCollection} into Solr index, for all workspaces and commit
     * @param collectionId The id of collection 
     * @param indexAttachments to index content attachments
     * @throws Exception if an error occurs while indexing.
     */
    public void indexSubcontents(String collectionId, boolean indexAttachments) throws Exception
    {
        String[] workspaceNames = _workspaceSelector.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            indexSubcontents(collectionId, workspaceName, indexAttachments);
        }
    }
    
    /**
     * Index the child contents of a {@link AmetysObjectCollection}
     * @param collectionId The id of collection 
     * @param workspaceName the workspace where to index
     * @param indexAttachments to index content attachments
     * @throws Exception if an error occurs while unindexing.
     */
    public void indexSubcontents(String collectionId, String workspaceName, boolean indexAttachments) 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(collectionId))
            {
                SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
                AmetysObjectCollection collection = _resolver.resolveById(collectionId);
                AmetysObjectIterable<AmetysObject> children = collection.getChildren();
                
                for (AmetysObject child : children)
                {
                    if (child instanceof Content)
                    {
                        Content content = (Content) child;
                        
                        _doIndexContent(content, workspaceName, indexAttachments, solrClient);
                    }
                }
            }
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * 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 = _workspaceSelector.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
    {
        IndexationResult result = new IndexationResult();
        
        String[] workspaceNames = _workspaceSelector.getWorkspaces();
        for (String workspaceName : workspaceNames)
        {
            SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
            IndexationResult wResult = indexContents(contents, workspaceName, true, solrClient);
            result = new IndexationResult(result.getSuccessCount() + wResult.getSuccessCount(), result.getErrorCount() + wResult.getErrorCount());
        }
        
        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
    {
        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);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} contents indexed without error in {} milliseconds.", result.getSuccessCount(), 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.getErrorCount());
            }
            
            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
     * @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) throws Exception
    {
        int successCount = 0;
        int errorCount = 0;
        for (Content content : contents)
        {
            try
            {
                doIndexContent(content, workspaceName, solrClient);
                doIndexContentWorkflow(content, workspaceName, solrClient);
                if (indexAttachments)
                {
                    indexContentAttachments(content.getRootAttachments(), content, solrClient);
                }
                successCount++;
            }
            catch (Exception e)
            {
                getLogger().error("Error indexing content '" + content.getId() + "' in the solr server.", e);
                errorCount++;
            }
        }
        
        return new IndexationResult(successCount, errorCount);
    }
    
    /**
     * Update the value of a specific system 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 updateSystemProperty(Content content, String propertyId, String workspaceName) throws Exception
    {
        SolrClient solrClient = _getAutoCommitSolrClient(workspaceName);
        updateSystemProperty(content, propertyId, workspaceName, solrClient);
    }
    
    /**
     * Update the value of a specific system 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 updateSystemProperty(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 = _solrContentIndexer.indexPartialSystemProperty(content, propertyId, document);
        
        if (!hasUpdate)
        {
            getLogger().debug("Did not index '{}' property for content {} in Solr because no update to apply.", propertyId, content);
            return;
        }
        
        String collection = _solrClientProvider.getCollectionName(workspaceName);
        UpdateResponse solrResponse = solrClient.add(collection, document);
        int status = solrResponse.getStatus();
        
        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);
    }
    
    /**
     * 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 = _workspaceSelector.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);
            
            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 = _workspaceSelector.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);
            }
            
            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 = new ArrayList<>();
        
        _solrContentIndexer.indexContent(content, document, additionalDocuments);

        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;
        }
        
        for (AmetysObject object : collection.getChildren())
        {
            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
        _indexContentAttachment(resource, document, content);
        
        // Indexation of the document
        _indexResourceDocument(resource, document, solrClient);
    }
    
    private void _indexContentAttachment(Resource resource, SolrInputDocument document, Content content) throws Exception
    {
        String language = content.getLanguage();
        
        _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());
    }
    
    /**
     * Index a populated solr input document of type Resource.
     * @param resource the resource from which the input document is created
     * @param document the input document
     * @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, SolrInputDocument document, 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, document);
        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
     * @return The indexation result as a Map.
     * @throws Exception if an error occurs while indexing.
     */
    public Map<String, Object> indexAllResources(String workspaceName, 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().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);
                
                long end = System.currentTimeMillis();
                
                if (!result.hasErrors())
                {
                    getLogger().info("{} resources indexed without error in {} milliseconds.", result.getSuccessCount(), 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.getErrorCount());
                }
                
                results.put("successCount", result.getSuccessCount());
                if (result.hasErrors())
                {
                    results.put("errorCount", result.getErrorCount());
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().info("There is no root for resources in current workspace.");
            }
            
            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
    {
        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);
            
            long end = System.currentTimeMillis();
            
            if (!result.hasErrors())
            {
                getLogger().info("{} resources indexed without error in {} milliseconds.", result.getSuccessCount(), 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.getErrorCount());
            }
            
            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
     * @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) throws Exception
    {
        int successCount = 0;
        int errorCount = 0;
        for (AmetysObject resource : resources)
        {
            try
            {
                doIndexExplorerItem(resource, documentType, resourceRoot, solrClient);
                successCount++;
            }
            catch (Exception e)
            {
                getLogger().error("Error indexing resource '" + resource.getId() + "' in the solr server.", e);
                errorCount++;
            }
        }
        
        return new IndexationResult(successCount, errorCount);
    }
    
    /**
     * 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
    {
        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("Indexing resource {} into Solr.", resource.getId());
            
            doIndexResource(resource, documentType, null, solrClient);
            
            getLogger().debug("Succesfully indexed resource {} in Solr.", resource.getId());
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index resource %s in workspace %s", resource.getId(), workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    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 = _workspaceSelector.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());
            
            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 = _workspaceSelector.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);
            
            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);
        }
    }
    
    /**
     * Add or update a resource into Solr index
     * @param node The resource 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 solrClient The solr client to use
     * @throws Exception if an error occurs while indexing.
     */
    protected void doIndexExplorerItem(AmetysObject node, String documentType, TraversableAmetysObject resourceRoot, SolrClient solrClient) throws Exception
    {
        if (node instanceof ResourceCollection)
        {
            for (AmetysObject child : ((ResourceCollection) node).getChildren())
            {
                doIndexExplorerItem(child, documentType, resourceRoot, solrClient);
            }
        }
        else if (node instanceof Resource)
        {
            doIndexResource((Resource) node, documentType, resourceRoot, solrClient);
        }
    }
    
    /**
     * Add or update a resource into Solr index
     * @param resource The resource 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 solrClient The solr client to use 
     * @throws Exception if an error occurs while indexing.
     */
    protected void doIndexResource(Resource resource, String documentType, TraversableAmetysObject resourceRoot, SolrClient solrClient) throws Exception
    {
        SolrInputDocument document = new SolrInputDocument();
        
        _solrResourceIndexer.indexResource(resource, document, documentType, resourceRoot);
        
        String workspaceName = _workspaceSelector.getWorkspace();
        UpdateResponse solrResponse = solrClient.add(_solrClientProvider.getCollectionName(workspaceName), document);
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Resource indexation: got status code '" + status + "'.");
        }
    }
    
    /**
     * 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 = _workspaceSelector.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 + "'.");
        }
    }
    
//    /**
//     * Get the collection to use.
//     * @return The name of the collection to index into.
//     */
//    protected String getCollection()
//    {
//        return _solrCorePrefix + _workspaceSelector.getWorkspace();
//    }
    
    class IndexationResult
    {
        protected int _successCount;
        
        protected int _errorCount;
        
        /**
         * Constructor
         */
        public IndexationResult()
        {
            this(0, 0);
        }
        
        /**
         * Constructor
         * @param successCount The success count.
         * @param errorCount The error count.
         */
        public IndexationResult(int successCount, int errorCount)
        {
            this._successCount = successCount;
            this._errorCount = errorCount;
        }
        
        /**
         * Get the successCount.
         * @return the successCount
         */
        public int getSuccessCount()
        {
            return _successCount;
        }
        
        /**
         * Set the successCount.
         * @param successCount the successCount to set
         */
        public void setSuccessCount(int successCount)
        {
            this._successCount = successCount;
        }
        
        /**
         * Test if the indexation had errors.
         * @return true if the indexation had errors, false otherwise.
         */
        public boolean hasErrors()
        {
            return _errorCount > 0;
        }
        
        /**
         * Get the errorCount.
         * @return the errorCount
         */
        public int getErrorCount()
        {
            return _errorCount;
        }
        
        /**
         * Set the errorCount.
         * @param errorCount the errorCount to set
         */
        public void setErrorCount(int errorCount)
        {
            this._errorCount = errorCount;
        }
    }
    
}