/*
 *  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.lang.reflect.Array;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.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.ContentAttributeDefinition;
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.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.data.Binary;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.ExplorerFile;
import org.ametys.cms.data.File;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.repository.Content;
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.plugins.core.user.UserHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.impl.ModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.impl.ModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.impl.ModelAwareRepeaterEntry;
import org.ametys.plugins.repository.metadata.MultilingualString;
import org.ametys.plugins.repository.metadata.MultilingualStringHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemType;
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;

    /** 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);
    }
    
    /**
     * 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:
            case REFERENCE:
                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:
            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, ModelItem.ITEM_PATH_SEPARATOR);
        String fieldName = pathSegments[0];
        
        // System property ?
        if (_sysPropEP.hasExtension(fieldName) && pathSegments.length == 1)
        {
            return Optional.ofNullable(_sysPropEP.getExtension(fieldName).getSearchField());
        }
        
        Set<String> commonContentTypeIds = _cTypeHelper.getCommonAncestors(contentTypes);
        
        MetadataType type = null;
        MetadataDefinition def = null;
        
        
        if (!commonContentTypeIds.isEmpty())
        {
            IndexingField indexingField = null;
            Iterator<String> commonContentTypeIdsIt = commonContentTypeIds.iterator();
            while (commonContentTypeIdsIt.hasNext() && indexingField == null)
            {
                ContentType cType = _cTypeEP.getExtension(commonContentTypeIdsIt.next());
                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(Content.ATTRIBUTE_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, ModelItem.ITEM_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, ModelItem.ITEM_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(ModelItem.ITEM_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(Content.ATTRIBUTE_TITLE))
                .map(MetadataDefinition::getType)
                .map(MetadataType.MULTILINGUAL_STRING::equals)
                .orElse(false);
        return isTitleMultilingual;
    }
    
    /**
     * Determines if the given metadata definition represents a CONTENT metadata with contents with multilingual titles
     * @param modelItem The metadata definition
     * @return <code>true</code> if the given metadata definition represents a CONTENT metadata with contents with multilingual titles
     */
    public boolean isTitleMultilingual(ModelItem modelItem)
    {
        return Optional.ofNullable(modelItem)
                .filter(ContentAttributeDefinition.class::isInstance)
                .map(ContentAttributeDefinition.class::cast)
                .map(ContentAttributeDefinition::getContentTypeId)
                .map(_cTypeEP::getExtension)
                .filter(cType -> cType.hasModelItem(Content.ATTRIBUTE_TITLE))
                .map(cType -> cType.getModelItem(Content.ATTRIBUTE_TITLE))
                .map(ModelItem::getType)
                .map(ModelItemType::getId)
                .map(ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID::equals)
                .orElse(false);
    }
    
    /**
     * 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> getAttributeValues(String contentId, Collection<String> metadataPath, Locale defaultLocale)
    {
        Content content = _resolver.resolveById(contentId);
        return getAttributeValues(content, metadataPath, defaultLocale);
    }
    
    /**
     * Get metadata values by their path
     * @param content The initial content
     * @param dataPaths 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> getAttributeValues(Content content, Collection<String> dataPaths, Locale defaultLocale)
    {
        Map<String, Object> values = new HashMap<>();
        
        for (String path : dataPaths)
        {
            Object value = getAttributeValue(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 dataPath 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 getAttributeValue(Content content, String dataPath, Locale defaultLocale)
    {
        return getAttributeValue(content, dataPath, 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 dataPath 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, transformed for search.
     */
    public Object getAttributeValue(Content content, String dataPath, Locale defaultLocale, boolean resolveReferences)
    {
        ModelItem modelItem = content.getDefinition(dataPath);
        return getAttributeValue(content, dataPath, modelItem, defaultLocale, resolveReferences);
    }
    
    /**
     * Get the value(s) of an attribute - transformed into JSONified value - of a content at given path.
     * The path can represent a path of an attribute into the content or an attribute on one or more linked contents, such as 'composite/linkedContent/secondContent/composite/attribute'.
     * @param content The initial content.
     * @param dataPath The path to the attribute, separated by '/'
     * @param modelItem The attribute definition.
     * @param defaultLocale The default locale to resolve multilingual values if the content's language is null. Can be null.
     * @param resolveReferences <code>true</code> to generate full representation of attribute's values : the references will be resolved and the label of enumerated values will be returned.
     * @return The final value, transformed for search.
     */
    public Object getAttributeValue(Content content, String dataPath, ModelItem modelItem, Locale defaultLocale, boolean resolveReferences)
    {
        Locale locale = content.getLanguage() != null ? new Locale(content.getLanguage()) : defaultLocale;
        if (modelItem instanceof ElementDefinition)
        {
            // Get attribute's values allowing multi-valued path segments inside the data path (not necessarily at the last segment)
            Object rawValues = content.getValue(dataPath, true);
            
            // 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.
            return _transformValue(content, (ElementDefinition) modelItem, rawValues, locale, resolveReferences);
        }
        else if (modelItem instanceof org.ametys.plugins.repository.model.RepeaterDefinition)
        {
            Object repeater = content.getValue(dataPath, true);
            return _getRepeaterValues(content, (org.ametys.plugins.repository.model.RepeaterDefinition) modelItem, repeater, locale, resolveReferences);
        }
        else
        {
            throw new IllegalArgumentException();
        }
    }
    
    @SuppressWarnings("unchecked")
    private Map<String, Object> _getRepeaterValues(Content content, org.ametys.plugins.repository.model.RepeaterDefinition repeaterDefinition, Object repeater, Locale locale, boolean full)
    {
        if (repeater == null)
        {
            return null;
        }
        
        if (repeater instanceof ModelAwareRepeater[])
        {
            I18nizableText label = null;
            String headerLabel = null;
            List<Object> entries = new ArrayList<>();

            for (ModelAwareRepeater singleRepeater : (ModelAwareRepeater[]) repeater)
            {
                Map<String, Object> singleRepeaterValues = _getSingleRepeaterValues(content, repeaterDefinition, singleRepeater, locale, full);
                if (singleRepeaterValues != null)
                {
                    entries.addAll((List<Object>) singleRepeaterValues.get("entries"));
                    label = (I18nizableText) singleRepeaterValues.get("label");
                    headerLabel = (String) singleRepeaterValues.get("header-label");
                }
            }

            Map<String, Object> repeaterValues = new HashMap<>();
            repeaterValues.put("entries", entries);
            repeaterValues.put("label",  label);
            
            if (headerLabel != null)
            {
                repeaterValues.put("header-label", headerLabel);
            }

            return repeaterValues;
        }
        
        return _getSingleRepeaterValues(content, repeaterDefinition, (ModelAwareRepeater) repeater, locale, full);
    }
    
    private Map<String, Object> _getSingleRepeaterValues(Content content, org.ametys.plugins.repository.model.RepeaterDefinition repeaterDefinition, ModelAwareRepeater repeater, Locale locale, boolean full)
    {
        List<Map<String, Object>> entriesValues = new ArrayList<>();
        
        for (ModelAwareRepeaterEntry entry : repeater.getEntries())
        {
            Map<String, Object> values = new HashMap<>();
            for (String dataName : entry.getDataNames())
            {
                values.putAll(_getDataHolderValues(content, entry, dataName, dataName, locale, full));
            }
                
            Map<String, Object> entryValues = new HashMap<>();
            entryValues.put("position", entry.getPosition());
            entryValues.put("values", values);

            entriesValues.add(entryValues);
        }
        
        Map<String, Object> repeaterValues = new HashMap<>();
        repeaterValues.put("entries", entriesValues);
        repeaterValues.put("label", repeaterDefinition.getLabel());
        String headerLabel = repeaterDefinition.getHeaderLabel();
        if (headerLabel != null)
        {
            repeaterValues.put("header-label", headerLabel);
        }
        
        return repeaterValues;
    }
    
    private Map<String, Object> _getCompositeValues(Content content, ModelAwareComposite composite, String prefix, Locale locale, boolean full)
    {
        Map<String, Object> compositeValues = new HashMap<>();
        
        for (String dataName : composite.getDataNames())
        {
            String dataAbsolutePathFromFirstRepeater = prefix + ModelItem.ITEM_PATH_SEPARATOR + dataName;
            compositeValues.putAll(_getDataHolderValues(content, composite, dataName, dataAbsolutePathFromFirstRepeater, locale, full));
        }
        
        return compositeValues;
    }
    
    private Map<String, Object> _getDataHolderValues(Content content, ModelAwareDataHolder dataHolder, String dataName, String dataAbsolutePathFromFirstRepeater, Locale locale, boolean full)
    {
        Map<String, Object> values = new HashMap<>();
        
        ModelItem modelItem = dataHolder.getDefinition(dataName);
        if (modelItem instanceof ElementDefinition)
        {
            Object value = dataHolder.getValue(dataName);
            Object transformedValue = _transformValue(content, (ElementDefinition) modelItem, value, locale, full);
            values.put(dataAbsolutePathFromFirstRepeater, transformedValue);
        }
        else if (modelItem instanceof org.ametys.plugins.repository.model.RepeaterDefinition)
        {
            ModelAwareRepeater subRepeater = dataHolder.getRepeater(dataName);
            Map<String, Object> subRepeaterValues = _getSingleRepeaterValues(content, (org.ametys.plugins.repository.model.RepeaterDefinition) modelItem, subRepeater, locale, full);
            values.put(dataAbsolutePathFromFirstRepeater, subRepeaterValues);
        }
        else
        {
            ModelAwareComposite subComposite = dataHolder.getComposite(dataName);
            Map<String, Object> subCompositeValues = _getCompositeValues(content, subComposite, dataAbsolutePathFromFirstRepeater, locale, full);
            values.putAll(subCompositeValues);
        }
        
        return values;
    }
    
    /**
     * Transform the raw value into a JSONified value, understandable for search UI
     * @param content the content
     * @param definition definition of the attribute to transform
     * @param value The typed values to transform
     * @param locale Locale to use for localized values if content's language is null.
     * @param resolveReferences <code>true</code> to generate full representation of attribute's values
     * @return The transformed values
     */
    private Object _transformValue(Content content, ElementDefinition definition, Object value, Locale locale, boolean resolveReferences)
    {
        if (value == null)
        {
            return null;
        }
        
        if (value.getClass().isArray())
        {
            List<Object> transformedValues = new ArrayList<>();
            for (int i = 0; i < Array.getLength(value); i++)
            {
                Object singleValue = Array.get(value, i);
                Object transformedSingleValue = _transformValue(content, definition, singleValue, locale, resolveReferences);
                transformedValues.add(transformedSingleValue);
            }
            return transformedValues;
        }

        Object valueAsJSON = _transformSingleValue(content, definition, value, locale, resolveReferences);
            
        org.ametys.runtime.model.Enumerator enumerator = definition.getEnumerator();
        if (resolveReferences && enumerator != null)
        {
            Map<String, Object> transformedValue = new HashMap<>();
            transformedValue.put("value", valueAsJSON);
            
            try
            {
                @SuppressWarnings("unchecked")
                I18nizableText label = enumerator.getEntry(value);
                transformedValue.put("label", label);
            }
            catch (Exception e)
            {
                transformedValue.put("label", valueAsJSON);
            }
            
            return transformedValue;
        }
        else
        {
            return valueAsJSON;
        }
    }

    @SuppressWarnings("unchecked")
    private Object _transformSingleValue(Content content, ElementDefinition definition, Object value, Locale locale, boolean resolveReferences)
    {
        ElementType type = definition.getType();

        switch (type.getId())
        {
            case ModelItemTypeConstants.CONTENT_ELEMENT_TYPE_ID:
                return _transformValue((ContentValue) value, locale, resolveReferences);
            case ModelItemTypeConstants.FILE_ELEMENT_TYPE_ID:
                return value instanceof ExplorerFile ? _transformValue((ExplorerFile) value, resolveReferences) : _transformValue((Binary) value, definition.getPath(), content.getId());
            case ModelItemTypeConstants.BINARY_ELEMENT_TYPE_ID:
                return _transformValue((Binary) value, definition.getPath(), content.getId());
            case ModelItemTypeConstants.RICH_TEXT_ELEMENT_TYPE_ID:
                return _transformValue((org.ametys.cms.data.RichText) value);
            case org.ametys.runtime.model.type.ModelItemTypeConstants.DATE_TYPE_ID:
                return _transformValue((LocalDate) value);
            case org.ametys.runtime.model.type.ModelItemTypeConstants.DATETIME_TYPE_ID:
                return _transformValue((ZonedDateTime) value);
            case ModelItemTypeConstants.USER_ELEMENT_TYPE_ID:
                return _transformValue((UserIdentity) value);
            case ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID:
                return _transformValue((MultilingualString) value, type, locale, resolveReferences);
            default:
                return type.valueToJSONForClient(value);
        }
    }
    
    private Object _transformValue(ContentValue contentValue, Locale locale, boolean resolveReferences)
    {
        if (resolveReferences)
        {
            Map<String, Object> info = new HashMap<>();
            info.put("id", contentValue.getContentId());

            Optional<? extends Content> optionalContent = contentValue.getContentIfExists();
            if (!optionalContent.isEmpty())
            {
                Content value = optionalContent.get();
                info.put("title", value.getTitle(locale));
                info.put("isSimple", _contentHelper.isSimple(value));
            }
            
            return info;
        }
        else
        {
            return contentValue.getContentId();
        }
    }
    
    private Object _transformValue(ExplorerFile file, boolean resolveReferences)
    {
        
        if (resolveReferences)
        {
            Map<String, Object> info = new HashMap<>();
            
            info.put("type", "explorer");
            info.put("id", file.getResourceId());
            info.put("viewUrl", ResolveURIComponent.resolve("explorer", file.getResourceId(), false));
            info.put("downloadUrl", ResolveURIComponent.resolve("explorer", file.getResourceId(), true));
            
            info.putAll(_getFileTransformedInfo(file));

            return info;
        }
        else
        {
            return file.getResourceId();
        }
        
    }
    
    private Map<String, Object> _transformValue(Binary binary, String attributePath, String contentId)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("type", "metadata");
        info.put("id", EditContentFunction.UNTOUCHED_BINARY);
        info.put("viewUrl", ResolveURIComponent.resolve("metadata", attributePath + "?objectId=" + contentId, false));
        info.put("downloadUrl", ResolveURIComponent.resolve("metadata", attributePath + "?objectId=" + contentId, true));
        
        info.putAll(_getFileTransformedInfo(binary));
        
        return info;
    }
    
    private Map<String, Object> _getFileTransformedInfo(File file)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("filename", file.getName());
        info.put("mime-type", file.getMimeType());
        info.put("size", file.getLength());
        info.put("lastModified", file.getLastModificationDate());
        
        return info;
    }
    
    private Map<String, Object> _transformValue(org.ametys.cms.data.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.getLastModificationDate());

        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 String _transformValue(LocalDate date)
    {
        ZonedDateTime zdt = date.atStartOfDay(ZoneId.systemDefault());
        return _transformValue(zdt);
    }
    
    private String _transformValue(ZonedDateTime dateTime)
    {
        return DateUtils.zonedDateTimeToString(dateTime);
    }
    
    private Object _transformValue(UserIdentity user)
    {
        return _userHelper.user2json(user, true);
    }
    
    private Object _transformValue(MultilingualString multilingualString, ElementType<MultilingualString> type, Locale locale, boolean resolveReferences)
    {
        return resolveReferences ? type.valueToJSONForClient(multilingualString) : MultilingualStringHelper.getValue(multilingualString, locale);
    }
    
}