/*
 *  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.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Future;
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.Constants;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.LocaleUtils;
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.SolrFieldNames;
import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.content.indexing.solr.SolrResourceIndexer;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.type.indexing.IndexableElementType;
import org.ametys.cms.data.type.indexing.IndexableElementTypeHelper;
import org.ametys.cms.indexing.IndexingException;
import org.ametys.cms.indexing.solr.AbstractIndexerCallable;
import org.ametys.cms.indexing.solr.AdditionalPropertyIndexer;
import org.ametys.cms.indexing.solr.AdditionalPropertyIndexerExtensionPoint;
import org.ametys.cms.indexing.solr.IndexationResult;
import org.ametys.cms.indexing.solr.ThreadIndexerHelper;
import org.ametys.cms.model.CMSDataContext;
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.systemprop.FirstValidationSystemProperty;
import org.ametys.cms.search.systemprop.LastMajorValidationSystemProperty;
import org.ametys.cms.search.systemprop.LastModifiedSystemProperty;
import org.ametys.cms.search.systemprop.LastValidationSystemProperty;
import org.ametys.cms.search.systemprop.TagsSystemProperty;
import org.ametys.cms.tag.Tag;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.util.DateUtils;
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.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.ModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeaterEntry;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.plugins.repository.model.RepositoryDataContext;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
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 service manager. */
    protected ServiceManager _manager;
    /** The Solr client provider */
    protected SolrClientProvider _solrClientProvider;
    /** The Solr indexer */
    protected SolrIndexer _solrIndexer;
    /** 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 content types helper */
    protected ContentTypesHelper _cTypesHelper;
    /** The thread indexer helper */
    protected ThreadIndexerHelper _threadIndexerHelper;
    
    /** The service extension point. */
    protected ServiceExtensionPoint _serviceExtensionPoint;
    /** The Ametys object resolver*/
    protected AmetysObjectResolver _ametysObjectResolver;
    /** The avalon context */
    protected Context _context;
    /** Cocoon Context */
    protected org.apache.cocoon.environment.Context _cocoonContext;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _solrIndexer = (SolrIndexer) manager.lookup(SolrIndexer.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);
        _threadIndexerHelper = (ThreadIndexerHelper) manager.lookup(ThreadIndexerHelper.ROLE);
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_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
    {
        // Add callable for each page to index
        List<Future<Void>> tasks = _asyncIndexPage(page, workspaceName, indexRecursively, indexAttachments, solrClient);
        
        // Now that everything is submitted, we can iterate and wait for result
        IndexationResult.fromTasks(tasks, getLogger());
    }
    
    private List<Future<Void>> _asyncIndexPage(Page page, String workspaceName, boolean indexRecursively, boolean indexAttachments, SolrClient solrClient) throws IndexingException
    {
        List<Future<Void>> tasks = new ArrayList<>();

        if (page.isIndexable())
        {
            _threadIndexerHelper.submitCallable(new PageIndexerCallable(page, workspaceName, indexAttachments, solrClient));
        }
        else
        {
            getLogger().debug("Not indexing page: {} in workspace '{}'", page, workspaceName);
        }
        
        if (indexRecursively)
        {
            AmetysObjectIterable<? extends Page> children = page.getChildrenPages();
            for (Page child : children)
            {
                // FIXME index child pages if (and only if) not indexed... see original source.
//                indexPage(child, false, indexRecursively);
//                indexPage(child, false);
                tasks.addAll(_asyncIndexPage(child, workspaceName, indexRecursively, indexAttachments, solrClient));
            }
        }
        
        return tasks;
    }
    
    /**
     * 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
        CMSDataContext context = CMSDataContext.newInstance()
                                               .withLocale(LocaleUtils.toLocale(language));
        IndexableElementTypeHelper.indexFulltextValue(document, pageTitle, context);
        if (!pageTitle.equals(pageLongTitle))
        {
            IndexableElementTypeHelper.indexFulltextValue(document, pageLongTitle, context);
        }
        
        // 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).
        Set<String> tags = page.getTags()
                .stream()
                .filter(tagName -> _tagProviderEP.hasTag(tagName, Map.of("siteName", page.getSiteName())))
                .collect(Collectors.toSet());
        document.addField(TagsSystemProperty.TAGS_SOLR_FIELD_NAME, tags);
        document.addField(TagsSystemProperty.ALL_TAGS_SOLR_FIELD_NAME, _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
        ZonedDateTime lastModified = _getLastModificationDate(page);
        if (lastModified != null)
        {
            String lastModifiedStr = DateUtils.zonedDateTimeToString(lastModified, ZoneOffset.UTC);
            // For 'new' search service
            document.addField(LastModifiedSystemProperty.SOLR_FIELD_NAME, lastModifiedStr);
            // For 'old' search service
            document.addField(LastModifiedSystemProperty.SOLR_FIELD_NAME + "_dt", lastModifiedStr);
        }
        
        // Page last validation date
        ZonedDateTime lastValidation = _getLastValidationDate(page);
        if (lastValidation != null)
        {
            String lastValidationStr = DateUtils.zonedDateTimeToString(lastValidation, ZoneOffset.UTC);
            // For 'new' search service
            document.addField(LastValidationSystemProperty.SOLR_FIELD_NAME, lastValidationStr);
        }
        
        // Page first validation date
        ZonedDateTime firstValidation = _getFirstValidationDate(page);
        if (firstValidation != null)
        {
            String firstValidationStr = DateUtils.zonedDateTimeToString(firstValidation, ZoneOffset.UTC);
            // For 'new' search service
            document.addField(FirstValidationSystemProperty.SOLR_FIELD_NAME, firstValidationStr);
        }
        
        // Page last major validation date
        ZonedDateTime lastMajorValidation = _getLastMajorValidationDate(page);
        if (lastMajorValidation != null)
        {
            String lastMajorValidationStr = DateUtils.zonedDateTimeToString(lastMajorValidation, ZoneOffset.UTC);
            // For 'new' search service
            document.addField(LastMajorValidationSystemProperty.SOLR_FIELD_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 = Map.of("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())
            {
                AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems();
                for (ZoneItem zoneItem : zoneItems)
                {
                    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
                            }
                            
                            _indexFacetableFields(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 _indexFacetableFields(Content content, SolrInputDocument document)
    {
        try
        {
            String[] allContentTypes = ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());
            for (ModelItem modelItem : _cTypesHelper.getModelItems(allContentTypes))
            {
                DataContext context = RepositoryDataContext.newInstance()
                                                           .withObject(content);
                
                Optional.ofNullable(content.getLanguage())
                        .map(LocaleUtils::toLocale)
                        .ifPresent(context::withLocale);
                
                _findAndIndexFacetableField(document, content, modelItem, context);
            }
        }
        catch (IllegalArgumentException e)
        {
            getLogger().error("indexContent > Error getting the model items of content " + content.getId(), e);
            throw new RuntimeException("indexContent > Error getting the model items of content " + content.getId(), e);
        }
    }
    
    /**
     * Index the facetable fields of a data holder into the page solr document
     * @param pageDocument The Solr page document
     * @param dataHolder the parent data holder
     * @param modelItem the model item
     * @param context the context of the data to index
     */
    protected void _findAndIndexFacetableField(SolrInputDocument pageDocument, ModelAwareDataHolder dataHolder, ModelItem modelItem, DataContext context)
    {
        String dataName = modelItem.getName();
        if (dataHolder.hasValue(dataName))
        {
            if (modelItem instanceof ElementDefinition elementDefinition)
            {
                DataContext newContext = context.cloneContext()
                                                .addSegmentToDataPath(dataName);
               
                Collection<String> values = _getValuesToIndex(dataHolder, elementDefinition, newContext);
                for (String value : values)
                {
                    pageDocument.addField(FACETABLE_CONTENT_FIELD_PREFIX + dataName + "_s_dv", value);
                }
            }
            else if (modelItem instanceof RepeaterDefinition repeaterDefinition)
            {
                ModelAwareRepeater repeater = dataHolder.getRepeater(dataName);
                for (ModelAwareRepeaterEntry entry : repeater.getEntries())
                {
                    DataContext newContext = context.cloneContext()
                                                    .addSegmentToDataPath(dataName + "[" + entry.getPosition() + "]");
                    
                    for (ModelItem child : repeaterDefinition.getModelItems())
                    {
                        _findAndIndexFacetableField(pageDocument, entry, child, newContext);
                    }
                }
            }
            else if (modelItem instanceof CompositeDefinition compositeDefinition)
            {
                ModelAwareComposite composite = dataHolder.getComposite(dataName);
                DataContext newContext = context.cloneContext()
                                                .addSegmentToDataPath(dataName);
                
                for (ModelItem child : compositeDefinition.getModelItems())
                {
                    _findAndIndexFacetableField(pageDocument, composite, child, newContext);
                }
            }
        }
    }
    
    /**
     * Retrieves the values to index if the field is facetable, or an empty collection
     * @param dataHolder the data holder
     * @param elementDefinition the definition of the field
     * @param context the context of the data to index
     * @return the values to index if the field is facetable, or an empty collection
     */
    protected Collection<String> _getValuesToIndex(ModelAwareDataHolder dataHolder, ElementDefinition elementDefinition, DataContext context)
    {
        String dataName = elementDefinition.getName();
        ElementType type = elementDefinition.getType();
        if (type instanceof IndexableElementType indexingElementType)
        {
            if (ModelItemTypeConstants.STRING_TYPE_ID.equals(type.getId()) && indexingElementType.isFacetable(context))
            {
                Object value = dataHolder.getValue(dataName, true);
                if (value instanceof String[] stringValues)
                {
                    return Arrays.asList(stringValues);
                }
                else if (value instanceof String stringValue)
                {
                    return List.of(stringValue);
                }
            }
            else if (org.ametys.cms.data.type.ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID.equals(type.getId()))
            {
                Object value = dataHolder.getValue(dataName, true);
                if (value instanceof ContentValue[] contentValues)
                {
                    return Arrays.stream(contentValues)
                            .map(ContentValue::getContentId)
                            .collect(Collectors.toList());
                }
                else if (value instanceof ContentValue contentValue)
                {
                    return List.of(contentValue.getContentId());
                }
            }
        }
        
        return List.of();
    }
    
    /**
     * Computes the last modification date of a page.
     * @param page the page.
     * @return the last modification date or <code>null</code>.
     */
    protected ZonedDateTime _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 ZonedDateTime _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 ZonedDateTime _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 ZonedDateTime _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 ZonedDateTime _getLastDate(Page page, Function<Content, ZonedDateTime> dateRetriever)
    {
        ZonedDateTime last = null;

        if (page.getType() == PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems();
                for (ZoneItem zoneItem : zoneItems)
                {
                    switch (zoneItem.getType())
                    {
                        case SERVICE:
                            // A service has no last date
                            break;
                        case CONTENT:
                            try
                            {
                                ZonedDateTime contentLast = dateRetriever.apply(zoneItem.getContent());

                                if (contentLast != null && (last == null || contentLast.isAfter(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 ZonedDateTime _getFirstDate(Page page, Function<Content, ZonedDateTime> dateRetriever)
    {
        ZonedDateTime first = null;
        
        if (page.getType() == PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems();
                for (ZoneItem zoneItem : zoneItems)
                {
                    switch (zoneItem.getType())
                    {
                        case SERVICE:
                            // A service has no first date
                            break;
                        case CONTENT:
                            try
                            {
                                ZonedDateTime contentFirst = dateRetriever.apply(zoneItem.getContent());
                                
                                if (contentFirst != null && (first == null || contentFirst.isBefore(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
    {
        if (page.isIndexable())
        {
            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;
        }
        
        AmetysObjectIterable<AmetysObject> children = collection.getChildren();
        for (AmetysObject object : children)
        {
            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
    {
        if (page.isIndexable())
        {
            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);
        }
    }
    
    private class PageIndexerCallable extends AbstractIndexerCallable<Page>
    {
        private boolean _indexAttachments;
        
        @SuppressWarnings("synthetic-access")
        public PageIndexerCallable(Page page, String workspaceName, boolean indexAttachments, SolrClient solrClient)
        {
            super(page, workspaceName, solrClient, _manager, _cocoonContext, _ametysObjectResolver, getLogger());
            this._indexAttachments = indexAttachments;
        }
        
        @Override
        protected void process(Page page) throws Exception
        {
            _logger.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 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);
            }
        }

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