/*
 *  Copyright 2015 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.content.indexing.solr;

import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.xml.sax.SAXParser;
import org.apache.solr.common.SolrInputDocument;
import org.apache.tika.Tika;
import org.apache.tika.exception.TikaException;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import org.ametys.cms.content.RichTextHandler;
import org.ametys.cms.contenttype.ContentConstants;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataManager;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.contenttype.indexing.CustomIndexingField;
import org.ametys.cms.contenttype.indexing.CustomMetadataIndexingField;
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.repository.Content;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.explorer.resources.metadata.TikaProvider;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.RichText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component for {@link Content} indexing into a Solr server.
 */
public class SolrContentIndexer extends AbstractLogEnabled implements Component, Serviceable, SolrFieldNames
{
    /** The component role. */
    public static final String ROLE = SolrContentIndexer.class.getName();
    
    private static final int __SOLR_STRING_NB_BYTES_LIMIT = 32766; 
    
    /** The Ametys objet resolver */
    protected AmetysObjectResolver _resolver;
    /** The content type extension point */
    protected ContentTypeExtensionPoint _cTypeEP;
    /** The content type helper */
    protected ContentTypesHelper _cTypesHelper;
    /** The users manager */
    protected UserHelper _userHelper;
    /** The Tika instance */
    protected Tika _tika;
    /** The resource indexer */
    protected SolrResourceIndexer _resourceIndexer;
    /** The sax parser */
    protected SAXParser _parser;
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _systemPropEP;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _resourceIndexer = (SolrResourceIndexer) manager.lookup(SolrResourceIndexer.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _userHelper = (UserHelper) manager.lookup(UserHelper.ROLE);
        TikaProvider tikaProvider = (TikaProvider) manager.lookup(TikaProvider.ROLE);
        _tika = tikaProvider.getTika();
        _parser = (SAXParser) manager.lookup(SAXParser.ROLE);
        _systemPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
    }
    
    /**
     * Populate a solr input document by adding fields to index into it.
     * @param content The content to index
     * @param document The main solr document to index into
     * @param additionalDocuments The additional documents for repeater instances
     * @throws Exception if an error occurred while indexing
     */
    public void indexContent(Content content, SolrInputDocument document, List<SolrInputDocument> additionalDocuments) throws Exception
    {
        // Properties specific to a stand-alone indexation.
        String contentId = content.getId();
        document.addField(ID, contentId);
        document.addField(DOCUMENT_TYPE, TYPE_CONTENT);
        document.addField(TITLE, _truncateUtf8StringValue(content.getTitle(), contentId, TITLE));
        document.addField(CONTENT_NAME, _truncateUtf8StringValue(content.getName(), contentId, CONTENT_NAME));
        
        document.addField(WORKFLOW_REF_DV, contentId + "#workflow");
        
        // Index content system properties.
        indexSystemProperties(content, document);
        
        // Index the fields specified in the indexation model.
        indexModelFields(content, document, additionalDocuments);
    }
    
    /**
     * Index the system properties of a content.
     * @param content The content to index.
     * @param document The solr document to index into.
     */
    protected void indexSystemProperties(Content content, SolrInputDocument document)
    {
        for (String sysPropId : _systemPropEP.getExtensionsIds())
        {
            SystemProperty sysProp = _systemPropEP.getExtension(sysPropId);
            
            sysProp.index(content, document);
        }
    }
    
    /**
     * Index the content type and all its supertypes in the given document (recursively).
     * @param cTypeId The ID of the content type to index.
     * @param document The solr document to index into.
     * @param fieldName The field name.
     */
    protected void indexAllContentTypes(String cTypeId, SolrInputDocument document, String fieldName)
    {
        document.addField(fieldName, cTypeId);
        
        if (_cTypeEP.hasExtension(cTypeId))
        {
            ContentType contentType = _cTypeEP.getExtension(cTypeId);
            for (String supertypeId : contentType.getSupertypeIds())
            {
                indexAllContentTypes(supertypeId, document, fieldName);
            }
        }
    }
    
    /**
     * Index the fields specified in the indexation model.
     * @param content The content to index.
     * @param document The main content solr document.
     * @param additionalDocuments The additional documents for repeater instances.
     */
    protected void indexModelFields(Content content, SolrInputDocument document, List<SolrInputDocument> additionalDocuments)
    {
        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 CustomIndexingField)
            {
                Object[] values = ((CustomIndexingField) field).getValues(content);
                indexValues(content, field.getName(), field.getType(), values, document, null);
            }
            else 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)
                {
                    findAndIndexMetadata(content, pathSegments, content.getMetadataHolder(), definition, field, field.getName(), document, null, additionalDocuments);
                }
            }
        }
    }
    
    /**
     * Populate a Solr input document by adding fields for a single system property.
     * @param content The content to index
     * @param propertyId The system property ID.
     * @param document The solr document
     * @throws Exception if an error occurred
     */
    public void indexPartialSystemProperty(Content content, String propertyId, SolrInputDocument document) throws Exception
    {
        if (!_systemPropEP.hasExtension(propertyId))
        {
            throw new IllegalStateException("The property '" + propertyId + "' can't be indexed as it does not exist.");
        }
        
        SolrInputDocument tempDocument = new SolrInputDocument();
        
        SystemProperty property = _systemPropEP.getExtension(propertyId);
        property.index(content, tempDocument);
        
        // Copy the indexed values as partial updates.
        for (String fieldName : tempDocument.getFieldNames())
        {
            Collection<Object> fieldValues = tempDocument.getFieldValues(fieldName);
            
            Map<String, Object> partialUpdate = new HashMap<>();
            partialUpdate.put("set", fieldValues);
            document.addField(fieldName, partialUpdate);
        }
        
        document.addField("id", content.getId());
    }
    
    /**
     * Find the metadata to index from its path
     * @param content the content currently being traversed.
     * @param pathSegments The segments of path of metadata to index
     * @param metadata The parent composite metadata
     * @param definition The metadata definition
     * @param field the current indexing field.
     * @param fieldName the name of the field to index.
     * @param document The main solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param additionalDocuments The additional documents
     */
    protected void findAndIndexMetadata(Content content, String[] pathSegments, CompositeMetadata metadata, MetadataDefinition definition, IndexingField field, String fieldName, SolrInputDocument document, SolrInputDocument contentDoc, List<SolrInputDocument> additionalDocuments)
    {
        String currentFieldName = pathSegments[0];
        
        IndexingModel indexingModel = null;
        try
        {
            indexingModel = _cTypesHelper.getIndexingModel(content);
        }
        catch (RuntimeException e)
        {
            if (content != null)
            {
                getLogger().error("findAndIndexMetadata > Error while indexing content " + content.getId() + " metadata", e);
            }
            else
            {
                getLogger().error("findAndIndexMetadata > Error while indexing null content metadata");
            }
            throw e;
        }
        
        IndexingField refField = indexingModel.getField(currentFieldName);
        if (refField != null && refField instanceof CustomMetadataIndexingField)
        {
            CustomMetadataIndexingField overridingField = (CustomMetadataIndexingField) refField;
            findAndIndexOverridingField(content, indexingModel, overridingField, fieldName, definition, pathSegments, document, contentDoc, additionalDocuments);
        }
        else
        {
            if (metadata.hasMetadata(currentFieldName))
            {
                findAndIndexMetadataField(content, pathSegments, metadata, definition, field, fieldName, document, contentDoc, additionalDocuments);
            }
        }
    }

    /**
     * Find and index a metadata.
     * @param content the current content being traversed.
     * @param pathSegments the full metadata path segments.
     * @param metadata the current metadata holder.
     * @param definition the current metadata definition.
     * @param field the current indexing field.
     * @param fieldName the name of the field to index.
     * @param document the solr main document.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself). 
     * @param additionalDocuments the solr additional documents.
     */
    protected void findAndIndexMetadataField(Content content, String[] pathSegments, CompositeMetadata metadata, MetadataDefinition definition, IndexingField field, String fieldName, SolrInputDocument document, SolrInputDocument contentDoc, List<SolrInputDocument> additionalDocuments)
    {
        String currentFieldName = pathSegments[0];
        
        if (pathSegments.length == 1)
        {
            indexMetadata(content, currentFieldName, metadata, document, contentDoc, additionalDocuments, fieldName, definition);
            return;
        }
        
        String[] followingSegments = ArrayUtils.subarray(pathSegments, 1, pathSegments.length);
        
        switch (definition.getType())
        {
            case BINARY:
            case BOOLEAN:
            case STRING:
            case USER:
            case LONG:
            case DOUBLE:
            case DATE:
            case DATETIME:
            case REFERENCE:
            case RICH_TEXT:
            case FILE:
            case GEOCODE:
                getLogger().warn("The metadata '{}' of type {} can not be a part of a path to index : {}", currentFieldName, definition.getType().toString(), StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR));
                break;
            case CONTENT:
                String[] contentIds = metadata.getStringArray(currentFieldName, new String[0]);
                for (String contentId : contentIds)
                {
                    try
                    {
                        Content refContent = _resolver.resolveById(contentId);
                        MetadataDefinition remoteMetadataDef = _cTypesHelper.getMetadataDefinition(followingSegments[0], refContent.getTypes(), refContent.getMixinTypes());
                        findAndIndexMetadata(refContent, followingSegments, refContent.getMetadataHolder(), remoteMetadataDef, field, fieldName, document, contentDoc, additionalDocuments);
                    }
                    catch (UnknownAmetysObjectException e)
                    {
                        // Nothing to index
                    }
                }
                break;
            case SUB_CONTENT:
                TraversableAmetysObject objectCollection = metadata.getObjectCollection(currentFieldName);
                AmetysObjectIterable<Content> subcontents = objectCollection.getChildren();
                for (Content subcontent : subcontents)
                {
                    MetadataDefinition remoteMetadataDef = _cTypesHelper.getMetadataDefinition(followingSegments[0], subcontent.getTypes(), subcontent.getMixinTypes());
                    findAndIndexMetadata(subcontent, followingSegments, subcontent.getMetadataHolder(), remoteMetadataDef, field, fieldName, document, contentDoc, additionalDocuments);
                }
                break;
            case COMPOSITE:
                CompositeMetadata composite = metadata.getCompositeMetadata(currentFieldName);
   
                if (definition instanceof RepeaterDefinition)
                {
                    String[] entries = composite.getMetadataNames();
                    for (String entry : entries)
                    {
                        findAndIndexMetadata(content, followingSegments, composite.getCompositeMetadata(entry), definition.getMetadataDefinition(followingSegments[0]), field, fieldName, document, contentDoc, additionalDocuments);
                    }
                }
                else
                {
                    findAndIndexMetadata(content, followingSegments, composite, definition.getMetadataDefinition(followingSegments[0]), field, fieldName, document, contentDoc, additionalDocuments);
                }
                break;
            default:
                break;
            
        }
    }
    
    /**
     * Find and index a property represented by an overriding field.
     * @param content the current content being traversed.
     * @param indexingModel the current indexing model.
     * @param pathSegments the full metadata path segments.
     * @param definition the current metadata definition.
     * @param field the current indexing field.
     * @param fieldName the name of the field to index.
     * @param document the solr main document.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param additionalDocuments the solr additional documents.
     */
    protected void findAndIndexOverridingField(Content content, IndexingModel indexingModel, CustomMetadataIndexingField field, String fieldName, MetadataDefinition definition, String[] pathSegments, SolrInputDocument document, SolrInputDocument contentDoc, List<SolrInputDocument> additionalDocuments)
    {
        String currentFieldName = field.getName();
        
        if (pathSegments.length == 1)
        {
            indexOverridingField(field, content, fieldName, document, contentDoc, additionalDocuments);
            return;
        }
        
        String[] followingSegments = ArrayUtils.subarray(pathSegments, 1, pathSegments.length);
        MetadataType type = definition.getType();
        
        switch (type)
        {
            case BINARY:
            case BOOLEAN:
            case STRING:
            case USER:
            case LONG:
            case DOUBLE:
            case DATE:
            case DATETIME:
            case REFERENCE:
            case RICH_TEXT:
            case FILE:
            case GEOCODE:
                getLogger().warn("The field '{}' of type {} can not be a part of a path to index : {}", currentFieldName, type.toString(), StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR));
                break;
            case COMPOSITE:
                getLogger().warn("The type {} is invalid for the overriding field '{}'.", type.toString(), currentFieldName);
                break;
            case CONTENT:
            case SUB_CONTENT:
                String[] contentIds = (String[]) field.getValues(content);
                for (String contentId : contentIds)
                {
                    Content refContent = _resolver.resolveById(contentId);
                    MetadataDefinition remoteMetadataDef = _cTypesHelper.getMetadataDefinition(followingSegments[0], refContent.getTypes(), refContent.getMixinTypes());
                    findAndIndexMetadata(refContent, followingSegments, refContent.getMetadataHolder(), remoteMetadataDef, field, fieldName, document, contentDoc, additionalDocuments);
                }
                break;
            default:
                break;
        }
    }
    
    /**
     * Index a content metadata.
     * @param content the current content being traversed.
     * @param metadataName The name of metadata to index
     * @param metadata The parent composite metadata
     * @param document the solr document to index into.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param additionalDocuments The solr additional documents used for repeater instance
     * @param fieldName the name of the indexed field.
     * @param definition the metadata definition.
     */
    public void indexMetadata(Content content, String metadataName, CompositeMetadata metadata, SolrInputDocument document, SolrInputDocument contentDoc, List<SolrInputDocument> additionalDocuments, String fieldName, MetadataDefinition definition)
    {
        String language = content.getLanguage();
        
        switch (definition.getType())
        {
            case STRING:
                indexStringMetadata(metadata, metadataName, content.getId(), document, contentDoc, fieldName, language, definition);
                break;
            case USER:
                indexUserMetadata(metadata, metadataName, document, contentDoc, fieldName, language, definition);
                break;
            case GEOCODE:
                indexGeoCodeMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case BINARY:
                indexBinaryMetadata(metadata, metadataName, document, contentDoc, fieldName, language, definition);
                break;
            case FILE:
                indexFileMetadata(metadata, metadataName, document, contentDoc, fieldName, language, definition);
                break;
            case DATE:
                indexDateMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case DATETIME:
                indexDateTimeMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case CONTENT:
                indexContentMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case SUB_CONTENT:
                indexSubContentMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case LONG:
                indexLongMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case DOUBLE:
                indexDoubleMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case BOOLEAN:
                indexBooleanMetadata(metadata, metadataName, document, fieldName, definition);
                break;
            case RICH_TEXT:
                indexRichtextMetadata(metadata, metadataName, document, contentDoc, fieldName, language, definition);
                break;
            case COMPOSITE:
                if (definition instanceof RepeaterDefinition)
                {
                    indexRepeaterMetadata(content, metadata, metadataName, document, contentDoc, fieldName, definition, additionalDocuments);
                }
                else
                {
                    indexCompositeMetadata(content, metadata, metadataName, document, contentDoc, fieldName, definition, additionalDocuments);
                }
                break;
            case REFERENCE:
                // TODO reference -> to be indexed?
                break;
            default:
                break;
        }
    }
    
    /**
     * Index a property represented by an overriding field.
     * @param field The overriding field.
     * @param content The content of which to get the property.
     * @param fieldName The name of the field to index.
     * @param document the solr document to index into.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param additionalDocuments The solr additional documents used for repeater instance
     */
    public void indexOverridingField(CustomMetadataIndexingField field, Content content, String fieldName, SolrInputDocument document, SolrInputDocument contentDoc, List<SolrInputDocument> additionalDocuments)
    {
        Object[] values = field.getValues(content);
        MetadataDefinition definition = field.getMetadataDefinition();
        boolean isFacetable = definition.getEnumerator() != null;
        String language = content.getLanguage();
        
        switch (definition.getType())
        {
            case STRING:
                indexStringValues((String[]) values, content.getId(), document, contentDoc, fieldName, language, isFacetable);
                break;
            case USER:
                UserIdentity[] users = new UserIdentity[values.length];
                for (int i = 0; i < values.length; i++)
                {
                    users[i] = UserIdentity.stringToUserIdentity((String) values[i]);
                }
                indexUserValues(users, document, contentDoc, fieldName, language);
                break;
            case GEOCODE:
                if (values.length > 1)
                {
                    indexGeocodeValue((double) values[0], (double) values[1], document, fieldName);
                }
                break;
            case BINARY:
                if (values.length > 0)
                {
                    indexFullTextBinaryValue((InputStream) values[0], document, contentDoc, fieldName, language);
                }
                break;
            case FILE:
                indexFileValue(values, document, contentDoc, fieldName, language);
                break;
            case DATE:
                indexDateValues((Date[]) values, document, fieldName);
                break;
            case DATETIME:
                indexDateTimeValues((Date[]) values, document, fieldName);
                break;
            case CONTENT:
                indexContentValues((String[]) values, document, fieldName);
                break;
            case SUB_CONTENT:
                indexContentValues((String[]) values, document, fieldName);
                break;
            case LONG:
                indexLongValues((Long[]) values, document, fieldName, isFacetable);
                break;
            case DOUBLE:
                indexDoubleValues((Double[]) values, document, fieldName, isFacetable);
                break;
            case BOOLEAN:
                indexBooleanValues((Boolean[]) values, document, fieldName);
                break;
            case RICH_TEXT:
                if (values.length > 0)
                {
                    indexRichtextValue((RichText) values[0], document, contentDoc, fieldName, language);
                }
                break;
            case COMPOSITE:
                break;
            case REFERENCE:
                // TODO reference -> to be indexed?
                break;
            default:
                break;
        }
    }
    
    /**
     * Index values 
     * @param content The content being indexed.
     * @param fieldName The Solr field's name
     * @param type the type of values to index
     * @param values the values
     * @param document the Solr document
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     */
    public void indexValues(Content content, String fieldName, MetadataType type, Object[] values, SolrInputDocument document, SolrInputDocument contentDoc)
    {
        String language = content.getLanguage();
        
        switch (type)
        {
            case STRING:
                indexStringValues((String[]) values, content.getId(), document, contentDoc, fieldName, language, false);
                break;
            case LONG:
                indexLongValues((Long[]) values, document, fieldName, false);
                break;
            case DOUBLE:
                indexDoubleValues((Double[]) values, document, fieldName, false);
                break;
            case DATE:
                indexDateValues((Date[]) values, document, fieldName);
                break;
            case DATETIME:
                indexDateTimeValues((Date[]) values, document, fieldName);
                break;
            case CONTENT:
                indexContentValues((String[]) values, document, fieldName);
                break;
            case BOOLEAN:
                indexBooleanValues((Boolean[]) values, document, fieldName);
                break;
            case USER:
                UserIdentity[] users = new UserIdentity[values.length];
                for (int i = 0; i < values.length; i++)
                {
                    users[i] = UserIdentity.stringToUserIdentity((String) values[i]);
                }
                indexUserValues(users, document, contentDoc, fieldName, language);
                break;
            case RICH_TEXT:
                indexRichtextValue((RichText) values[0], document, contentDoc, fieldName, language);
                break;
            case BINARY:
            case FILE:
            case COMPOSITE:
            case REFERENCE:
            case SUB_CONTENT:
            case GEOCODE:
                getLogger().warn("Only primitive type is allowed on a custom indexing field");
                break;
            default:
                break;
        }
    }
    
    
    /**
     * Index a 'string' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param contentId The content id. For logging purposes
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    public void indexStringMetadata(CompositeMetadata metadata, String metadataName, String contentId, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        String[] strValues = metadata.getStringArray(metadataName, new String[0]);
        indexStringValues(strValues, contentId, document, contentDoc, fieldName, language, definition.getEnumerator() != null);
    }
    
    /**
     * Index 'string' values
     * @param values The values
     * @param contentId The content id. For logging purposes
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param isFacetable true if the field can be used as a facet.
     */
    public void indexStringValues(String[] values, String contentId, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, boolean isFacetable)
    {
        for (String value : values)
        {
            if (!isFacetable)
            {
                // No enumerator: index as full-text.
                document.addField(fieldName + "_txt_" + language, value);
                document.addField(fieldName + "_txt_stemmed_" + language, value);
                document.addField(fieldName + "_txt_ws_" + language, value);
            }
            else
            {
                // Facets (enumeration only)
                document.addField(fieldName + "_s_dv", value);
            }
            
            // Index without analyzing.
            String possiblyTruncatedValue = _truncateUtf8StringValue(value, contentId, fieldName);
            document.addField(fieldName + "_s", possiblyTruncatedValue);
            
            // Index without analyzing but lower-case (for wildcard queries).
            document.addField(fieldName + "_s_lower", possiblyTruncatedValue.toLowerCase());
            
            // Exact words tokenized by whitespace.
            document.addField(fieldName + "_s_ws", value.toLowerCase());
            
            // Index with analyze (full-text search).
            document.addField(fieldName + "_txt", value);
            
            indexFulltextValue(document, contentDoc, value, language);
        }
        
        String sortField = SolrFieldHelper.getMetadataSortFieldName(MetadataType.STRING, fieldName);
        if (values.length > 0 && !document.containsKey(sortField))
        {
            // FIXME Si la meta est enumerée, indexer le label ? dans quelle langue ?
            document.addField(sortField, SolrFieldHelper.getSortValue(values[0]));
        }
    }
    
    private String _truncateUtf8StringValue(String value, String contentId /*logging purpose*/, String fieldName /*logging purpose*/)
    {
        if (value.length() * 4 <= __SOLR_STRING_NB_BYTES_LIMIT)
        {
            // With UTF-8, a character is encoded using 1, 2, 3 or 4 bytes, so (value.length() <= value.getBytes().length <= 4 * value.length())
            // As a result, value.getBytes().length <= limit
            return value;
        }
        
        // There is a doubt, the string may need to be truncated (or not)
        byte[] valueBytes = value.getBytes(StandardCharsets.UTF_8);
        int bytesLength = valueBytes.length;
        if (bytesLength <= __SOLR_STRING_NB_BYTES_LIMIT)
        {
            return value;
        }
        
        getLogger().warn("The string value for content '{}' and field name '{}' is longer ({}) than the max bytes length {}. It will be truncated to prevent Solr error, but you should consider verifying why this string is so long.", contentId, fieldName, bytesLength, __SOLR_STRING_NB_BYTES_LIMIT);
        
        // Need a truncation (inspired by https://stackoverflow.com/questions/119328/how-do-i-truncate-a-java-string-to-fit-in-a-given-number-of-bytes-once-utf-8-en#answer-35148974)
        CharBuffer charBuffer = CharBuffer.allocate(__SOLR_STRING_NB_BYTES_LIMIT);
        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder()
                                                       .onMalformedInput(CodingErrorAction.IGNORE);
        decoder.decode(ByteBuffer.wrap(valueBytes, 0, __SOLR_STRING_NB_BYTES_LIMIT), charBuffer, true);
        decoder.flush(charBuffer);
        return new String(charBuffer.array(), 0, charBuffer.position());
    }
    
    /**
     * Index a 'date' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexDateMetadata (CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        Date[] dateValues = metadata.getDateArray(metadataName, new Date[0]);
        indexDateValues (dateValues, document, fieldName);
    }
    
    /**
     * Index 'date' values
     * @param values The values
     * @param document The solr document to index into
     * @param fieldName The index field name
     */
    public void indexDateValues (Date[] values, SolrInputDocument document, String fieldName)
    {
        for (Date value : values)
        {
            document.addField(fieldName + "_dt", SolrIndexer.dateFormat().format(value));
        }
        
        String sortField = fieldName + "_dt_sort";
        if (values.length > 0 && !document.containsKey(sortField))
        {
            document.addField(sortField, SolrIndexer.dateFormat().format(values[0]));
        }
    }
    
    /**
     * Index a 'datetime' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexDateTimeMetadata (CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        Date[] dateValues = metadata.getDateArray(metadataName, new Date[0]);
        indexDateTimeValues(dateValues, document, fieldName);
    }
    
    /**
     * Index 'datetime' values
     * @param values The values
     * @param document The solr document to index into
     * @param fieldName The index field name
     */
    public void indexDateTimeValues (Date[] values, SolrInputDocument document, String fieldName)
    {
        for (Date value : values)
        {
            document.addField(fieldName + "_dt", SolrIndexer.dateFormat().format(value));
        }
        
        String sortField = fieldName + "_dt_sort";
        if (values.length > 0 && !document.containsKey(sortField))
        {
            document.addField(sortField, SolrIndexer.dateFormat().format(values[0]));
        }
    }
    
    /**
     * Index a 'double' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexDoubleMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        boolean isFacetable = definition.getEnumerator() != null;
        double[] values = metadata.getDoubleArray(metadataName, new double[0]);
        indexDoubleValues (ArrayUtils.toObject(values), document, fieldName, isFacetable);
    }
    
    /**
     * Index 'double' values
     * @param values The values
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param isFacetable true if the field can be used as a facet.
     */
    public void indexDoubleValues(Double[] values, SolrInputDocument document, String fieldName, boolean isFacetable)
    {
        for (Double value : values)
        {
            document.addField(fieldName + "_d", value);
            if (isFacetable)
            {
                document.addField(fieldName + "_d_dv", value);
            }
        }
        
        String sortField = fieldName + "_d_sort";
        if (values.length > 0 && !document.containsKey(sortField))
        {
            document.addField(sortField, values[0]);
        }
    }
    
    /**
     * Index a 'long' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexLongMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        boolean isFacetable = definition.getEnumerator() != null;
        long[] values = metadata.getLongArray(metadataName, new long[0]);
        indexLongValues(ArrayUtils.toObject(values), document, fieldName, isFacetable);
    }
    
    /**
     * Index 'long' values
     * @param values The values
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param isFacetable true if the field can be used as a facet. 
     */
    public void indexLongValues(Long[] values, SolrInputDocument document, String fieldName, boolean isFacetable)
    {
        for (Long value : values)
        {
            document.addField(fieldName + "_l", value);
            if (isFacetable)
            {
                document.addField(fieldName + "_l_dv", value);
            }
        }
        
        String sortField = fieldName + "_l_sort";
        if (values.length > 0 && !document.containsKey(sortField))
        {
            document.addField(sortField, values[0]);
        }
    }
    
    /**
     * Index a 'user' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    public void indexUserMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        UserIdentity[] users = metadata.getUserArray(metadataName);
        indexUserValues(users, document, contentDoc, fieldName, language);
    }
    
    /**
     * Index 'user' values
     * @param users The users
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     */
    public void indexUserValues(UserIdentity[] users, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language)
    {
        int count = 0;
        for (UserIdentity userIdentity : users)
        {
            String fullName = _userHelper.getUserFullName(userIdentity);
            String identityAsString = UserIdentity.userIdentityToString(userIdentity);
            
            indexFulltextValue(document, contentDoc, identityAsString, language);
            
            // Dynamic fields
            document.addField(fieldName + "_s", identityAsString);
            
            if (StringUtils.isNotEmpty(fullName))
            {
                document.addField(fieldName + "_txt", fullName);
                
                indexFulltextValue(document, contentDoc, fullName, language);
            }
            
            String sortField = SolrFieldHelper.getMetadataSortFieldName(MetadataType.STRING, fieldName);
            if (count == 0 && StringUtils.isNotEmpty(fullName) && !document.containsKey(sortField))
            {
                // Index only first user for sorting
                document.addField(sortField, SolrFieldHelper.getSortValue(fullName));
            }
            count++;
        }
    }
    
    /**
     * Index a 'boolean' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexBooleanMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        boolean[] values = metadata.getBooleanArray(metadataName, new boolean[0]);
        indexBooleanValues(ArrayUtils.toObject(values), document, fieldName);
    }
    
    /**
     * Index 'boolean' values
     * @param values The values
     * @param document The solr document to index into
     * @param fieldName The index field name
     */
    public void indexBooleanValues(Boolean[] values, SolrInputDocument document, String fieldName)
    {
        for (Boolean value : values)
        {
            document.addField(fieldName + "_b", value);
        }
        
        String sortField = fieldName + "_b_sort";
        if (values.length > 0 && !document.containsKey(sortField))
        {
            document.addField(sortField, values[0]);
        }
    }
    
    /**
     * Index a 'richtext' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    public void indexRichtextMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        indexRichtextValue(metadata.getRichText(metadataName), document, contentDoc, fieldName, language);
    }
    
    /**
     * Index 'richtext' values
     * @param richText The rich text to index.
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name.
     * @param language The content language.
     */
    public void indexRichtextValue(RichText richText, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language)
    {
        try (InputStream is = richText.getInputStream())
        {
            String value = _richTextToString(is);
            
            // Index as a text field.
            document.addField(fieldName + "_txt_" + language, value);
            document.addField(fieldName + "_txt_stemmed_" + language, value);
            document.addField(fieldName + "_txt_ws_" + language, value);
            
            // Index in the full-text value.
            SolrContentIndexer.indexFulltextValue(document, value, language);
            
            if (contentDoc != null)
            {
                SolrContentIndexer.indexFulltextValue(contentDoc, value, language);
            }
        }
        catch (Exception e)
        {
            getLogger().warn("Failed to index RICH_TEXT value'", e);
        }
    }
    
    /**
     * Gets a XML as a string and extract the text only
     * @param is The inputstream of XML
     * @return The text or null if the XML is not well formed
     */
    protected String _richTextToString(InputStream is)
    {
        try
        {
            RichTextHandler txtHandler = new RichTextHandler();
            _parser.parse(new InputSource(is), txtHandler);
            return txtHandler.getValue().trim();
        }
        catch (IOException | SAXException e)
        {
            getLogger().error("Cannot parse inputstream", e);
            return null;
        }
    }
    
    
   
    /**
     * Index a 'binary' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    public void indexBinaryMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        // Index file name.
        BinaryMetadata binary = metadata.getBinaryMetadata(metadataName);
        document.addField(fieldName + "_txt", binary.getFilename());
        
        // Index the contents.
        indexFullTextBinary(metadata, metadataName, document, contentDoc, fieldName, language, definition);
    }
    
    /**
     * Index a 'file' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    public void indexFileMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        if (org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.BINARY.equals(metadata.getType(metadataName)))
        {
            indexBinaryMetadata(metadata, metadataName, document, contentDoc, fieldName, language, definition);
        }
        else
        {
            // Resource from the explorer.
            String value = metadata.getString(metadataName);
            
            try
            {
                Resource resource = (Resource) _resolver.resolveById(value);
                
                // Index file name.
                document.addField(fieldName + "_txt", resource.getName());
                
                // Index the contents.
                indexResourceContent(resource, document, contentDoc, language);
                
//                document.addField(prefix + fieldName + "$path", resource.getId());
//                document.addField(prefix + fieldName + "$type", "explorer");
//                document.addField(prefix + fieldName + "$mime-type", resource.getMimeType());
//                document.addField(prefix + fieldName + "$filename", filename);
//                document.addField(prefix + fieldName + "$lastModified", resource.getLastModified());
//                document.addField(prefix + fieldName + "$size", resource.getLength());
//                
//                String viewUrl = "/plugins/explorer/resource?id=" + resource.getId();
//                document.addField(prefix + fieldName + "$viewUrl", viewUrl);
//                document.addField(prefix + fieldName + "$downloadUrl", viewUrl + "&download=true");
            }
            catch (AmetysRepositoryException e)
            {
                getLogger().warn(String.format("Unable to index the resource of id '%s' : resource does not exist.", value), e);
            }
        }
    }
    
    /**
     * Index a 'file' metadata
     * @param values The values.
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     */
    public void indexFileValue(Object[] values, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language)
    {
        String type = (String) values[0];
        if (org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.BINARY.equals(type))
        {
            indexFullTextBinaryValue((InputStream) values[1], document, contentDoc, fieldName, language);
        }
        else
        {
            indexResourceContent((Resource) values[1], document, contentDoc, language);
        }
    }
    
    /**
     * Index a 'binary' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param contentDoc The content document.
     * @param fieldName The index field name
     * @param language The content language.
     * @param definition The metadata definition
     */
    protected void indexFullTextBinary(CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language, MetadataDefinition definition)
    {
        try (InputStream is = metadata.getBinaryMetadata(metadataName).getInputStream())
        {
            indexFullTextBinaryValue(is, document, contentDoc, fieldName, language);
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * Index a 'binary' value
     * @param is An InputStream on the binary data.
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The index field name
     * @param language The content language.
     */
    protected void indexFullTextBinaryValue(InputStream is, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, String language)
    {
        try
        {
            String text = _tika.parseToString(is);
            
            indexFulltextValue(document, contentDoc, text, language);
        }
        catch (Throwable e)
        {
            getLogger().warn(String.format("Failed to index binary field '%s'", fieldName), e);
        }
    }
    
    /**
     * Index a 'content' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexContentMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        String[] contentIds = metadata.getStringArray(metadataName, new String[0]);
        indexContentValues(contentIds, document, fieldName);
    }
    
    /**
     * Index content values.
     * @param contentIds The ID of the contents to index.
     * @param document The solr document to index into.
     * @param fieldName the field name.
     */
    public void indexContentValues (String[] contentIds, SolrInputDocument document, String fieldName)
    {
        for (String contentId : contentIds)
        {
            document.addField(fieldName + "_s", contentId);
            // Facets
            document.addField(fieldName + "_s_dv", contentId);
        }
        
        String sortField = SolrFieldHelper.getMetadataSortFieldName(MetadataType.STRING, fieldName);
        if (contentIds.length > 0 && !document.containsKey(sortField))
        {
            try
            {
                // TODO Est-ce qu'on peut faire autrement qu'un resolve ?
                Content content = _resolver.resolveById(contentIds[0]);
                document.addField(sortField, SolrFieldHelper.getSortValue(content.getTitle()));
            }
            catch (AmetysRepositoryException e)
            {
                // Do not index
            }
        }
    }
    
    /**
     * Index a 'sub_content' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexSubContentMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        TraversableAmetysObject objectCollection = metadata.getObjectCollection(metadataName);
        AmetysObjectIterable<Content> subcontents = objectCollection.getChildren();
        for (Content subcontent : subcontents)
        {
            document.addField(fieldName + "_s", subcontent.getId());
            // Facets
            document.addField(fieldName + "_s_dv", subcontent.getId());
        }
        
//        String sortField = fieldName + "_s_sort";
        String sortField = SolrFieldHelper.getMetadataSortFieldName(MetadataType.STRING, fieldName);
        subcontents = objectCollection.getChildren();
        Iterator<Content> it = subcontents.iterator();
        
        if (it.hasNext() && !document.containsKey(sortField))
        {
            Content subcontent = it.next();
            document.addField(sortField, SolrFieldHelper.getSortValue(subcontent.getTitle()));
        }
    }
    
    /**
     * Index a 'geocode' metadata
     * @param metadata The parent composite metadata
     * @param metadataName The name of metadata to index
     * @param document The solr document to index into
     * @param fieldName The index field name
     * @param definition The metadata definition
     */
    public void indexGeoCodeMetadata(CompositeMetadata metadata, String metadataName, SolrInputDocument document, String fieldName, MetadataDefinition definition)
    {
        CompositeMetadata geoCodeMetadata = metadata.getCompositeMetadata(metadataName);
        if (geoCodeMetadata.hasMetadata("longitude") && geoCodeMetadata.hasMetadata("latitude"))
        {
            double longitude = geoCodeMetadata.getDouble("longitude");
            double latitude = geoCodeMetadata.getDouble("latitude");
            
            indexGeocodeValue(latitude, longitude, document, fieldName);
        }
    }
    
    /**
     * Index a 'geocode' metadata
     * @param latitude the coord latitude.
     * @param longitude the coord longitude.
     * @param document The solr document to index into
     * @param fieldName The index field name
     */
    public void indexGeocodeValue(double latitude, double longitude, SolrInputDocument document, String fieldName)
    {
        document.addField(fieldName + "$longitude_d", longitude);
        document.addField(fieldName + "$latitude_d", latitude);
        
        String geoFieldName = SolrFieldHelper.getIndexingFieldName(MetadataType.GEOCODE, fieldName);
        document.addField(geoFieldName, longitude + " " + latitude);
    }
    
    /**
     * Index a composite metadata, i.e. browse and index the sub-metadatas.
     * @param content The content being indexed.
     * @param metadata The parent metadata.
     * @param metadataName The composite metadata name.
     * @param document The solr document to index into.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The field name.
     * @param definition The composite metadata definition.
     * @param additionalDocuments The solr additional documents used for repeater instance
     */
    public void indexCompositeMetadata(Content content, CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, MetadataDefinition definition, List<SolrInputDocument> additionalDocuments)
    {
        CompositeMetadata compositeMetadata = metadata.getCompositeMetadata(metadataName);
        
        // Index recursively
        Set<String> subMetadataNames = definition.getMetadataNames();
        for (String subMetadataName : subMetadataNames)
        {
            if (compositeMetadata.hasMetadata(subMetadataName))
            {
                indexMetadata(content, subMetadataName, compositeMetadata, document, contentDoc, additionalDocuments, fieldName + ContentConstants.METADATA_PATH_SEPARATOR + subMetadataName, definition.getMetadataDefinition(subMetadataName));
            }
        }
    }
    
    /**
     * Index a repeater metadata, i.e. browse and index the entries.
     * @param content The content being indexed.
     * @param metadata The parent metadata.
     * @param metadataName The repeater metadata name.
     * @param document The solr document to index into.
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param fieldName The field name.
     * @param definition The repeater metadata definition.
     * @param additionalDocuments The solr additional documents used for repeater instance
     */
    public void indexRepeaterMetadata(Content content, CompositeMetadata metadata, String metadataName, SolrInputDocument document, SolrInputDocument contentDoc, String fieldName, MetadataDefinition definition, List<SolrInputDocument> additionalDocuments)
    {
        CompositeMetadata compositeMetadata = metadata.getCompositeMetadata(metadataName);
        
        // Get and sort the entry names.
        String[] entries = compositeMetadata.getMetadataNames();
        Arrays.sort(entries, MetadataManager.REPEATER_ENTRY_COMPARATOR);
        
        for (int i = 0; i < entries.length; i++)
        {
            String entryName = entries[i];
            int position = i + 1;
            
            CompositeMetadata entry = compositeMetadata.getCompositeMetadata(entryName);
            
            String repeaterID = document.getField("id").getFirstValue().toString() + "/" + fieldName + "/" + entryName;
            
            // Creates a new Solr document for each entry
            SolrInputDocument repDocument = new SolrInputDocument();
            repDocument.addField("id", repeaterID);
            document.addField(fieldName + "_s_dv", repeaterID);
            
            repDocument.addField(DOCUMENT_TYPE, TYPE_REPEATER);
            repDocument.addField(REPEATER_ENTRY_POSITION, position);
            // Add the created document to additional documents
            additionalDocuments.add(repDocument);
            
            SolrInputDocument parentContentDoc = contentDoc != null ? contentDoc : document; 
            
            Set<String> subMetadataNames = definition.getMetadataNames();
            for (String subMetadataName : subMetadataNames)
            {
                if (entry.hasMetadata(subMetadataName))
                {
                    // Created document is now the main document
                    indexMetadata(content, subMetadataName, entry, repDocument, parentContentDoc, additionalDocuments, subMetadataName, definition.getMetadataDefinition(subMetadataName));
                }
            }
        }
    }
    
    /**
     * Index the content of a resource.
     * @param resource The resource
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @param language The content language.
     */
    protected void indexResourceContent(Resource resource, SolrInputDocument document, SolrInputDocument contentDoc, String language)
    {
        try (InputStream is = resource.getInputStream())
        {
            indexResourceContentValue(is, resource.getDCSubject(), resource.getDCDescription(), language, document, contentDoc);
            
            // TODO Declare and index DC metadata?
            // DC meta
//            _resourceIndexer.indexDublinCoreMetadata(resource, document);
        }
        catch (Exception e)
        {
            getLogger().error("Unable to index resource at " + resource.getPath(), e);
        }
    }
    
    /**
     * Index the content of a resource.
     * @param is An input stream on the resource content.
     * @param keywords The resource keywords.
     * @param description The resource description.
     * @param language The content language.
     * @param document The solr document to index into
     * @param contentDoc The parent content document to index into (can be null if the main document is the content doc itself).
     * @throws TikaException If an error occurs extracting the document's text content.
     * @throws IOException If an error occurs reading the document's text content.
     */
    protected void indexResourceContentValue(InputStream is, String[] keywords, String description, String language, SolrInputDocument document, SolrInputDocument contentDoc) throws IOException, TikaException
    {
        String value = _tika.parseToString(is);
        
        indexFulltextValue(document, contentDoc, value, language);
        
        for (String keyword : keywords)
        {
            indexFulltextValue(document, contentDoc, keyword, language);
        }
        
        if (description != null)
        {
            indexFulltextValue(document, contentDoc, description, language);
        }
    }
    
    /**
     * Index a full-text value.
     * @param mainDocument The document being used, can be either the content document itself or a repeater document.
     * @param contentDoc The parent content document. If the mainDocument is the content document, this will be null.
     * @param text The text to index.
     * @param language The content language.
     */
    protected void indexFulltextValue(SolrInputDocument mainDocument, SolrInputDocument contentDoc, String text, String language)
    {
        indexFulltextValue(mainDocument, text, language);
        
        // The content doc is null if the main document is the content doc (to prevent indexing the data twice).
        if (contentDoc != null)
        {
            indexFulltextValue(contentDoc, text, language);
        }
    }
    
    /**
     * Index a full-text value.
     * @param document The document to index into.
     * @param text The text to index.
     * @param language The content language.
     */
    public static void indexFulltextValue(SolrInputDocument document, String text, String language)
    {
        if (StringUtils.isNotBlank(text))
        {
            document.addField(FULL_GENERAL, text);
            document.addField(FULL_EXACT_WS, text);
            
            indexLanguageFulltextValue(document, text, language);
        }
    }
    
    /**
     * Index a full-text value.
     * @param document The document to index into.
     * @param text The text to index.
     * @param languages The languages.
     */
    public static void indexFulltextValue(SolrInputDocument document, String text, Collection<String> languages)
    {
        if (StringUtils.isNotBlank(text))
        {
            document.addField(FULL_GENERAL, text);
            document.addField(FULL_EXACT_WS, text);
            
            for (String language : languages)
            {
                indexLanguageFulltextValue(document, text, language);
            }
        }
    }
    
    /**
     * Index a full-text value in the language-specific fields.
     * @param document The document to index into.
     * @param text The text to index.
     * @param language The content language.
     */
    protected static void indexLanguageFulltextValue(SolrInputDocument document, String text, String language)
    {
        document.addField(FULL_PREFIX + language, text);
        document.addField(FULL_STEMMED_PREFIX + language, text);
    }
}