/*
 *  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.web.indexing.solr;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

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.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.SolrInputField;

import org.ametys.cms.content.indexing.solr.SolrContentIndexer;
import org.ametys.cms.content.indexing.solr.SolrFieldNames;
import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.content.indexing.solr.SolrResourceIndexer;
import org.ametys.cms.indexing.IndexingException;
import org.ametys.cms.indexing.solr.AdditionalPropertyIndexer;
import org.ametys.cms.indexing.solr.AdditionalPropertyIndexerExtensionPoint;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.RequestAttributeWorkspaceSelector;
import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.DocumentTypeQuery;
import org.ametys.cms.search.query.JoinQuery;
import org.ametys.cms.search.query.OrQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.QuerySyntaxException;
import org.ametys.cms.search.solr.SolrClientProvider;
import org.ametys.cms.tag.Tag;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.WebConstants;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.page.ZoneItem.ZoneType;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.search.query.AttachmentQuery;
import org.ametys.web.search.query.PageQuery;
import org.ametys.web.service.Service;
import org.ametys.web.service.ServiceExtensionPoint;

/**
 * Component responsible for indexing a page with all its contents.
 */
public class SolrPageIndexer extends AbstractLogEnabled implements Component, Serviceable, SolrWebFieldNames, Contextualizable
{
    /** The avalon role. */
    public static final String ROLE = SolrPageIndexer.class.getName();
    
    /** The Solr client provider */
    protected SolrClientProvider _solrClientProvider;
    /** The Solr indexer */
    protected SolrIndexer _solrIndexer;
    /** Solr Ametys contents indexer */
    protected SolrContentIndexer _solrContentIndexer;
    /** Solr Ametys resources indexer */
    protected SolrResourceIndexer _solrResourceIndexer;
    /** The Solr page right indexer. */
    protected SolrPageRightIndexer _solrPageRightIndexer;
    /** The additional property indexer extension point. */
    protected AdditionalPropertyIndexerExtensionPoint _additionalPropertiesIndexerEP;
    /** The tag provider extension point. */
    protected TagProviderExtensionPoint _tagProviderEP;
    
    /** The service extension point. */
    protected ServiceExtensionPoint _serviceExtensionPoint;
    /** The Ametys object resolver*/
    protected AmetysObjectResolver _ametysObjectResolver;
    /** The avalon context */
    protected Context _context;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _solrIndexer = (SolrIndexer) manager.lookup(SolrIndexer.ROLE);
        _solrContentIndexer = (SolrContentIndexer) manager.lookup(SolrContentIndexer.ROLE);
        _solrResourceIndexer = (SolrResourceIndexer) manager.lookup(SolrResourceIndexer.ROLE);
        _solrPageRightIndexer = (SolrPageRightIndexer) manager.lookup(SolrPageRightIndexer.ROLE);
        _solrClientProvider = (SolrClientProvider) manager.lookup(SolrClientProvider.ROLE);
        _serviceExtensionPoint = (ServiceExtensionPoint) manager.lookup(ServiceExtensionPoint.ROLE);
        _additionalPropertiesIndexerEP = (AdditionalPropertyIndexerExtensionPoint) manager.lookup(AdditionalPropertyIndexerExtensionPoint.ROLE);
        _tagProviderEP = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Index a page and eventually its children, recursively, in all workspaces and commit<br>
     * By default, children pages will be actually indexed if indexRecursively is true and if those pages are not already indexed.
     * @param pageId the page to be indexed.
     * @param indexRecursively to also process children pages.
     * @param indexAttachments to index page attachments
     * @throws Exception if an error occurs during indexation.
     */
    public void indexPage(String pageId, boolean indexRecursively, boolean indexAttachments) throws Exception
    {
        indexPage(pageId, RepositoryConstants.DEFAULT_WORKSPACE, indexRecursively, indexAttachments, true);
        indexPage(pageId, WebConstants.LIVE_WORKSPACE, indexRecursively, indexAttachments, true);
    }
    
    /**
     * Index a page and eventually its children, recursively.<br>
     * By default, children pages will be actually indexed if indexRecursively is true and if those pages are not already indexed.
     * @param pageId the page to be indexed.
     * @param workspaceName the workspace where to index
     * @param indexRecursively to also process children pages.
     * @param indexAttachments to index page attachments
     * @param commit Commit the indexation
     * @throws Exception if an error occurs during indexation.
     */
    public void indexPage(String pageId, String workspaceName, boolean indexRecursively, boolean indexAttachments, boolean commit) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        // Retrieve the current site name.
        String currentSiteName = (String) request.getAttribute("siteName");
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
    
            getLogger().debug("Indexing page: {}", pageId);
            
            if (_ametysObjectResolver.hasAmetysObjectForId(pageId)) // In 'live' the page may not exist
            {
                Page page = _ametysObjectResolver.resolveById(pageId);
                _indexPage(page, workspaceName, indexRecursively, indexAttachments);
                
                if (commit)
                {
                    _solrIndexer.commit(workspaceName);
                }
            }
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index page %s in workspace %s", pageId, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore the site name.
            request.setAttribute("siteName", currentSiteName);
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    private void _indexPage(Page page, String workspaceName, boolean indexRecursively, boolean indexAttachments) throws Exception
    {
        getLogger().info("Indexing page: {} in workspace '{}'", page, workspaceName);
        
        SolrInputDocument document = new SolrInputDocument();
        
        // Prepare the solr input document by adding fields.
        _populatePageDocument(page, document);
        
        // Set the additional properties in the document.
        _populateAdditionalProperties(page, document);
        
        // Indexation of the page access.
        _indexPageAccess(page, document);
        
        // Indexation of the document
        _indexPageDocument(page, document, workspaceName);
        
        // Index page attachments documents
        if (indexAttachments)
        {
            indexPageAttachments(page.getRootAttachments(), page);
        }
        
        if (indexRecursively)
        {
            for (Page child : page.getChildrenPages())
            {
                // FIXME index child pages if (and only if) not indexed... see original source.
//                indexPage(child, false, indexRecursively);
//                indexPage(child, false);
                _indexPage(child, workspaceName, indexRecursively, indexAttachments);
            }
        }
    }
    
    /**
     * Populate the solr input document by adding fields to index.
     * @param page the page to index.
     * @param document the solr input document
     * @throws Exception if something goes wrong when processing the indexation of the page
     */
    protected void _populatePageDocument(Page page, SolrInputDocument document) throws Exception
    {
        Sitemap sitemap = page.getSitemap();
        String sitemapName = sitemap.getName();
        Site site = page.getSite();
        String siteName = site.getName();
        String pageTitle = page.getTitle();
        String language = sitemapName;
        
        // Page id and type
        document.addField(SolrFieldNames.ID, page.getId());
        document.addField(SolrFieldNames.DOCUMENT_TYPE, SolrWebFieldNames.TYPE_PAGE);
        
        // Fulltext
        SolrContentIndexer.indexFulltextValue(document, page.getTitle(), language);
        if (!page.getTitle().equals(page.getLongTitle()))
        {
            SolrContentIndexer.indexFulltextValue(document, page.getLongTitle(), language);
        }
        
        // Page title
        document.addField(TITLE, pageTitle);
        document.addField(LONG_TITLE, page.getLongTitle());
        
        document.addField(TEMPLATE, page.getTemplate());
        document.addField(PAGE_TYPE, page.getType().name());
        document.addField(PAGE_DEPTH, page.getDepth());
        
        // Contents (page title shoud be indexed before because the main content can override it).
        _populatePageContentsDocument(page, document);

        // Parents of the page
        List<String> ancestorIds = new ArrayList<>();
        AmetysObject parent = page.getParent();
        while (parent instanceof Page)
        {
            ancestorIds.add(parent.getId());
            parent = parent.getParent();
        }
        document.addField(ANCESTOR_IDS, ancestorIds);
        
        document.addField(SITE_NAME, siteName);
        document.addField(SITEMAP_NAME, sitemapName);
        
        // Page tags (strict and tags including ancestor pages).
        document.addField(SolrFieldNames.TAGS, page.getTags());
        document.addField(SolrFieldNames.ALL_TAGS, _getTagsWithAncestors(page));
        
        // Page last modification date - Store.YES, Index.ANALYZED
        Date lastModified = _getLastModificationDate(page);
        if (lastModified != null)
        {
            document.addField(LAST_MODIFIED + "_dt", SolrIndexer.dateFormat().format(lastModified));
        }

        // Page last validation date - Store.YES, Index.ANALYZED
        Date lastValidation = _getLastValidationDate(page);
        if (lastValidation != null)
        {
            document.addField(LAST_VALIDATION, SolrIndexer.dateFormat().format(lastValidation));
        }
        
        // date for sorting
        SolrInputField dateField = document.getField(DATE_FOR_SORTING);
        if (dateField == null)
        {
            Collection<Object> oDateValues = document.getFieldValues(CONTENT_INTERESTING_DATES);
            if (oDateValues != null && !oDateValues.isEmpty())
            {
                document.setField(DATE_FOR_SORTING, oDateValues.iterator().next());
            }
        }
        
        // Attachments
        _solrResourceIndexer.indexResourceCollection(page.getRootAttachments(), document, language);
    }
    
    /**
     * Get all the page tags with their ancestors.
     * @param page The page.
     * @return All the page tags with their ancestors.
     */
    protected Set<String> _getTagsWithAncestors(Page page)
    {
        Set<String> allTags = new HashSet<>(page.getTags());
        
        Map<String, Object> tagParams = Collections.singletonMap("siteName", page.getSiteName());
        
        for (String tagName : page.getTags())
        {
            allTags.add(tagName);
            
            // Get the ancestor tags
            Tag tag = _tagProviderEP.getTag(tagName, tagParams);
            for (Tag ancestor : TagHelper.getAncestors(tag, false))
            {
                allTags.add(ancestor.getName());
            }
        }
        
        return allTags;
    }
    
    /**
     * Index the content of the page.<p>
     * @param page the page to index.
     * @param document the document to populate.
     * @throws Exception if an error occurs.
     */
    protected void _populatePageContentsDocument(Page page, SolrInputDocument document) throws Exception
    {
        if (page.getType() == PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                for (ZoneItem zoneItem : zone.getZoneItems())
                {
                    if (zoneItem.getType() == ZoneType.CONTENT)
                    {
                        // Content
                        Content content = zoneItem.getContent();
                        document.addField(CONTENT_IDS, content.getId());
                    }
                    else if (zoneItem.getType() == ZoneType.SERVICE)
                    {
                        // service 
                        String serviceId = zoneItem.getServiceId();
                        document.addField(SERVICE_IDS, serviceId);

                        Service service = _serviceExtensionPoint.getExtension(serviceId);
                        if (service == null)
                        {
                            getLogger().error("The service id '{}' does not exist. It is referenced in the page {}/{}/{} ({} in zoneitem {})", serviceId, page.getSiteName(), page.getSitemapName(), page.getPathInSitemap(), page.getId(), zoneItem.getId());
                        }
                        else
                        {
                            service.index(zoneItem, document);
                        }
                    }
                }
            }
        }
    }

    /**
     * Computes the last modification date of a page.
     * @param page the page.
     * @return the last modification date or <code>null</code>.
     */
    protected Date _getLastModificationDate(Page page)
    {
        Date lastModified = null;

        if (page.getType() == PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                for (ZoneItem zoneItem : zone.getZoneItems())
                {
                    switch (zoneItem.getType())
                    {
                        case SERVICE:
                            // A service has no last modification date
                            break;
                        case CONTENT:
                            Date contentLastModified = zoneItem.getContent().getLastModified();

                            if (lastModified == null || contentLastModified.after(lastModified))
                            {
                                // Keep the latest modification date
                                lastModified = contentLastModified;
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        return lastModified;
    }

    /**
     * Computes the last validation date of a page.
     * @param page the page.
     * @return the last validation date or <code>null</code>.
     */
    protected Date _getLastValidationDate(Page page)
    {
        Date lastValidated = null;

        if (page.getType() == PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                for (ZoneItem zoneItem : zone.getZoneItems())
                {
                    switch (zoneItem.getType())
                    {
                        case SERVICE:
                            // A service has no last validation date
                            break;
                        case CONTENT:
                            Date contentLastValidation = zoneItem.getContent().getLastValidationDate();

                            if (contentLastValidation != null && (lastValidated == null || contentLastValidation.after(lastValidated)))
                            {
                                // Keep the latest modification date
                                lastValidated = contentLastValidation;
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        
        return lastValidated;
    }
    
    /**
     * Populate the solr input document by adding fields to index.
     * @param page the page to index.
     * @param document the solr input document
     * @throws Exception if something goes wrong when processing the indexation of the page
     */
    protected void _populateAdditionalProperties(Page page, SolrInputDocument document) throws Exception
    {
        Collection<AdditionalPropertyIndexer> indexers = _additionalPropertiesIndexerEP.getIndexers("page");
        for (AdditionalPropertyIndexer indexer : indexers)
        {
            indexer.index(page, document);
        }
    }
    
    /**
     * Index page attachments as new entries in the index.
     * @param collection the collection of attachments
     * @param page the page whose attachments will be indexed
     * @throws Exception if something goes wrong when indexing the attachments of the page
     */
    public void indexPageAttachments(ResourceCollection collection, Page page) throws Exception
    {
        if (collection == null)
        {
            return;
        }
        
        for (AmetysObject object : collection.getChildren())
        {
            if (object instanceof ResourceCollection)
            {
                indexPageAttachments((ResourceCollection) object, page);
            }
            else if (object instanceof Resource)
            {
                Resource resource = (Resource) object;
                indexPageAttachment(resource, page);
            }
        }
    }
    
    /**
     * Index a page attachment
     * @param resource the page attachment as a {@link Resource}
     * @param page the page whose attachment is going to be indexed
     * @throws Exception if something goes wrong when processing the indexation of the page attachment
     */
    public void indexPageAttachment(Resource resource, Page page) throws Exception
    {
        SolrInputDocument document = new SolrInputDocument();
        
        // Prepare resource doc
        _indexPageAttachment(resource, document, page);
        
        // Indexation of the document
        _indexResourceDocument(resource, document);
    }
    
    private void _indexPageAttachment(Resource resource, SolrInputDocument document, Page page) throws Exception
    {
        String language = page.getSitemapName();
        
        _solrResourceIndexer.indexResource(resource, document, TYPE_PAGE_RESOURCE, language);
        
        // site name - Store.YES, Index.NOT_ANALYZED
        document.addField(SITE_NAME, page.getSiteName());
        
        // Added for Solr.
        // Page site map name - Store.YES, Index.NOT_ANALYZED
        document.addField(SITEMAP_NAME, page.getSitemapName());
        
        // Need the id of the page for unindexing attachment during the unindexing of the page
        document.addField(PAGE_ID, page.getId());
        document.addField(PAGE_ID + "_s_dv", page.getId());
    }
    
    /**
     * Index a populated solr input document of type Page.
     * @param page the page from which the input document is created
     * @param document the input document to add to the solr index
     * @param workspaceName The workspace name
     * @throws SolrServerException if there is an error on the Solr server
     * @throws IOException if there is a communication error with the server
     */
    protected void _indexPageDocument(Page page, SolrInputDocument document, String workspaceName) throws SolrServerException, IOException
    {
        // Retrieve appropriate solr client
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
        
        // Add document
        UpdateResponse solrResponse = solrClient.add(collectionName, document);
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys Page indexing - Expecting status code of '0' in the Solr response but got : '" + status + "'. Page id : " + page.getId());
        }
        
        getLogger().debug("Successful page indexing. Page identifier : {}", page.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
     * @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) throws SolrServerException, IOException
    {
        // Retrieve appropriate solr client
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
        
        // Add document
        UpdateResponse solrResponse = solrClient.add(collectionName, document);
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys Page indexing - Expecting status code of '0' in the Solr response but got : '" + status + "'. Resource id : " + resource.getId());
        }
        
        getLogger().debug("Successful resource indexing. Resource identifier : {}", resource.getId());
    }
    
    /**
     * Index the page access.
     * @param page The page.
     * @param document The document.
     * @throws Exception If an error occurs while indexing.
     */
    protected void _indexPageAccess(Page page, SolrInputDocument document) throws Exception
    {
        _solrPageRightIndexer.indexPageAccess(page, document);
    }
    
    ///////////////////////////////////////////////////////////////////////////
    
    /**
     * Un-index a page by its ID  for all workspaces and commit
     * @param pageId The page ID.
     * @param unindexRecursively also unindex child pages if requested.
     * @param unindexAttachments also unindex page attachments
     * @throws Exception if an error occurs during index update.
     */
    public void unindexPage(String pageId, boolean unindexRecursively, boolean unindexAttachments) throws Exception
    {
        unindexPage(pageId, RepositoryConstants.DEFAULT_WORKSPACE, unindexRecursively, unindexAttachments, true);
        unindexPage(pageId, WebConstants.LIVE_WORKSPACE, unindexRecursively, unindexAttachments, true);
    }
    
    /**
     * De-index a page (and optionally its children pages).
     * @param pageId the page to be de-indexed.
     * @param workspaceName The workspace where to work in 
     * @param unindexRecursively also unindex child pages if requested.
     * @param unindexAttachments also unindex page attachments
     * @param commit Commit the operator to Solr
     * @throws Exception if an error occurs during index update.
     */
    public void unindexPage(String pageId, String workspaceName, boolean unindexRecursively, boolean unindexAttachments, boolean commit) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        // Retrieve the current site name.
        String currentSiteName = (String) request.getAttribute("siteName");
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
    
            getLogger().debug("Unindexing page: {}", pageId);
            
            _unindexPageDocument(pageId, workspaceName, unindexRecursively, unindexAttachments);
            
            if (commit)
            {
                _solrIndexer.commit(workspaceName);
            }
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex page %s in workspace %s", pageId, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore the site name.
            request.setAttribute("siteName", currentSiteName);
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
    
    /**
     * Deindex a document of type Page. Also deindex attachments of a page
     * @param pageId the id of the page to deindex
     * @param workspaceName The workspace name
     * @param unindexRecursively also unindex child pages if requested.
     * @param unindexAttachments also unindex page attachments
     * @throws SolrServerException if there is an error on the server
     * @throws IOException if there is a communication error with the server
     * @throws QuerySyntaxException if the uri query can't be built because of a syntax error.
     */
    protected void _unindexPageDocument(String pageId, String workspaceName, boolean unindexRecursively, boolean unindexAttachments) throws SolrServerException, IOException, QuerySyntaxException
    {
        // Retrieve appropriate solr client
        String collectionName = _solrClientProvider.getCollectionName(workspaceName);
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
        
        getLogger().info("Unindexing page {} in workspace '{}'", pageId, workspaceName);
        
        Query pages = new AndQuery(new DocumentTypeQuery(TYPE_PAGE), new PageQuery(pageId, unindexRecursively));
        Query query;
        if (unindexRecursively && unindexAttachments)
        {
            // {!ametys join=pageId q=ancestorIds:"page://xxxx"}
            Query joinQuery = new JoinQuery(() -> ANCESTOR_IDS + ":\"" + pageId + "\"", PAGE_ID);
            Query attachments = new AndQuery(new DocumentTypeQuery(TYPE_PAGE_RESOURCE), new OrQuery(new AttachmentQuery(pageId), joinQuery));
            query = new OrQuery(attachments, pages);
        }
        else if (unindexAttachments)
        {
            Query attachments = new AndQuery(new DocumentTypeQuery(TYPE_PAGE_RESOURCE), new AttachmentQuery(pageId));
            query = new OrQuery(attachments, pages);
        }
        else
        {
            query = pages;
        }
        
        // Delete by query
        UpdateResponse solrResponse = solrClient.deleteByQuery(collectionName, query.build());
        int status = solrResponse.getStatus();
        
        if (status != 0)
        {
            throw new IOException("Ametys Page de-indexing - Expecting status code of '0' in the Solr response but got : '" + status + "'. Page id : " + pageId);
        }
        
        getLogger().debug("Successful page de-indexing{}. Page identifier : {}", unindexRecursively ? " with its children" : "", pageId);
    }
    
    ///////////////////////////////////////////////////////////////////////////
    
    /**
     * Reindex a page by its ID for all workspaces and commit
     * @param pageId The page ID.
     * @param reindexRecursively also reindex child pages if requested.
     * @param reindexAttachments also reindex page attachments
     * @throws Exception if an error occurs during index update.
     */
    public void reindexPage(String pageId, boolean reindexRecursively, boolean reindexAttachments) throws Exception
    {
        reindexPage(pageId, RepositoryConstants.DEFAULT_WORKSPACE, reindexRecursively, reindexAttachments, true);
        reindexPage(pageId, WebConstants.LIVE_WORKSPACE, reindexRecursively, reindexAttachments, true);
    }
  
    
    /**
     * Reindex a page by its ID.
     * @param pageId The page ID.
     * @param workspaceName The workspace where to work in 
     * @param reindexRecursively also reindex child pages if requested.
     * @param reindexAttachments also reindex page attachments
     * @param commit Commit the operator to Solr
     * @throws Exception if an error occurs during index update.
     */
    public void reindexPage(String pageId, String workspaceName, boolean reindexRecursively, boolean reindexAttachments, boolean commit) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        // Retrieve the current site name.
        String currentSiteName = (String) request.getAttribute("siteName");
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
    
            getLogger().debug("Reindexing page: {}", pageId);
            
            if (_ametysObjectResolver.hasAmetysObjectForId(pageId)) // In 'live' the page may not exist
            {
                Page page = _ametysObjectResolver.resolveById(pageId);
                _unindexPageDocument(pageId, workspaceName, reindexRecursively, reindexAttachments);
                _indexPage(page, workspaceName, reindexRecursively, reindexAttachments);
                
                if (commit)
                {
                    _solrIndexer.commit(workspaceName);
                }
            }
        }
        catch (Exception e)
        {
            String error = String.format("Failed to unindex page %s in workspace %s", pageId, workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        finally
        {
            // Restore the site name.
            request.setAttribute("siteName", currentSiteName);
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
    }
}