/*
 *  Copyright 2013 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.ui.model.impl;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
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.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

import org.ametys.cms.contenttype.ContentConstants;
import org.ametys.cms.contenttype.ContentType;
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.IndexingField;
import org.ametys.cms.contenttype.indexing.IndexingModel;
import org.ametys.cms.contenttype.indexing.MetadataIndexingField;
import org.ametys.cms.search.SearchField;
import org.ametys.cms.search.content.ContentSearchHelper;
import org.ametys.cms.search.model.IndexingFieldSearchCriterion;
import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.BooleanQuery;
import org.ametys.cms.search.query.DateQuery;
import org.ametys.cms.search.query.DoubleQuery;
import org.ametys.cms.search.query.JoinQuery;
import org.ametys.cms.search.query.LongQuery;
import org.ametys.cms.search.query.OrQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.query.StringQuery;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.Enumerator;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.parameter.ParameterHelper.ParameterType;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.LogEnabled;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * This class is a search criteria on a metadata of a content
 */
public class IndexingFieldSearchUICriterion extends AbstractSearchUICriterion implements IndexingFieldSearchCriterion, Contextualizable, LogEnabled, Disposable
{
    
    /** Prefix for id of metadata search criteria */
    public static final String SEARCH_CRITERIA_METADATA_PREFIX = "metadata-";
    
    /** The content search helper. */
    protected ContentSearchHelper _searchHelper;
    
    /** The criteria operator */
    protected Operator _operator;
    
    /** The field full path */
    protected String _fullPath;
    
    /** The field path */
    protected String _fieldPath;
    
    /** The join paths */
    protected List<String> _joinPaths;
    
    /** Is it AND or OR for multiple metadata */
    protected boolean _isMultipleOperandAnd;
    
    /** The ID of the content type which contains the metadata. */
    protected String _contentTypeId;
    
    /** ComponentManager for {@link Validator}s. */
    protected ThreadSafeComponentManager<Validator> _validatorManager;
    /** ComponentManager for {@link Enumerator}s. */
    protected ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    private ServiceManager _manager;
    private Logger _logger;
    private Context _context;
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void setLogger(Logger logger)
    {
        _logger = logger;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _manager = manager;
        _searchHelper = (ContentSearchHelper) manager.lookup(ContentSearchHelper.ROLE);
    }
    
    @Override
    public void dispose()
    {
        _validatorManager.dispose();
        _validatorManager = null;
        _enumeratorManager.dispose();
        _enumeratorManager = null;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        try
        {
            _validatorManager = new ThreadSafeComponentManager<>();
            _validatorManager.setLogger(_logger);
            _validatorManager.contextualize(_context);
            _validatorManager.service(_manager);
            
            _enumeratorManager = new ThreadSafeComponentManager<>();
            _enumeratorManager.setLogger(_logger);
            _enumeratorManager.contextualize(_context);
            _enumeratorManager.service(_manager);
            
            _fullPath = configuration.getChild("field").getAttribute("path");
            _contentTypeId = configuration.getChild("contentTypes").getAttribute("baseId", null);
            
            _operator = Operator.fromName(configuration.getChild("test-operator").getValue("eq"));
            
            _isMultipleOperandAnd = StringUtils.equalsIgnoreCase(configuration.getChild("multiple-operand").getValue("or"), "or") ? false : true;
            
            String id = SEARCH_CRITERIA_METADATA_PREFIX + _fullPath + "-" + _operator.getName();
            
            String[] pathSegments = StringUtils.split(_fullPath, ContentConstants.METADATA_PATH_SEPARATOR);
            String fieldName = pathSegments[0];
            
            IndexingField indexingField = null;
            if (_contentTypeId != null)
            {
                ContentType cType = _cTypeEP.getExtension(_contentTypeId);
                IndexingModel indexingModel = cType.getIndexingModel();
                indexingField = indexingModel.getField(fieldName);
            }
            else if ("title".equals(_fullPath))
            {
                // Only the title indexing field is allowed if the base content type is null.
                indexingField = _searchHelper.getTitleMetadataIndexingField();
            }
            else
            {
                throw new ConfigurationException("The indexing field '" + _fullPath + "' is forbidden when no content type is specified: only title can be used.");
            }
            
            if (indexingField == null)
            {
                throw new ConfigurationException("Indexing field search criteria with path '" + _fullPath + "' refers to an unknown indexing field: " + fieldName);
            }
            
            _joinPaths = new ArrayList<>();
            
            String[] remainingPathSegments = pathSegments.length > 1 ? (String[]) ArrayUtils.subarray(pathSegments, 1, pathSegments.length) : new String[0];
            
            MetadataDefinition finalDefinition = getMetadataDefinition(indexingField, remainingPathSegments, _joinPaths);
            _fieldPath = getFieldPath(indexingField, remainingPathSegments);
            
            setId(id);
            setGroup(_configureI18nizableText(configuration.getChild("group", false), null));
            _configureLabel(configuration, indexingField, fieldName, finalDefinition);
            _configureDescription(configuration, indexingField, fieldName, finalDefinition);
            
            if (finalDefinition != null)
            {
                MetadataType type = finalDefinition.getType();
                setType(type);
    //            setValidator(finalDefinition.getValidator());
                
                String validatorRole = "validator";
                if (!_initializeValidator(_validatorManager, "cms", validatorRole, configuration))
                {
                    validatorRole = null;
                }
                
                setEnumerator(finalDefinition.getEnumerator());
                
                String defaultWidget = finalDefinition.getWidget();
                if ("edition.textarea".equals(defaultWidget))
                {
                    defaultWidget = null;
                }
                else if (type == MetadataType.RICH_TEXT)
                {
                    defaultWidget = "edition.textfield";
                }
                else if (type == MetadataType.BOOLEAN)
                {
                    defaultWidget = "edition.boolean-combobox";
                }
                
                setWidget(configuration.getChild("widget").getValue(defaultWidget));
                setWidgetParameters(_configureWidgetParameters(configuration.getChild("widget-params", false), finalDefinition.getWidgetParameters()));
                setMultiple(finalDefinition.isMultiple());
                
                if (finalDefinition.getType() == MetadataType.CONTENT || finalDefinition.getType() == MetadataType.SUB_CONTENT)
                {
                    setContentTypeId(finalDefinition.getContentType());
                    
                    Map<String, I18nizableText> widgetParameters = new HashMap<>(finalDefinition.getWidgetParameters());
                    // Override the widget parameters to disable search and creation
                    widgetParameters.put("allowCreation", new I18nizableText("false"));
                    widgetParameters.put("allowSearch", new I18nizableText("false"));
                    setWidgetParameters(widgetParameters);
                }
            }
            
            _configureOperator(configuration, finalDefinition);
            
            configureUIProperties(configuration);
            configureValues(configuration);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Error configuring the indexing field search criterion.", configuration, e);
        }
    }
    
    /**
     * Get the operator.
     * @return the operator.
     */
    public Operator getOperator()
    {
        return _operator;
    }
    
    public String getFieldId()
    {
        return SEARCH_CRITERIA_METADATA_PREFIX + _fullPath;
    }
    
    /**
     * Get the path of field (separated by '/')
     * @return the path of the field.
     */
    public String getFieldPath()
    {
        return _fieldPath;
    }
    
    /**
     * Get the join paths, separated with slashes.
     * @return the join paths.
     */
    public List<String> getJoinPaths()
    {
        return Collections.unmodifiableList(_joinPaths);
    }
    
    @Override
    public Query getQuery(Object value, Operator customOperator, Map<String, Object> allValues, String language, Map<String, Object> contextualParameters)
    {
        String fieldPath = getFieldPath();
        List<String> joinPaths = getJoinPaths();
        Operator operator = customOperator != null ? customOperator : getOperator();
        
        if (operator != Operator.EXISTS && isEmpty(value))
        {
            return null;
        }
        
        Query query = null;
        switch (getType())
        {
            case DATE:
            case DATETIME:
                query = getDateQuery(value, fieldPath, operator);
                break;
            case LONG:
                query = getLongQuery(value, fieldPath, operator);
                break;
            case DOUBLE:
                query = getDoubleQuery(value, fieldPath, operator);
                break;
            case BOOLEAN:
                query = getBooleanQuery(value, fieldPath, operator);
                break;
            case STRING:
            case RICH_TEXT:
            case USER:
                query = getStringQuery(value, language, fieldPath, operator);
                break;
            case CONTENT:
                query = getContentQuery(value, language, fieldPath, operator);
                break;
            default:
                return null;
        }
        
        if (query != null && !joinPaths.isEmpty())
        {
            query = new JoinQuery(query, joinPaths);
        }
        
        return query;
    }

    private static boolean isEmpty(Object value)
    {
        return value == null
            || (value instanceof String && ((String) value).length() == 0)
            || (value instanceof List && ((List) value).isEmpty());
    }
    
    /**
     * Get a string query.
     * @param value The value to use for this criterion.
     * @param language The search language.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getStringQuery(Object value, String language, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new StringQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            Collection<Object> values = (Collection<Object>) value;
            
            List<Query> queries = new ArrayList<>();
            for (Object val : values)
            {
                queries.add(getStringQuery(val, language, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else if (operator.equals(Operator.LIKE))
        {
            String stringValue = (String) ParameterHelper.castValue((String) value, ParameterType.STRING);
            
            if (StringUtils.isNotEmpty(stringValue))
            {
                return new StringQuery(fieldPath, operator, stringValue, language);
            }
            
            return null;
        }
        else
        {
            String stringValue = (String) ParameterHelper.castValue((String) value, ParameterType.STRING);
            return new StringQuery(fieldPath, operator, stringValue, language);
        }
    }
    
    /**
     * Get a boolean query.
     * @param value The value to use for this criterion.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getBooleanQuery(Object value, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new BooleanQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            Collection<Object> values = (Collection<Object>) value;
            
            List<Query> queries = new ArrayList<>();
            for (Object val : values)
            {
                queries.add(getBooleanQuery(val, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else if (value instanceof String)
        {
            Boolean boolValue = (Boolean) ParameterHelper.castValue((String) value, ParameterType.BOOLEAN);
            return new BooleanQuery(fieldPath, boolValue);
        }
        else
        {
            return new BooleanQuery(fieldPath, (Boolean) value);
        }
    }
    
    /**
     * Get a double query.
     * @param value The value to use for this criterion.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getDoubleQuery(Object value, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new DoubleQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            Collection<Object> values = (Collection<Object>) value;
            
            List<Query> queries = new ArrayList<>();
            for (Object val : values)
            {
                queries.add(getDoubleQuery(val, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else if (value instanceof String)
        {
            Double doubleValue = (Double) ParameterHelper.castValue((String) value, ParameterType.DOUBLE);
            return new DoubleQuery(fieldPath, operator, doubleValue);
        }
        else if (value instanceof Integer)
        {
            return new DoubleQuery(fieldPath, operator, new Double((Integer) value));
        }
        else
        {
            return new DoubleQuery(fieldPath, operator, (Double) value);
        }
    }
    
    /**
     * Get a long query.
     * @param value The value to use for this criterion.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getLongQuery(Object value, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new LongQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            Collection<Object> values = (Collection<Object>) value;
            
            List<Query> queries = new ArrayList<>();
            for (Object val : values)
            {
                queries.add(getLongQuery(val, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else if (value instanceof String)
        {
            Long longValue = (Long) ParameterHelper.castValue((String) value, ParameterType.LONG);
            return new LongQuery(fieldPath, operator, longValue);
        }
        else
        {
            return new LongQuery(fieldPath, operator, new Long((Integer) value));
        }
    }
    
    /**
     * Get a date query.
     * @param value The value to use for this criterion.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getDateQuery(Object value, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new DateQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            Collection<Object> values = (Collection<Object>) value;
            
            List<Query> queries = new ArrayList<>();
            for (Object val : values)
            {
                queries.add(getDateQuery(val, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else 
        {
            Date dateValue = (Date) ParameterHelper.castValue((String) value, ParameterType.DATE);
            
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTime(dateValue);
            calendar.set(Calendar.HOUR, 0);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.MILLISECOND, 0);
    
            if (operator.equals(Operator.LE))
            {
                calendar.add(Calendar.DAY_OF_YEAR, 1);
                return new DateQuery(fieldPath, Operator.LT, calendar.getTime());
            }
    
            return new DateQuery(fieldPath, operator, calendar.getTime());
        }
    }
    
    /**
     * Get a content query.
     * @param value The value to use for this criterion.
     * @param language The search language.
     * @param fieldPath The field path.
     * @param operator The query operator to use.
     * @return The query.
     */
    protected Query getContentQuery(Object value, String language, String fieldPath, Operator operator)
    {
        if (operator == Operator.EXISTS)
        {
            return new StringQuery(fieldPath);
        }
        else if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            List<String> stringValues = (List<String>) value;
            
            List<Query> queries = new ArrayList<>();
            for (String val : stringValues)
            {
                queries.add(getContentQuery(val, language, fieldPath, operator));
            }
            
            return _isMultipleOperandAnd ? new AndQuery(queries) : new OrQuery(queries);
        }
        else
        {
            String stringValue = (String) ParameterHelper.castValue((String) value, ParameterType.STRING);
            return new StringQuery(fieldPath, operator, stringValue, language);
        }
    }
    
    @Override
    public SearchField getSearchField()
    {
        // No search field for a joined field.
        if (getJoinPaths().isEmpty())
        {
            return _searchHelper.getMetadataSearchField(getFieldPath(), getType());
        }
        
        return null;
    }
    
    /**
     * Configure the criterion operator.
     * @param configuration the global criterion configuration.
     * @param definition the metadata definition.
     * @throws ConfigurationException if an error occurs.
     */
    private void _configureOperator(Configuration configuration, MetadataDefinition definition) throws ConfigurationException
    {
        try
        {
            String op = configuration.getChild("test-operator").getValue("");
            if (StringUtils.isNotBlank(op))
            {
                _operator = Operator.fromName(op);
            }
            else if (definition != null && definition.getEnumerator() == null
                && (definition.getType() == MetadataType.STRING || definition.getType() == MetadataType.RICH_TEXT))
            {
                _operator = Operator.SEARCH;
            }
            else
            {
                _operator = Operator.EQ;
            }
        }
        catch (IllegalArgumentException e)
        {
            throw new ConfigurationException("Invalid operator", configuration, e);
        }
    }
    
    private void _configureLabel(Configuration configuration, IndexingField indexingField, String fieldName, MetadataDefinition definition)
    {
        I18nizableText defaultValue = new I18nizableText(fieldName);
        if (definition != null)
        {
            defaultValue = definition.getLabel();
        }
        else if (indexingField != null && indexingField.getLabel() != null)
        {
            defaultValue = indexingField.getLabel();
        }
        
        setLabel(_configureI18nizableText(configuration.getChild("label", false), defaultValue));
    }
    
    private void _configureDescription(Configuration configuration, IndexingField indexingField, String fieldName, MetadataDefinition definition)
    {
        I18nizableText defaultValue = new I18nizableText(fieldName);
        if (definition != null)
        {
            defaultValue = definition.getDescription();
        }
        else if (indexingField != null && indexingField.getDescription() != null)
        {
            defaultValue = indexingField.getDescription();
        }
        
        setDescription(_configureI18nizableText(configuration.getChild("description", false), defaultValue));
    }
    
    private Map<String, I18nizableText> _configureWidgetParameters(Configuration config, Map<String, I18nizableText> defaultParams) throws ConfigurationException
    {
        if (config != null)
        {
            Map<String, I18nizableText> widgetParams = new HashMap<>();
            
            Configuration[] params = config.getChildren("param");
            for (Configuration paramConfig : params)
            {
                boolean i18nSupported = paramConfig.getAttributeAsBoolean("i18n", false);
                if (i18nSupported)
                {
                    String catalogue = paramConfig.getAttribute("catalogue", null);
                    widgetParams.put(paramConfig.getAttribute("name"), new I18nizableText(catalogue, paramConfig.getValue()));
                }
                else
                {
                    widgetParams.put(paramConfig.getAttribute("name"), new I18nizableText(paramConfig.getValue("")));
                }
            }
            
            return widgetParams;
        }
        else
        {
            return defaultParams;
        }
    }
    
    /**
     * Get the metadata definition from the indexing field. 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
     * @return The metadata definition or null if not found
     * @throws ConfigurationException If an error occurs.
     */
    protected MetadataDefinition getMetadataDefinition(IndexingField indexingField, String[] remainingPathSegments, List<String> joinPaths) throws ConfigurationException
    {
        if (indexingField instanceof MetadataIndexingField)
        {
            return getMetadataDefinition((MetadataIndexingField) indexingField, remainingPathSegments, joinPaths, false);
        }
        else if (indexingField instanceof CustomIndexingField)
        {
            if (remainingPathSegments.length > 0)
            {
                throw new ConfigurationException("The custom indexing field '" + indexingField.getName() + "' can not have remaining path: " + StringUtils.join(remainingPathSegments, ContentConstants.METADATA_PATH_SEPARATOR));
            }
            else
            {
                // No more recursion
                setType(indexingField.getType());
                // No metadata definition for a custom indexing field
                return null;
            }
        }
        else
        {
            throw new ConfigurationException("Unsupported class of indexing field:" + indexingField.getName() + " (" + indexingField.getClass().getName() + ")");
        }
    }
    
    /**
     * Get the field's path without join paths
     * @param indexingField The initial indexing field
     * @param remainingPathSegments The path to access the metadata or an another indexing field from the initial indexing field
     * @return the field's path
     * @throws ConfigurationException If an error occurs.
     */
    protected String getFieldPath(IndexingField indexingField, String[] remainingPathSegments) throws ConfigurationException
    {
        StringBuilder currentMetaPath = new StringBuilder();
        currentMetaPath.append(indexingField.getName());
        
        if (indexingField instanceof MetadataIndexingField)
        {
            MetadataDefinition definition = ((MetadataIndexingField) indexingField).getMetadataDefinition();
            
            for (int i = 0; i < remainingPathSegments.length && definition != null; i++)
            {
                if (definition.getType() == MetadataType.CONTENT || definition.getType() == MetadataType.SUB_CONTENT)
                {
                    currentMetaPath = new StringBuilder();
                    currentMetaPath.append(remainingPathSegments[i]);
                    
                    String refCTypeId = definition.getContentType();
                    if (refCTypeId != null && _cTypeEP.hasExtension(refCTypeId))
                    {
                        ContentType refCType = _cTypeEP.getExtension(refCTypeId);
                        IndexingModel refIndexingModel = refCType.getIndexingModel();
                        
                        IndexingField refIndexingField = refIndexingModel.getField(remainingPathSegments[i]);
                        if (refIndexingField == null)
                        {
                            throw new ConfigurationException("Indexing field search criteria with path '" + StringUtils.join(remainingPathSegments, ContentConstants.METADATA_PATH_SEPARATOR) + "' refers to an unknown indexing field: " + remainingPathSegments[i]);
                        }
                        
                        definition = refCType.getMetadataDefinition(remainingPathSegments[i]);
                    }
                }
                else
                {
                    if (definition instanceof RepeaterDefinition)
                    {
                        // Add path to repeater from current content type or last repeater to join paths
                        currentMetaPath = new StringBuilder();
                        currentMetaPath.append(remainingPathSegments[i]);
                    }
                    else
                    {
                        currentMetaPath.append(ContentConstants.METADATA_PATH_SEPARATOR).append(remainingPathSegments[i]);
                    }
                    definition = definition.getMetadataDefinition(remainingPathSegments[i]);
                }
            }
            
            // If the criteria is a join on several levels, the path of the metadata is the path from the last level of joint
            // Ex: {!ametys join=[join paths separated by arrows] q=[metadataPath]:"content://xxxx"}
            // -> {!ametys join=address/city_s_dv->links/department_s_dv q=links/state_ss:"content://xxxx"}
            return currentMetaPath.toString();
        }
        else if (indexingField instanceof CustomIndexingField)
        {
            if (remainingPathSegments.length > 0)
            {
                throw new ConfigurationException("The custom indexing field '" + indexingField.getName() + "' can not have remaining path: " + StringUtils.join(remainingPathSegments, ContentConstants.METADATA_PATH_SEPARATOR));
            }
            else
            {
                return indexingField.getName();
            }
        }
        else
        {
            throw new ConfigurationException("Unsupported class of indexing field:" + indexingField.getName() + " (" + indexingField.getClass().getName() + ")");
        }
    }
    
}