/*
 *  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.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

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.ArrayUtils;
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.contenttype.ContentConstants;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.contenttype.indexing.IndexingField;
import org.ametys.cms.contenttype.indexing.IndexingModel;
import org.ametys.cms.contenttype.indexing.MetadataIndexingField;
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.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.search.solr.field.FirstValidationSearchField;
import org.ametys.cms.search.solr.field.LastMajorValidationSearchField;
import org.ametys.cms.search.solr.field.LastModifiedSearchField;
import org.ametys.cms.search.solr.field.LastValidationSearchField;
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.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.WebConstants;
import org.ametys.web.indexing.solr.page.attachment.PageVisibleAttachmentIndexerExtensionPoint;
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.PageAttachmentQuery;
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 extension point for PageVisibleAttachmentIndexers */
    protected PageVisibleAttachmentIndexerExtensionPoint _pageVisibleAttachmentIndexerEP;
    /** 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;

    private ContentTypesHelper _cTypesHelper;
    
    @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);
        _pageVisibleAttachmentIndexerEP = (PageVisibleAttachmentIndexerExtensionPoint) manager.lookup(PageVisibleAttachmentIndexerExtensionPoint.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);
        _cTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.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);
        indexPage(pageId, WebConstants.LIVE_WORKSPACE, indexRecursively, indexAttachments);
    }
    
    /**
     * 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
     * @throws IndexingException if an error occurs during indexation.
     */
    public void indexPage(String pageId, String workspaceName, boolean indexRecursively, boolean indexAttachments) throws IndexingException
    {
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName, true);
        indexPage(pageId, workspaceName, indexRecursively, indexAttachments, solrClient);
    }
    
    /**
     * 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 solrClient The solr client to use
     * @throws IndexingException if an error occurs during indexation.
     */
    public void indexPage(String pageId, String workspaceName, boolean indexRecursively, boolean indexAttachments, SolrClient solrClient) throws IndexingException
    {
        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, solrClient);
            }
        }
        catch (AmetysRepositoryException 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, SolrClient solrClient) throws IndexingException
    {
        getLogger().info("Indexing page: {} in workspace '{}'", page, workspaceName);
        
        SolrInputDocument document = new SolrInputDocument();
        
        try
        {
            // Prepare the solr input document by adding fields.
            _populatePageDocument(page, document);
            
            // Set the additional properties in the document.
            _populateAdditionalProperties(page, document);
            
            // Indexation of ACL initial values
            _solrIndexer.indexAclInitValues(page, document);
            
            // Indexation of the document
            _indexPageDocument(page, document, workspaceName, solrClient);
            
            // Index page attachments documents
            if (indexAttachments)
            {
                _indexPageAttachments(page.getRootAttachments(), page, solrClient);
            }
        }
        catch (Exception e)
        {
            String error = String.format("Failed to index page %s in workspace %s", page.getId(), workspaceName);
            getLogger().error(error, e);
            throw new IndexingException(error, e);
        }
        
        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, solrClient);
            }
        }
    }
    
    /**
     * 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 pageId = page.getId();
        String pageTitle = page.getTitle();
        String pageLongTitle = page.getLongTitle();
        String language = sitemapName;
        
        // Page id and type
        document.addField(SolrFieldNames.ID, pageId);
        document.addField(SolrFieldNames.DOCUMENT_TYPE, SolrWebFieldNames.TYPE_PAGE);
        
        // Fulltext
        SolrContentIndexer.indexFulltextValue(document, pageTitle, language);
        if (!pageTitle.equals(pageLongTitle))
        {
            SolrContentIndexer.indexFulltextValue(document, pageLongTitle, language);
        }
        
        // Page title
        _indexStringFields(document, pageId, PAGE_TITLE, pageTitle, language);
        // Page long title
        _indexStringFields(document, pageId, PAGE_LONG_TITLE, pageLongTitle, language);
        // Title for sorting
        document.addField(TITLE_SORT, pageTitle);
        
        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);
        
        // Parent of the page
        AmetysObject parent = page.getParent();
        if (parent != null)
        {
            document.addField(PAGE_PARENT_ID, parent.getId());
        }

        // Ancestors of the page
        List<String> ancestorIds = new ArrayList<>();
        while (parent instanceof Page)
        {
            ancestorIds.add(parent.getId());
            parent = parent.getParent();
        }
        document.addField(PAGE_ANCESTOR_IDS, ancestorIds);
        
        document.addField(SITE_NAME, siteName);
        document.addField(SITEMAP_NAME, sitemapName);
        document.addField(SITE_TYPE, site.getType());
        
        // Page tags (strict and tags including ancestor pages).
        document.addField(SolrFieldNames.TAGS, page.getTags());
        document.addField(SolrFieldNames.ALL_TAGS, _getTagsWithAncestors(page));
        
        _populateDatesOfPage(page, document);
        
        // Attachments
        _solrResourceIndexer.indexResourceCollection(page.getRootAttachments(), document, language);
        Optional.ofNullable(page.getRootAttachments())
                .map(AmetysObject::getId)
                .ifPresent(id -> document.addField(PAGE_OUTGOING_REFEERENCES_RESOURCE_IDS, id));
        _indexVisibleAttachments(page, document);
    }
    
    private void _indexVisibleAttachments(Page page, SolrInputDocument document)
    {
        Collection<String> values = _pageVisibleAttachmentIndexerEP.getExtensionsIds()
                .stream()
                .map(_pageVisibleAttachmentIndexerEP::getExtension)
                .map(attachmentIndexer -> attachmentIndexer.getVisibleAttachmentIds(page))
                .flatMap(Collection::stream)
                .collect(Collectors.toList());
        document.addField(PAGE_VISIBLE_ATTACHMENT_RESOURCE_IDS, values);
    }
    
    /**
     * Populate the solr input document with dates from the page
     * @param page The page
     * @param document The Solr document
     */
    protected void _populateDatesOfPage(Page page, SolrInputDocument document)
    {
        // Page last modification date
        Date lastModified = _getLastModificationDate(page);
        if (lastModified != null)
        {
            String lastModifiedStr = SolrIndexer.dateFormat().format(lastModified);
            // For 'new' search service
            document.addField(LastModifiedSearchField.NAME, lastModifiedStr);
            // For 'old' search service
            document.addField(LAST_MODIFIED + "_dt", lastModifiedStr);
        }
        
        // Page last validation date
        Date lastValidation = _getLastValidationDate(page);
        if (lastValidation != null)
        {
            String lastValidationStr = SolrIndexer.dateFormat().format(lastValidation);
            // For 'new' search service
            document.addField(LastValidationSearchField.NAME, lastValidationStr);
            if (!LAST_VALIDATION.equals(LastValidationSearchField.NAME))
            {
                // For 'old' search service
                document.addField(LAST_VALIDATION, lastValidationStr);
            }
        }
        
        // Page first validation date
        Date firstValidation = _getFirstValidationDate(page);
        if (firstValidation != null)
        {
            String firstValidationStr = SolrIndexer.dateFormat().format(firstValidation);
            // For 'new' search service
            document.addField(FirstValidationSearchField.NAME, firstValidationStr);
        }
        
        // Page last major validation date
        Date lastMajorValidation = _getLastMajorValidationDate(page);
        if (lastMajorValidation != null)
        {
            String lastMajorValidationStr = SolrIndexer.dateFormat().format(lastMajorValidation);
            // For 'new' search service
            document.addField(LastMajorValidationSearchField.NAME, lastMajorValidationStr);
        }
        
        // 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());
            }
        }
    }
    
    private void _indexStringFields(SolrInputDocument document, String documentId, String fieldName, String fieldValue, String language)
    {
        String possiblyTruncatedValue = SolrIndexer.truncateUtf8StringValue(fieldValue, getLogger(), documentId, fieldName);
        
        document.addField(fieldName, possiblyTruncatedValue);
        document.addField(fieldName + "_txt_" + language, fieldValue);
        document.addField(fieldName + "_txt_stemmed_" + language, fieldValue);
        document.addField(fieldName + "_txt_ws_" + language, fieldValue);

        document.addField(fieldName + "_s_lower", possiblyTruncatedValue.toLowerCase());
        document.addField(fieldName + "_s_ws", fieldValue.toLowerCase());
        document.addField(fieldName + "_txt", fieldValue);
    }
    /**
     * 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)
                    {
                        try
                        {
                            Content content = zoneItem.getContent();
                            document.addField(CONTENT_IDS, content.getId());
                            
                            for (String cType : content.getTypes())
                            {
                                document.addField(PAGE_CONTENT_TYPES, cType);
                                document.addField(PAGE_CONTENT_TYPES + "_s_dv", cType); // facets
                            }
                            
                            _indexFacetableField(content, document);
                        }
                        catch (AmetysRepositoryException e)
                        {
                            getLogger().error("Failed to index content referenced in the page {}/{}/{} ({} in zoneitem {})", page.getSiteName(), page.getSitemapName(), page.getPathInSitemap(), page.getId(), zoneItem.getId(), e);
                        }
                    }
                    else if (zoneItem.getType() == ZoneType.SERVICE)
                    {
                        try
                        {
                            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);
                            }
                        }
                        catch (AmetysRepositoryException e)
                        {
                            getLogger().error("Failed to index service referenced in the page {}/{}/{} ({} in zoneitem {})", page.getSiteName(), page.getSitemapName(), page.getPathInSitemap(), page.getId(), zoneItem.getId(), e);
                        }
                        
                    }
                }
            }
        }
    }
    
    /**
     * Index the facetable fields of a content into the page solr document
     * @param content The content
     * @param document The main page solr document.
     */
    protected void _indexFacetableField(Content content, SolrInputDocument document)
    {
        IndexingModel indexingModel = null;
        try
        {
            indexingModel = _cTypesHelper.getIndexingModel(content);
        }
        catch (RuntimeException e)
        {
            getLogger().error("indexContent > Error getting the indexing model of content " + content.getId(), e);
            throw e;
        }
        
        for (IndexingField field : indexingModel.getFields())
        {
            if (field instanceof MetadataIndexingField)
            {
                String metadataPath = ((MetadataIndexingField) field).getMetadataPath();
                String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
                
                MetadataDefinition definition = _cTypesHelper.getMetadataDefinition(pathSegments[0], content.getTypes(), content.getMixinTypes());
                if (definition != null)
                {
                    _findAndIndexFacetableField(pathSegments, content.getLanguage(), content.getMetadataHolder(), definition, field, document);
                }
            }
        }
    }
    
    /**
     * Index the facetable fields of a content into the page solr document
     * @param pathSegments The path of metadata
     * @param lang The language
     * @param metadata The parent composite metadata
     * @param definition The metadata definition
     * @param field The indexing field
     * @param pageDocument The Solr page document
     */
    protected void _findAndIndexFacetableField(String[] pathSegments, String lang, CompositeMetadata metadata, MetadataDefinition definition, IndexingField field, SolrInputDocument pageDocument)
    {
        String currentFieldName = pathSegments[0];
        
        if (!metadata.hasMetadata(currentFieldName))
        {
            // Nothing to do
            return;
        }
        
        switch (definition.getType())
        {
            case STRING:
                if (definition.getEnumerator() != null)
                {
                    String[] strValues = metadata.getStringArray(currentFieldName, new String[0]);
                    for (String value : strValues)
                    {
                        pageDocument.addField(FACETABLE_CONTENT_FIELD_PREFIX + currentFieldName + "_s_dv", value);
                    }
                }
                break;
            case CONTENT:
                String[] contentIds = metadata.getStringArray(currentFieldName, new String[0]);
                for (String contentId : contentIds)
                {
                    pageDocument.addField(FACETABLE_CONTENT_FIELD_PREFIX + currentFieldName + "_s_dv", contentId);
                }
                break;
            case COMPOSITE:
                if (pathSegments.length > 1)
                {
                    String[] followingSegments = ArrayUtils.subarray(pathSegments, 1, pathSegments.length);
                    
                    CompositeMetadata composite = metadata.getCompositeMetadata(currentFieldName);
                    if (definition instanceof RepeaterDefinition)
                    {
                        String[] entries = composite.getMetadataNames();
                        for (String entry : entries)
                        {
                            _findAndIndexFacetableField(followingSegments, lang, composite.getCompositeMetadata(entry), definition.getMetadataDefinition(followingSegments[0]), field, pageDocument);
                        }
                    }
                    else
                    {
                        _findAndIndexFacetableField(followingSegments, lang, composite, definition.getMetadataDefinition(followingSegments[0]), field, pageDocument);
                    }
                }
                
                break;
            default:
                break;
            
        }
    }

    /**
     * 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)
    {
        return _getLastDate(page, Content::getLastModified);
    }
    /**
     * Computes the first validation date of a page.
     * @param page the page.
     * @return the first validation date or <code>null</code>.
     */
    protected Date _getFirstValidationDate(Page page)
    {
        return _getFirstDate(page, Content::getFirstValidationDate);
    }

    /**
     * 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)
    {
        return _getLastDate(page, Content::getLastValidationDate);
    }
    
    /**
     * Computes the last major validation date of a page.
     * @param page the page.
     * @return the last major validation date or <code>null</code>.
     */
    protected Date _getLastMajorValidationDate(Page page)
    {
        return _getLastDate(page, Content::getLastMajorValidationDate);
    }
    
    /**
     * Computes a "last date" of a page, using the simple and naive following algorithm:
     * <br>From all the dates from each of its contents, keep the greatest of them.
     * @param page the page.
     * @param dateRetriever The function to retrieve a Date from a Content of the Page
     * @return the "last date" or <code>null</code>.
     */
    protected Date _getLastDate(Page page, Function<Content, Date> dateRetriever)
    {
        Date last = 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 date
                            break;
                        case CONTENT:
                            try
                            {
                                Date contentLast = dateRetriever.apply(zoneItem.getContent());

                                if (contentLast != null && (last == null || contentLast.after(last)))
                                {
                                    // Keep the latest date
                                    last = contentLast;
                                }
                            }
                            catch (AmetysRepositoryException e)
                            {
                                getLogger().error("Failed to index last date for content in page {}/{}/{} ({} in zoneitem {})", page.getSiteName(), page.getSitemapName(), page.getPathInSitemap(), page.getId(), zoneItem.getId(), e);
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        
        return last;
    }
    
    /**
     * Computes a "first date" of a page, using the simple and naive following algorithm:
     * <br>From all the dates from each of its contents, keep the lowest of them.
     * @param page the page.
     * @param dateRetriever The function to retrieve a Date from a Content of the Page
     * @return the "first date" or <code>null</code>.
     */
    protected Date _getFirstDate(Page page, Function<Content, Date> dateRetriever)
    {
        Date first = 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 first date
                            break;
                        case CONTENT:
                            try
                            {
                                Date contentFirst = dateRetriever.apply(zoneItem.getContent());
                                
                                if (contentFirst != null && (first == null || contentFirst.before(first)))
                                {
                                    // Keep the lowest date
                                    first = contentFirst;
                                }
                            }
                            catch (AmetysRepositoryException e)
                            {
                                getLogger().error("Failed to index first date for content in page {}/{}/{} ({} in zoneitem {})", page.getSiteName(), page.getSitemapName(), page.getPathInSitemap(), page.getId(), zoneItem.getId(), e);
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        
        return first;
    }
    
    /**
     * 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
    {
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
        _indexPageAttachments(collection, page, solrClient);
    }
    
    private void _indexPageAttachments(ResourceCollection collection, Page page, SolrClient solrClient) throws Exception
    {
        if (collection == null)
        {
            return;
        }
        
        for (AmetysObject object : collection.getChildren())
        {
            if (object instanceof ResourceCollection)
            {
                _indexPageAttachments((ResourceCollection) object, page, solrClient);
            }
            else if (object instanceof Resource)
            {
                Resource resource = (Resource) object;
                _indexPageAttachment(resource, page, solrClient);
            }
        }
    }
    
    /**
     * 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
    {
        Request request = ContextHelper.getRequest(_context);
        String workspaceName = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
        _indexPageAttachment(resource, page, solrClient);
    }
    
    private void _indexPageAttachment(Resource resource, Page page, SolrClient solrClient) throws Exception
    {
        SolrInputDocument document = new SolrInputDocument();
        
        // Prepare resource doc
        _populatePageAttachmentDocument(resource, document, page);
        
        // Indexation of the document
        _indexResourceDocument(resource, document, solrClient);
    }
    
    private void _populatePageAttachmentDocument(Resource resource, SolrInputDocument document, Page page) throws Exception
    {
        String language = page.getSitemapName();
        
        _solrResourceIndexer.indexResource(resource, document, TYPE_PAGE_RESOURCE, language);
        
        Site site = page.getSite();
        // site name - Store.YES, Index.NOT_ANALYZED
        document.addField(SolrWebFieldNames.SITE_NAME, site.getName());
        
        // site type - Store.YES, Index.NOT_ANALYZED
        document.addField(SolrWebFieldNames.SITE_TYPE, site.getType());
        
        // 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(ATTACHMENT_PAGE_ID, 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
     * @param solrClient The solr client to use
     * @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, SolrClient solrClient) throws SolrServerException, IOException
    {
        // Retrieve appropriate solr client
        String collectionName = _solrClientProvider.getCollectionName(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
     * @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
    {
        // Retrieve appropriate solr client
        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 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());
    }
    
    ///////////////////////////////////////////////////////////////////////////
    
    /**
     * 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);
        unindexPage(pageId, WebConstants.LIVE_WORKSPACE, unindexRecursively, unindexAttachments);
    }
    
    /**
     * 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
     * @throws Exception if an error occurs during index update.
     */
    public void unindexPage(String pageId, String workspaceName, boolean unindexRecursively, boolean unindexAttachments) 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);
        }
        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=page-ancestorIds:"page://xxxx"}
            Query joinQuery = new JoinQuery(() -> PAGE_ANCESTOR_IDS + ":\"" + pageId + "\"", ATTACHMENT_PAGE_ID);
            Query attachments = new AndQuery(new DocumentTypeQuery(TYPE_PAGE_RESOURCE), new OrQuery(new PageAttachmentQuery(pageId), joinQuery));
            query = new OrQuery(attachments, pages);
        }
        else if (unindexAttachments)
        {
            Query attachments = new AndQuery(new DocumentTypeQuery(TYPE_PAGE_RESOURCE), new PageAttachmentQuery(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);
        reindexPage(pageId, WebConstants.LIVE_WORKSPACE, reindexRecursively, reindexAttachments);
    }
  
    
    /**
     * 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
     * @throws IndexingException if an error occurs during index update.
     */
    public void reindexPage(String pageId, String workspaceName, boolean reindexRecursively, boolean reindexAttachments) throws IndexingException
    {
        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);
                SolrClient solrClient = _solrClientProvider.getUpdateClient(workspaceName);
                _indexPage(page, workspaceName, reindexRecursively, reindexAttachments, solrClient);
            }
        }
        catch (AmetysRepositoryException | QuerySyntaxException | SolrServerException | IOException 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);
        }
    }
}