/*
 *  Copyright 2016 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.search.content;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
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.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.xml.sax.SAXParser;
import org.xml.sax.InputSource;

import org.ametys.cms.content.ContentHelper;
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.DefaultMetadataIndexingField;
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.repository.DefaultContent;
import org.ametys.cms.search.SearchField;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.solr.field.BooleanSearchField;
import org.ametys.cms.search.solr.field.ContentSearchField;
import org.ametys.cms.search.solr.field.DateSearchField;
import org.ametys.cms.search.solr.field.DoubleSearchField;
import org.ametys.cms.search.solr.field.JoinedSystemSearchField;
import org.ametys.cms.search.solr.field.LongSearchField;
import org.ametys.cms.search.solr.field.MultilingualStringSearchField;
import org.ametys.cms.search.solr.field.StringSearchField;
import org.ametys.cms.transformation.xslt.ResolveURIComponent;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.I18nUtils;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.MultilingualString;
import org.ametys.plugins.repository.metadata.MultilingualStringHelper;
import org.ametys.plugins.repository.metadata.RichText;
import org.ametys.runtime.parameter.Enumerator;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component which helps content searching by providing a simple way to access
 * content properties (either metadata or system properties).
 */
public class ContentSearchHelper extends AbstractLogEnabled implements Component, Serviceable, Contextualizable
{

    /** The component role. */
    public static final String ROLE = ContentSearchHelper.class.getName();
    
    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The content helper. */
    protected ContentHelper _contentHelper;
    
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _sysPropEP;
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;

    /** The user helper */
    protected UserHelper _userHelper;

    /** Content Types helper */
    protected ContentTypesHelper _contentTypesHelper;

    /** i18n Utils */
    protected I18nUtils _i18nUtils;

    /** Avalon service manager */
    protected ServiceManager _manager;
    
    private Context _context;
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _sysPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _userHelper = (UserHelper) manager.lookup(UserHelper.ROLE);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
    }
    
    /**
     * Get the metadata indexing field for the "title" standard metadata.
     * @return The standard title metadata indexing field.
     */
    public MetadataIndexingField getTitleMetadataIndexingField()
    {
        return new DefaultMetadataIndexingField("title", ContentTypesHelper.getTitleMetadataDefinition(), "title");
    }
    
    /**
     * Get a {@link SearchField} corresponding to a metadata.
     * @param metadataPath The metadata path.
     * @param metadataType The metadata type.
     * @param isTypeContentWithMultilingualTitle <code>true</code> if the type is Content and the linked contents have multilingual titles
     * @return the search field.
     */
    public SearchField getMetadataSearchField(String metadataPath, MetadataType metadataType, boolean isTypeContentWithMultilingualTitle)
    {
        return getMetadataSearchField(null, metadataPath, metadataType, isTypeContentWithMultilingualTitle);
    }
    
    /**
     * Get a {@link SearchField} corresponding to a metadata.
     * @param joinPaths The join paths
     * @param metadataPath The metadata path.
     * @param metadataType The metadata type.
     * @param isTypeContentWithMultilingualTitle <code>true</code> if the type is Content and the linked contents have multilingual titles
     * @return the search field.
     */
    public SearchField getMetadataSearchField(List<String> joinPaths, String metadataPath, MetadataType metadataType, boolean isTypeContentWithMultilingualTitle)
    {
        switch (metadataType)
        {
            case STRING:
            case USER:
                return new StringSearchField(joinPaths, metadataPath);
            case CONTENT:
            case SUB_CONTENT:
                return new ContentSearchField(joinPaths, metadataPath, isTypeContentWithMultilingualTitle, Optional.ofNullable(_context));
            case LONG:
                return new LongSearchField(joinPaths, metadataPath);
            case DOUBLE:
                return new DoubleSearchField(joinPaths, metadataPath);
            case BOOLEAN:
                return new BooleanSearchField(joinPaths, metadataPath);
            case DATE:
            case DATETIME:
                return new DateSearchField(joinPaths, metadataPath);
            case MULTILINGUAL_STRING:
                return new MultilingualStringSearchField(joinPaths, metadataPath, Optional.ofNullable(_context));
            case COMPOSITE:
            case BINARY:
            case FILE:
            case RICH_TEXT:
            case REFERENCE:
            default:
                return null;
        }
    }
    
    /**
     * Get a {@link SearchField} from a field name in a batch of content types.
     * @param contentTypes The content types, can be empty to search on any content type.
     * In that case, only the title metadata and system properties will be usable in sort and facets specs.
     * @param fieldPath The field path, can be either a system property ID or a indexing field name or path.
     * @return The {@link SearchField} corresponding to the field path, or an {@link Optional#empty() empty optional} if not found
     */
    public Optional<SearchField> getSearchField(Collection<String> contentTypes, String fieldPath)
    {
        SearchField searchField = null;
        
        String[] pathSegments = StringUtils.split(fieldPath, ContentConstants.METADATA_PATH_SEPARATOR);
        String fieldName = pathSegments[0];
        
        // System property ?
        if (_sysPropEP.hasExtension(fieldName) && pathSegments.length == 1)
        {
            return Optional.ofNullable(_sysPropEP.getExtension(fieldName).getSearchField());
        }
        
        String commonContentTypeId = _cTypeHelper.getCommonAncestor(contentTypes);
        
        MetadataType type = null;
        MetadataDefinition def = null;
        
        if (commonContentTypeId != null)
        {
            
            // Indexing field.
            ContentType cType = _cTypeEP.getExtension(commonContentTypeId);
            IndexingField indexingField = cType.getIndexingModel().getField(fieldName);
            
            if (indexingField == null)
            {
                throw new IllegalArgumentException("Search field with path '" + fieldPath + "' refers to an unknown indexing field: " + fieldName);
            }
            
            if (indexingField instanceof MetadataIndexingField)
            {
                List<String> joinPaths = new ArrayList<>();
                String[] remainingPathSegments = pathSegments.length > 1 ? (String[]) ArrayUtils.subarray(pathSegments, 1, pathSegments.length) : new String[0];
                
                searchField = _getSearchField((MetadataIndexingField) indexingField, remainingPathSegments, joinPaths, true);
                def = ((MetadataIndexingField) indexingField).getMetadataDefinition();
            }
            else if (indexingField instanceof CustomIndexingField)
            {
                type = indexingField.getType();
            }
        }
        else if (fieldPath.equals("title"))
        {
            // No specific content type: allow only title.
            type = ContentTypesHelper.getTitleMetadataDefinition().getType();
        }
        
        if (searchField == null)
        {
            searchField = type != null ? getMetadataSearchField(fieldPath, type, isTitleMultilingual(def)) : null;
        }
        
        return Optional.ofNullable(searchField);
    }
    
    /**
     * Get the search field from the indexing field and compute the join paths. Can be null if the last indexing field is a custom indexing field.
     * @param indexingField The initial indexing field
     * @param remainingPathSegments The path to access the metadata or an another indexing field from the initial indexing field
     * @param joinPaths The consecutive's path in case of joint to access the field/metadata
     * @param addLast <code>true</code> to add the last join path element to the list, <code>false</code> otherwise.
     * @return The search field or null if not found
     */
    protected SearchField _getSearchField(MetadataIndexingField indexingField, String[] remainingPathSegments, List<String> joinPaths, boolean addLast)
    {
        StringBuilder currentMetaPath = new StringBuilder();
        currentMetaPath.append(indexingField.getName());
        
        MetadataDefinition definition = indexingField.getMetadataDefinition();
        
        for (int i = 0; i < remainingPathSegments.length && definition != null; i++)
        {
            String currentPathSegment =  remainingPathSegments[i];
            if (definition.getType() == MetadataType.CONTENT || definition.getType() == MetadataType.SUB_CONTENT)
            {
                // Add path to content from current content type to join paths.
                // Join paths are the consecutive metadata paths (separated with '/') to access
                // the searched content, for instance [address/city, links/department].
                joinPaths.add(currentMetaPath.toString());
                
                String refCTypeId = definition.getContentType();
                if (refCTypeId != null)
                {
                    if (!_cTypeEP.hasExtension(refCTypeId))
                    {
                        throw new IllegalArgumentException("Search criterion with path '" + StringUtils.join(remainingPathSegments, ContentConstants.METADATA_PATH_SEPARATOR) + "' references an unknown content type:" + refCTypeId); 
                    }
                    
                    ContentType refCType = _cTypeEP.getExtension(refCTypeId);
                    IndexingModel refIndexingModel = refCType.getIndexingModel();
                    
                    IndexingField refIndexingField = refIndexingModel.getField(currentPathSegment);
                    if (refIndexingField == null && _sysPropEP.hasExtension(currentPathSegment))
                    {
                        SystemProperty sysProperty = _sysPropEP.getExtension(currentPathSegment);
                        return new JoinedSystemSearchField(joinPaths, sysProperty.getSearchField());
                    }
                    else if (refIndexingField == null)
                    {
                        throw new IllegalArgumentException("Search criterion with path '" + StringUtils.join(remainingPathSegments, ContentConstants.METADATA_PATH_SEPARATOR) + "' refers to an unknown indexing field: " + currentPathSegment);
                    }
                    
                    return _getSearchField((MetadataIndexingField) refIndexingField, ArrayUtils.subarray(remainingPathSegments, i + 1, remainingPathSegments.length), joinPaths, addLast);
                }
                else if ("title".equals(currentPathSegment))
                {
                    // No specific content type: allow only title.
                    return _getSearchField(ContentTypesHelper.getTitleMetadataDefinition(), joinPaths);
                }
            }
            else
            {
                if (definition instanceof RepeaterDefinition)
                {
                    // Add path to repeater from current content type or last repeater to join paths
                    joinPaths.add(currentMetaPath.toString());
                    currentMetaPath = new StringBuilder();
                    currentMetaPath.append(currentPathSegment);
                }
                else
                {
                    currentMetaPath.append(ContentConstants.METADATA_PATH_SEPARATOR).append(currentPathSegment);
                }
                definition = definition.getMetadataDefinition(currentPathSegment);
            }
        }
        
        if (addLast)
        {
            joinPaths.add(currentMetaPath.toString());
        }
        
        return _getSearchField(definition, joinPaths);
    }
    
    private SearchField _getSearchField(MetadataDefinition def, List<String> joinPaths)
    {
        MetadataType type = def.getType();
        
        String metadataPath = joinPaths.remove(joinPaths.size() - 1);
        return type != null ? getMetadataSearchField(joinPaths, metadataPath, type, isTitleMultilingual(def)) : null;
    }
    
    /**
     * Determines if the given metadata definition represents a CONTENT metadata with contents with multilingual titles
     * @param def The metadata definition
     * @return <code>true</code> if the given metadata definition represents a CONTENT metadata with contents with multilingual titles
     */
    public boolean isTitleMultilingual(MetadataDefinition def)
    {
        boolean isTitleMultilingual = Optional.ofNullable(def)
                .map(MetadataDefinition::getContentType)
                .map(_cTypeEP::getExtension)
                .map(cType -> cType.getMetadataDefinition(DefaultContent.METADATA_TITLE))
                .map(MetadataDefinition::getType)
                .map(MetadataType.MULTILINGUAL_STRING::equals)
                .orElse(false);
        return isTitleMultilingual;
    }
    
    /**
     * Get metadata values by their path
     * @param contentId The id of content
     * @param metadataPath The path of metadata to retrieve
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @return The metadata values
     */
    @Callable
    public Map<String, Object> getMetadataValues(String contentId, Collection<String> metadataPath, Locale defaultLocale)
    {
        Content content = _resolver.resolveById(contentId);
        return getMetadataValues(content, metadataPath, defaultLocale);
    }
    
    /**
     * Get metadata values by their path
     * @param content The initial content
     * @param metadataPaths The path of metadata to retrieve, slash-separated.
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @return The metadata values
     */
    public Map<String, Object> getMetadataValues(Content content, Collection<String> metadataPaths, Locale defaultLocale)
    {
        Map<String, Object> values = new HashMap<>();
        
        for (String path : metadataPaths)
        {
            Object value = getMetadataValue(content, path, defaultLocale);
            values.put(path, value);
        }
        
        return values;
    }
    
    /**
     * Get the value(s) of a metadata - transformed into JSONified value - of a content at given path.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * The returned value is typed.
     * @param content The content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @return The final value.
     */
    public Object getMetadataValue(Content content, String metadataPath, Locale defaultLocale)
    {
        return getMetadataValue(content, metadataPath, defaultLocale, false);
    }
    
    /**
     * Get the value(s) of a metadata - transformed into JSONified value - of a content at given path.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * @param content The content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @param resolveReferences <code>true</code> true to resolve references
     * @return The final value, tranformed for search.
     */
    public Object getMetadataValue(Content content, String metadataPath, Locale defaultLocale, boolean resolveReferences)
    {
        MetadataDefinition metadataDefinition = _contentTypesHelper.getMetadataDefinition(metadataPath, content);
        if (metadataDefinition != null && metadataDefinition instanceof RepeaterDefinition)
        {
            String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
            
            MetadataDefinition definition = _contentTypesHelper.getMetadataDefinition(pathSegments[0], content);
            if (definition != null)
            {
                return _getRepeaterValues(content, content.getMetadataHolder(), definition, "", metadataPath, defaultLocale, resolveReferences);
            }
            
            return null;
        }
        else
        {
            Object value = _contentHelper.getMetadataValue(content, metadataPath, defaultLocale, resolveReferences);
            return _transformValue(content, metadataPath, value, null, defaultLocale);
        }
    }
    
    /**
     * Get the value(s) of a metadata - transformed into JSONified value - of a content at given path.
     * The path can represent a path of a metadata into the content or a metadata on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/metadata'.
     * @param content The initial content.
     * @param fullMetadataPath The path to the metadata, separated by '/'
     * @param type The metadata type.
     * @param multiple <code>true</code> if the metadata is multiple.
     * @param enumerator The metadata enumerator. Can be null.
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @param full <code>true</code> to generate full representation of metadata's values : the references will be resolved and the label of enumerated values will be returned.
     * @return The final value, tranformed for search.
     */
    public Object getMetadataValue(Content content, String fullMetadataPath, MetadataType type, boolean multiple, Enumerator enumerator, Locale defaultLocale, boolean full)
    {
        // If full, extract content or resource values as Maps. If not, the values are kept as content/resources IDs.
        // If full, extract enumerated values as Maps of <key,label>. If not, the values are kept as entry IDs.
        
        MetadataDefinition metadataDefinition = _contentTypesHelper.getMetadataDefinition(fullMetadataPath, content);
        if (metadataDefinition != null && metadataDefinition instanceof RepeaterDefinition)
        {
            String[] pathSegments = fullMetadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
            MetadataDefinition definition = pathSegments.length > 1 ? _contentTypesHelper.getMetadataDefinition(pathSegments[0], content) : metadataDefinition;
            return _getRepeaterValues(content, content.getMetadataHolder(), definition, fullMetadataPath, fullMetadataPath, defaultLocale, full);
        }
        else
        {
            Object rawValue = _contentHelper.getMetadataValue(content, fullMetadataPath, defaultLocale, full);
            
            if (!multiple && rawValue instanceof Collection<?>)
            {
                if (((Collection<?>) rawValue).iterator().hasNext())
                {
                    rawValue = ((Collection<?>) rawValue).iterator().next();
                }
                else
                {
                    rawValue = null;
                }
            }
            
            return _transformValue(content, fullMetadataPath, rawValue, full ? enumerator : null, defaultLocale);
        }
    }

    /**
     * Transform the raw value into a JSONified value, understandable for search UI
     * @param content the content
     * @param metadataPath The path to the metadata, separated by '/'
     * @param rawValue The typed value
     * @param enumerator The enumerator. Can be null
     * @param defaultLocale Locale to use for localized values if content's language is null.
     * @return The transformed value
     */
    public Object _transformValue(Content content, String metadataPath, Object rawValue, Enumerator enumerator, Locale defaultLocale)
    {
        if (rawValue == null)
        {
            return null;
        }
        else if (rawValue instanceof Resource)
        {
            return _transformValue((Resource) rawValue);
        }
        else if (rawValue instanceof Content)
        {
            return _transformValue(content, (Content) rawValue, defaultLocale);
        }
        else if (rawValue instanceof UserIdentity)
        {
            return _transformValue((UserIdentity) rawValue);
        }
        else if (rawValue instanceof BinaryMetadata)
        {
            return _transformValue(content, metadataPath, (BinaryMetadata) rawValue);
        }
        else if (rawValue instanceof RichText)
        {
            return _transformValue((RichText) rawValue);
        }
        else if (rawValue instanceof MultilingualString)
        {
            return _transformValue((MultilingualString) rawValue);
        }
        else if (rawValue instanceof Collection<?>)
        {
            List<Object> tranformedValues = new ArrayList<>();
            for (Object object : (Collection<?>) rawValue)
            {
                tranformedValues.add(_transformValue(content, metadataPath, object, enumerator, defaultLocale));
            }
            return tranformedValues;
        }
        else if (rawValue instanceof Date)
        {
            return DateUtils.dateToString((Date) rawValue);
        }
        else if (enumerator != null)
        {
            Map<String, Object> tranformedValue = new HashMap<>();
            tranformedValue.put("value", rawValue);
            
            try
            {
                tranformedValue.put("label", enumerator.getEntry(rawValue.toString()));
            }
            catch (Exception e)
            {
                tranformedValue.put("label", rawValue);
            }
            
            return tranformedValue;
        }
        else
        {
            return rawValue;
        }
    }
    
    private Object _transformValue(Resource resource)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("type", "explorer");
        info.put("id", resource.getId());
        info.put("filename", resource.getName());
        info.put("mime-type", resource.getMimeType());
        info.put("size", resource.getLength());
        info.put("lastModified", resource.getLastModified());
        info.put("viewUrl", ResolveURIComponent.resolve("explorer", resource.getId(), false));
        info.put("downloadUrl", ResolveURIComponent.resolve("explorer", resource.getId(), true));
        
        return info;
    }
    
    private Object _transformValue(Content content, Content value, Locale defaultLocale)
    {
        Map<String, Object> info = new HashMap<>();
        
        Locale locale = content.getLanguage() != null ? new Locale(content.getLanguage()) : defaultLocale;
        info.put("id", value.getId());
        info.put("title", value.getTitle(locale));
        info.put("isSimple", _contentHelper.isSimple(value));
        
        return info;
    }
    
    private Object _transformValue(UserIdentity user)
    {
        return _userHelper.user2json(user, true);
    }
    
    private Object _transformValue(MultilingualString multilingualString)
    {
        return MultilingualStringHelper.toJson(multilingualString);
    }
    
    private Object _transformValue(Content content, String metadataPath, BinaryMetadata binary)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("type", "metadata");
        info.put("id", EditContentFunction.UNTOUCHED_BINARY);
        info.put("mime-type", binary.getMimeType());
        info.put("filename", binary.getFilename());
        info.put("size", binary.getLength());
        info.put("lastModified", binary.getLastModified());
        info.put("viewUrl", ResolveURIComponent.resolve("metadata", metadataPath + "?objectId=" + content.getId(), false));
        info.put("downloadUrl", ResolveURIComponent.resolve("metadata", metadataPath + "?objectId=" + content.getId(), true));
        
        return info;
    }
    
    private Object _transformValue(RichText richText)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("type", "metadata");
        info.put("mime-type", richText.getMimeType());
        info.put("size", richText.getLength());
        info.put("lastModified", richText.getLastModified());

        SAXParser saxParser = null;
        try (InputStream is = richText.getInputStream())
        {
            RichTextHandler txtHandler = new RichTextHandler(100);
            saxParser = (SAXParser) _manager.lookup(SAXParser.ROLE);
            saxParser.parse(new InputSource(is), txtHandler);
            
            String excerpt = txtHandler.getValue();
            info.put("content", excerpt);
        }
        catch (Exception e)
        {
            getLogger().error("Cannot extract excerpt of a RichText value ", e);
            info.put("content", "");
        }
        finally
        {
            _manager.release(saxParser);
        }
        
        return info;
    }
       
    private Object _getRepeaterValues(Content content, CompositeMetadata metadataHolder, MetadataDefinition definition, String prefix, String metadataPath, Locale defaultLocale, boolean resolveReferences)
    {
        String[] pathSegments = metadataPath.split(ContentConstants.METADATA_PATH_SEPARATOR);
        
        String metadataName = pathSegments[0];
        
        if (!metadataHolder.hasMetadata(metadataName) || definition == null)
        {
            return null;
        }
        
        MetadataType type = definition.getType();
        switch (type)
        {
            case COMPOSITE:
                return _getCompositeRepeaterValues(content, metadataHolder, definition, defaultLocale, resolveReferences, pathSegments, prefix, metadataName);
            
            case CONTENT:
                return _getContentRepeaterValues(content, metadataHolder, definition, metadataPath, defaultLocale, resolveReferences, pathSegments, metadataName);
                
            default:
                if (pathSegments.length == 1)
                {
                    Locale locale = content.getLanguage() != null ? new Locale(content.getLanguage()) : defaultLocale; 
                    Object rawValue = _contentHelper.getSimpleMetadataValue(metadataHolder, definition, metadataName, locale, resolveReferences);
                    return _transformValue(content, prefix + ContentConstants.METADATA_PATH_SEPARATOR + metadataPath, rawValue, null, defaultLocale);
                }
                
                throw new IllegalArgumentException("Metadata at path '" + definition.getId() + "' is a simple metadata : can not invoked get sub metadata values at path " + StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length));
        }
        
    }

    private Object _getContentRepeaterValues(Content content, CompositeMetadata metadataHolder, MetadataDefinition definition, String metadataPath, Locale defaultLocale,
            boolean resolveReferences, String[] pathSegments, String metadataName)
    {
        if (pathSegments.length > 1)
        {
            if (definition.isMultiple())
            {
                List<Object> values = new ArrayList<>();
                String[] refContentIds = metadataHolder.getStringArray(metadataName, new String[0]);
                for (String refContentId : refContentIds)
                {
                    Content refContent = _resolver.resolveById(refContentId);
                    Object remoteValue = getMetadataValue(refContent, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), defaultLocale, resolveReferences);
                    if (remoteValue != null && remoteValue instanceof Collection<?>)
                    {
                        values.addAll((Collection<?>) remoteValue);
                    }
                    else if (remoteValue != null)
                    {
                        values.add(remoteValue);
                    }
                }
                return values;
            }
            else
            {
                String refContentId = metadataHolder.getString(metadataName);
                Content refContent = _resolver.resolveById(refContentId);
                Object rawValue = getMetadataValue(refContent, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), defaultLocale, resolveReferences);
                return _transformValue(content, metadataPath, rawValue, null, defaultLocale);
            }   
        }
        else
        {
            Object rawValue = _contentHelper.getSimpleMetadataValue(metadataHolder, definition, metadataName, defaultLocale, resolveReferences);
            return _transformValue(content, metadataPath, rawValue, null, defaultLocale);
        }
    }

    private Object _getCompositeRepeaterValues(Content content, CompositeMetadata metadataHolder, MetadataDefinition definition, Locale locale, boolean resolveReferences, String[] pathSegments, String prefix, String metadataName)
    {
        if (definition instanceof RepeaterDefinition)
        {
            return _getRepeaterRepeaterValue(content, metadataHolder, definition, locale, resolveReferences, pathSegments, prefix, metadataName);
        }
        else
        {
            // Composite.
            CompositeMetadata subMetadataHolder = metadataHolder.getCompositeMetadata(metadataName);
            if (pathSegments.length > 1)
            {
                MetadataDefinition subMetadataDef = definition.getMetadataDefinition(pathSegments[1]);
                return _getRepeaterValues(content, subMetadataHolder, subMetadataDef, prefix, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences);
            }
            else
            {
                Map<String, Object> values = new HashMap<>();
                for (String subMetadataName : subMetadataHolder.getMetadataNames())
                {
                    MetadataDefinition submetadataDefinition = definition.getMetadataDefinition(subMetadataName);
                    Object entryValue = _getRepeaterValues(content, subMetadataHolder, submetadataDefinition, prefix, subMetadataName, locale, resolveReferences);
                    if (entryValue != null)
                    {
                        if (submetadataDefinition != null && submetadataDefinition.getType().equals(MetadataType.COMPOSITE) && !(submetadataDefinition instanceof RepeaterDefinition) && entryValue instanceof Map)
                        {
                            // add and prefix each entry of the composite
                            @SuppressWarnings("unchecked")
                            Map<String, Object> map = (Map<String, Object>) entryValue;
                            values.putAll(map.entrySet().stream().collect(Collectors.toMap(e -> metadataName + ContentConstants.METADATA_PATH_SEPARATOR + e.getKey(), e -> e.getValue())));
                        }
                        else
                        {
                            values.put(metadataName + ContentConstants.METADATA_PATH_SEPARATOR + subMetadataName, entryValue);
                        }
                    }
                }
                return values;
            }
        }
    }

    @SuppressWarnings("unchecked")
    private Object _getRepeaterRepeaterValue(Content content, CompositeMetadata metadataHolder, MetadataDefinition definition, Locale locale, boolean resolveReferences, String[] pathSegments, String prefix, String metadataName)
    {
        // Repeater: get and sort the entry names.
        CompositeMetadata repeater = metadataHolder.getCompositeMetadata(metadataName);
        String[] entries = repeater.getMetadataNames();
        Arrays.sort(entries, MetadataManager.REPEATER_ENTRY_COMPARATOR);
        
        
        if (pathSegments.length > 1)
        {
            Map<String, Object> values = new HashMap<>();
            for (String entryName : entries)
            {
                CompositeMetadata entry = repeater.getCompositeMetadata(entryName);
                
                Object entryValue = _getRepeaterValues(content, entry, definition.getMetadataDefinition(pathSegments[1]), prefix + ContentConstants.METADATA_PATH_SEPARATOR + entryName, StringUtils.join(pathSegments, ContentConstants.METADATA_PATH_SEPARATOR, 1, pathSegments.length), locale, resolveReferences);
                if (entryValue != null)
                {
                    values.put(_i18nUtils.translate(((RepeaterDefinition) definition).getLabel(), locale.getLanguage()), entryValue);
                }
            }
            
            return values;
        }
        else
        {
            List<Map<String, Object>> values = new LinkedList<>();
            
            int i = 0;
            for (String entryName : entries)
            {
                i++;
                CompositeMetadata entry = repeater.getCompositeMetadata(entryName);
                
                Map<String, Object> compositeValues = new HashMap<>();
                for (String subMetadataName : entry.getMetadataNames())
                {
                    MetadataDefinition submetadataDefinition = definition.getMetadataDefinition(subMetadataName);
                    Object entryValue = _getRepeaterValues(content, entry, submetadataDefinition, prefix + ContentConstants.METADATA_PATH_SEPARATOR + entryName, subMetadataName, locale, resolveReferences);
                    if (entryValue != null)
                    {
                        if (submetadataDefinition != null && submetadataDefinition.getType().equals(MetadataType.COMPOSITE) && !(submetadataDefinition instanceof RepeaterDefinition) && entryValue instanceof Map)
                        {
                            // if submetadata was a composite, add all composite child as a flat list of values 
                            compositeValues.putAll((Map< ? extends String, ? extends Object>) entryValue);
                        }
                        else
                        {
                            compositeValues.put(subMetadataName, entryValue);
                        }
                    }
                }
                
                Map<String, Object> repeaterValues = new HashMap<>();
                repeaterValues.put("label", ((RepeaterDefinition) definition).getLabel());
                repeaterValues.put("position", i);
                repeaterValues.put("values", compositeValues);
                String headerLabel = ((RepeaterDefinition) definition).getHeaderLabel();
                if (headerLabel != null)
                {
                    repeaterValues.put("header-label", headerLabel);
                }
                values.add(repeaterValues);
            }
            
            return values;
        }
    }
}