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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
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.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.util.ClientUtils;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.languages.Language;
import org.ametys.cms.languages.LanguagesManager;
import org.ametys.cms.search.model.SearchCriterion;
import org.ametys.cms.search.model.SystemSearchCriterion;
import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.ContentLanguageQuery;
import org.ametys.cms.search.query.ContentTypeQuery;
import org.ametys.cms.search.query.MixinTypeQuery;
import org.ametys.cms.search.query.NotQuery;
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.ui.model.SearchUICriterion;
import org.ametys.cms.search.ui.model.SearchUIModel;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;

/**
 * Builds a {@link Query} object from a user search.
 */
public class QueryBuilder extends AbstractLogEnabled implements Component, Serviceable
{
    /** The component role. */
    public static final String ROLE = QueryBuilder.class.getName();

    /** Prefix for id of metadata search criteria */
    public static final String SEARCH_CRITERIA_METADATA_PREFIX = "metadata-";

    /** Prefix for id of system property search criteria */
    public static final String SEARCH_CRITERIA_SYSTEM_PREFIX = "property-";
    
    /** Key of flag present in contextual parameters to indicate the current search is multilingual */
    public static final String MULTILINGUAL_SEARCH = "multilingualSearch";

    /** Key of flag present in contextual parameters to indicate the provided value was already escaped */
    public static final String VALUE_IS_ESCAPED = "isEscapedValue";
    
    /** The query default language. */
    public static final String DEFAULT_LANGUAGE = "en";

    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;

    /** The languages manager */
    protected LanguagesManager _languagesManager;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _cTypeEP = (ContentTypeExtensionPoint) serviceManager.lookup(ContentTypeExtensionPoint.ROLE);
        _languagesManager = (LanguagesManager) serviceManager.lookup(LanguagesManager.ROLE);
    }

    /**
     * Build the {@link Query} object.
     * @param model the search model.
     * @param searchMode the search mode.
     * @param createContentTypeQuery True to generate a query based on the content types of the model, and the 'property-contentTypes-eq' if present in values
     * @param values the user search values.
     * @param contextualParameters the search contextual parameters.
     * @return a {@link Query} object representing the search.
     */
    public Query build(SearchUIModel model, String searchMode, boolean createContentTypeQuery, Map<String, Object> values, Map<String, Object> contextualParameters)
    {
        Map<String, Object> copiedValues = new HashMap<>(values);
        List<Query> queries = new ArrayList<>();

        Set<String> modelContentTypes = model.getContentTypes(contextualParameters);
        Set<String> modelExcludedCTypes = model.getExcludedContentTypes(contextualParameters);
        Map<String, SearchUICriterion> criteria = searchMode.equals("advanced") ? model.getAdvancedCriteria(contextualParameters) : model.getCriteria(contextualParameters);

        Query cTypeQuery = null;
        if (createContentTypeQuery)
        {
            cTypeQuery = createContentTypeQuery(modelContentTypes, copiedValues, criteria, searchMode);
        }
        if (cTypeQuery != null)
        {
            queries.add(cTypeQuery);
        }

        if (!modelExcludedCTypes.isEmpty())
        {
            // query is on `allContentTypes` field, so do not be redundant and only keep the top supertypes for a readable query
            queries.add(new ContentTypeQuery(Operator.NE, _getOnlySuperTypes(modelExcludedCTypes)));
        }

        String language = getCriteriaLanguage(criteria, searchMode, copiedValues, contextualParameters);

        Query mixinQuery = createMixinTypeQuery(modelContentTypes, values, criteria, searchMode);
        if (mixinQuery != null)
        {
            queries.add(mixinQuery);
        }
        
        if (_isMultilingualSearch(cTypeQuery))
        {
            contextualParameters.put(MULTILINGUAL_SEARCH, true);
        }

        if ("simple".equals(searchMode))
        {
            queries.addAll(getCriteriaQueries(criteria, copiedValues, language, contextualParameters));
        }
        else if ("advanced".equals(searchMode))
        {
            Query advQuery = getAdvancedCriteriaQuery(criteria, copiedValues, language, contextualParameters);
            if (advQuery != null)
            {
                queries.add(advQuery);
            }

            Query contentLanguageQuery = new ContentLanguageQuery(language);
            queries.add(contentLanguageQuery);
        }

        return new AndQuery(queries);
    }
    
    private boolean _isMultilingualSearch(Query cTypeQuery)
    {
        if (cTypeQuery == null || !(cTypeQuery instanceof ContentTypeQuery))
        {
            return false;
        }
        
        for (String cTypeId : ((ContentTypeQuery) cTypeQuery).getIds())
        {
            if (!_cTypeEP.getExtension(cTypeId).isMultilingual())
            {
                return false;
            }
        }
        
        // All concerned content types are multilingual
        return true;
    }

    private Set<String> _getOnlySuperTypes(Set<String> cTypes)
    {
        Set<String> result = new HashSet<>();

        for (String cTypeId : cTypes)
        {
            ContentType cType = _cTypeEP.getExtension(cTypeId);
            if (!_containsAny(cTypes, cType.getSupertypeIds()))
            {
                result.add(cTypeId);
            }
        }

        return result;
    }

    // Returns true if at least one of the supertypeIds is in cTypes
    private boolean _containsAny(Set<String> cTypes, String[] supertypeIds)
    {
        for (String supertypeId : supertypeIds)
        {
            if (cTypes.contains(supertypeId))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * Get the language.
     * @param criteria the list of search criteria
     * @param searchMode The search mode (advanced or simple)
     * @param values The user values.
     * @param contextualParameters The search contextual parameters.
     * @return the query language.
     */
    public String getCriteriaLanguage(Map<String, SearchUICriterion> criteria, String searchMode, Map<String, Object> values, Map<String, Object> contextualParameters)
    {
        String langValue = null;

        // First search language in search criteria
        for (SearchCriterion criterion : criteria.values())
        {
            if (criterion instanceof SystemSearchCriterion)
            {
                SystemSearchUICriterion sysCrit = (SystemSearchUICriterion) criterion;
                if (sysCrit.getSystemPropertyId().equals("contentLanguage"))
                {
                    if (sysCrit.isHidden())
                    {
                        // Use the default value
                        langValue = (String) sysCrit.getDefaultValue();
                    }
                    else
                    {
                        // Use the user input
                        langValue = (String) values.get(sysCrit.getId());
                    }
                    break;
                }
            }
        }

        if (StringUtils.isEmpty(langValue) || "CURRENT".equals(langValue))
        {
            // If empty, get language from the search contextual parameters (for instance, sent by the tool).
            langValue = (String) contextualParameters.get("language");
        }

        if (StringUtils.isEmpty(langValue))
        {
            // If no language found: fall back to default.
            langValue = getDefaultLanguage();
        }

        return langValue;
    }

    /**
     * Get the default language for search
     * @return The default language
     */
    protected String getDefaultLanguage()
    {
        Map<String, Language> availableLanguages = _languagesManager.getAvailableLanguages();
        if (availableLanguages.containsKey(DEFAULT_LANGUAGE))
        {
            return DEFAULT_LANGUAGE;
        }

        return availableLanguages.size() > 0 ? availableLanguages.keySet().iterator().next() : DEFAULT_LANGUAGE;
    }

    /**
     * Create a content type query.
     * @param modelContentTypes the content types to search on.
     * @param values the user search values.
     * @param criteria the list of search criteria
     * @param searchMode The search mode (advanced or simple)
     * @return the content type {@link Query}.
     */
    protected Query createContentTypeQuery(Set<String> modelContentTypes, Map<String, Object> values, Map<String, SearchUICriterion> criteria, String searchMode)
    {
        return createContentTypeQuery(modelContentTypes, values, criteria, searchMode, false);
    }

    /**
     * Create a content type query.
     * @param modelContentTypes the content types to search on.
     * @param values the user search values.
     * @param criteria the list of search criteria
     * @param searchMode The search mode (advanced or simple)
     * @param exclude <code>true</code> to create a negative query ("all but the given content types"), <code>false</code> to create a standard "include" query.
     * @return the content type {@link Query}.
     */
    @SuppressWarnings("unchecked")
    protected Query createContentTypeQuery(Set<String> modelContentTypes, Map<String, Object> values, Map<String, SearchUICriterion> criteria, String searchMode, boolean exclude)
    {
        String systemCriterionId = _findSystemCriterionId("contentTypes", criteria);
        Object cTypeParam = _getAndRemoveValueForSytemCriterion(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId).map(criteria::get).map(SearchUICriterion::isMultiple).orElse(false);
        boolean emptyCTypeParam = criterionIsMultiple && CollectionUtils.isEmpty((Collection< ? >) cTypeParam) || !criterionIsMultiple && StringUtils.isEmpty((String) cTypeParam);
        Operator op = exclude ? Operator.NE : Operator.EQ;

        if (emptyCTypeParam)
        {
            return createContentTypeOrMixinQuery(modelContentTypes, values, criteria, searchMode);
        }
        else if (criterionIsMultiple) // non-empty and multiple
        {
            return new ContentTypeQuery(op, (Collection<String>) cTypeParam);
        }
        else // non-empty and non-multiple
        {
            return new ContentTypeQuery(op, (String) cTypeParam);
        }
    }

    /**
     * Create a mixin type query.
     * @param mixinTypes the mixin types to search on.
     * @param values the user search values.
     * @param criteria the list of search criteria
     * @param searchMode The search mode (advanced or simple)
     * @return the mixin type {@link Query}.
     */
    @SuppressWarnings("unchecked")
    protected Query createMixinTypeQuery(Set<String> mixinTypes, Map<String, Object> values, Map<String, SearchUICriterion> criteria, String searchMode)
    {
        String systemCriterionId = _findSystemCriterionId("mixin", criteria);
        Object mixinParam = _getAndRemoveValueForSytemCriterion(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId).map(criteria::get).map(SearchUICriterion::isMultiple).orElse(false);
        boolean emptyMixinParam = criterionIsMultiple && CollectionUtils.isEmpty((Collection< ? >) mixinParam) || !criterionIsMultiple && StringUtils.isEmpty((String) mixinParam);

        if (emptyMixinParam)
        {
            return null;
        }
        else if (criterionIsMultiple) // non-empty and multiple
        {
            return new MixinTypeQuery((Collection<String>) mixinParam);
        }
        else // non-empty and non-multiple
        {
            return new MixinTypeQuery((String) mixinParam);
        }
    }

    /**
     * Create a content type or mixin query.
     * @param modelContentTypes the content types or mixins to search on.
     * @param values the user search values.
     * @param criteria the list of search criteria
     * @param searchMode The search mode (advanced or simple)
     * @return the content type {@link Query}.
     */
    protected Query createContentTypeOrMixinQuery(Set<String> modelContentTypes, Map<String, Object> values, Map<String, SearchUICriterion> criteria, String searchMode)
    {
        String systemCriterionId = _findSystemCriterionId("contentTypeOrMixin", criteria);
        Object cTypeOrMixinParam = _getAndRemoveValueForSytemCriterion(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId).map(criteria::get).map(SearchUICriterion::isMultiple).orElse(false);
        return createContentTypeOrMixinQuery(modelContentTypes, cTypeOrMixinParam, criterionIsMultiple);
    }
    
    /**
     * Create a content type or mixin query.
     * @param modelContentTypes the content types or mixins to search on.
     * @param cTypeOrMixinParam The contentTypes or mixin parameter on which you want to build the Query
     * @param criterionIsMultiple <code>true</code> if the given parameter is a value for a multiple criterion
     * @return the content type {@link Query}.
     */
    @SuppressWarnings("unchecked")
    public Query createContentTypeOrMixinQuery(Set<String> modelContentTypes, Object cTypeOrMixinParam, boolean criterionIsMultiple)
    {
        boolean emptyCTypeOrMixinParam = criterionIsMultiple && CollectionUtils.isEmpty((Collection< ? >) cTypeOrMixinParam) || !criterionIsMultiple && StringUtils.isEmpty((String) cTypeOrMixinParam);
        
        if (emptyCTypeOrMixinParam && modelContentTypes != null && !modelContentTypes.isEmpty()) // empty and non-empty model contentTypes
        {
            return _contentTypeQueryOrMixinQuery(modelContentTypes);
        }
        else if (emptyCTypeOrMixinParam) // empty and empty model contentTypes
        {
            return null;
        }
        else if (criterionIsMultiple) // non-empty and multiple
        {
            return _contentTypeQueryOrMixinQuery((Collection<String>) cTypeOrMixinParam);
        }
        else // non-empty and non-multiple
        {
            String cTypeOrMixinParamStr = (String) cTypeOrMixinParam;
            return _cTypeEP.getExtension(cTypeOrMixinParamStr).isMixin() ? new MixinTypeQuery(cTypeOrMixinParamStr)
                                                                         : new ContentTypeQuery(cTypeOrMixinParamStr);
        }
    }

    private Query _contentTypeQueryOrMixinQuery(Collection<String> contentTypes)
    {
        Collection<String> onlyMixins = contentTypes.stream().filter(ct -> _cTypeEP.getExtension(ct).isMixin()).collect(Collectors.toList());
        Collection<String> onlyContentTypes = contentTypes.stream().filter(ct -> !_cTypeEP.getExtension(ct).isMixin()).collect(Collectors.toList());
        if (onlyMixins.isEmpty())
        {
            return new ContentTypeQuery(contentTypes);
        }
        else if (onlyContentTypes.isEmpty())
        {
            return new MixinTypeQuery(contentTypes);
        }
        else
        {
            return new OrQuery(new ContentTypeQuery(onlyContentTypes), new MixinTypeQuery(onlyMixins));
        }
    }
    
    private Object _getAndRemoveValueForSytemCriterion(String systemCriterionId, Map<String, Object> values, String searchMode)
    {
        if (systemCriterionId == null)
        {
            return null;
        }
        
        if ("simple".equals(searchMode))
        {
            return values.remove(systemCriterionId);
        }
        
        // advanced search mode
        String type = (String) values.get("type");
        if ("criterion".equals(type) && systemCriterionId.equals(values.get("id"))) // advanced mode with a unique criterion node
        {
            Object result = values.get("value");
            values.clear();
            return result;
        }
        else if (_isFlatAndExpression(type, values)) // advanced mode with an AND operator on only criteria (no complicated nested expressions)
        {
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> expressions = (List<Map<String, Object>>) values.get("expressions");
            Map<String, Object> systemPropertyExpr = expressions.stream().filter(exp -> systemCriterionId.equals(exp.get("id"))).findFirst().orElse(null);
            if (systemPropertyExpr != null)
            {
                expressions.remove(systemPropertyExpr);
                return systemPropertyExpr.get("value");
            }
        }
        
        return null;
    }
    
    private String _findSystemCriterionId(String systemPropertyId, Map<String, SearchUICriterion> criteria)
    {
        for (SearchCriterion criterion : criteria.values())
        {
            if (criterion instanceof SystemSearchCriterion && criterion.getOperator() == Operator.EQ)
            {
                if (((SystemSearchCriterion) criterion).getSystemPropertyId().equals(systemPropertyId))
                {
                    return criterion.getId();
                }
            }
        }
        
        return null;
    }
    
    @SuppressWarnings("unchecked")
    private boolean _isFlatAndExpression(String rootType, Map<String, Object> values)
    {
        return "and".equalsIgnoreCase(rootType)
                && ((List<Map<String, Object>>) values.get("expressions")).stream().allMatch(exp -> "criterion".equals(exp.get("type")));
    }

    /**
     * Get the list of query on criteria.
     * @param criteria the list of search criteria
     * @param values The submitted values
     * @param language The query language.
     * @param contextualParameters The contextual parameters
     * @return The criteria {@link Query}.
     */
    protected List<Query> getCriteriaQueries(Map<String, SearchUICriterion> criteria, Map<String, Object> values, String language, Map<String, Object> contextualParameters)
    {
        List<Query> queries = new ArrayList<>();

        for (String id : criteria.keySet())
        {
            SearchUICriterion criterion = criteria.get(id);
            Object submitValue = values.get(id);
            
            // If the criterion is hidden, take the default value (fixed in the search model).
            // Otherwise take the standard user value.
            Object value = criterion.isHidden() ? criterion.getDefaultValue() : submitValue;

            if (value != null || criterion.getOperator() == Operator.EXISTS)
            {
                Query query = criterion.getQuery(value, values, language, contextualParameters);
                if (query != null)
                {
                    queries.add(query);
                }
            }
        }

        return queries;
    }

    /**
     * Get a complex Query from the advanced search values.
     * @param criteria the list of search criteria
     * @param values The submitted values
     * @param language The query language.
     * @param contextualParameters The contextual parameters
     * @return The criteria {@link Query}.
     */
    protected Query getAdvancedCriteriaQuery(Map<String, SearchUICriterion> criteria, Map<String, Object> values, String language, Map<String, Object> contextualParameters)
    {
        Query query = null;

        String type = (String) values.get("type");

        if ("criterion".equals(type))
        {
            // Criterion node: return a simple Query object.
            String id = (String) values.get("id");
            Object value = values.get("value");
            String op = (String) values.get("op");

            SearchUICriterion criterion = criteria.get(id);

            query = getAdvancedCriterionQuery(criterion, op, value, language, contextualParameters);
        }
        else if ("and".equalsIgnoreCase(type) || "or".equalsIgnoreCase(type))
        {
            // AND/OR node: recurse on each sub-query and return a AndQuery/OrQuery.
            List<Query> queries = new ArrayList<>();

            @SuppressWarnings("unchecked")
            List<Map<String, Object>> expressions = (List<Map<String, Object>>) values.get("expressions");
            for (Map<String, Object> expression : expressions)
            {
                Query expQuery = getAdvancedCriteriaQuery(criteria, expression, language, contextualParameters);
                if (expQuery != null)
                {
                    queries.add(expQuery);
                }
            }

            query = "and".equalsIgnoreCase(type) ? new AndQuery(queries) : new OrQuery(queries);
        }

        return query;
    }

    /**
     * Build the {@link Query} object corresponding to an advanced criterion value.
     * @param criterion The search criterion.
     * @param op The advanced operator (can be a custom one, such as "contain").
     * @param value The user value.
     * @param language The query language.
     * @param contextualParameters the search contextual parameters.
     * @return The criterion {@link Query}.
     */
    protected Query getAdvancedCriterionQuery(SearchUICriterion criterion, String op, Object value, String language, Map<String, Object> contextualParameters)
    {
        Query query = null;

        // Special wildcard searches.
        if ("contains".equals(op) || "not-contains".equals(op))
        {
            String wdValue = "*" + escapeQueryCharsForLikeQuery((String) value, contextualParameters) + "*";
            query = criterion.getQuery(wdValue, Operator.LIKE, Collections.emptyMap(), language, contextualParameters);
            if ("not-contains".equals(op))
            {
                query = new NotQuery(query);
            }
        }
        else if ("starts-with".equals(op) || "not-starts-with".equals(op))
        {
            String wdValue = escapeQueryCharsForLikeQuery((String) value, contextualParameters) + "*";
            query = criterion.getQuery(wdValue, Operator.LIKE, Collections.emptyMap(), language, contextualParameters);
            if ("not-starts-with".equals(op))
            {
                query = new NotQuery(query);
            }
        }
        else if ("ends-with".equals(op) || "not-ends-with".equals(op))
        {
            String wdValue = "*" + escapeQueryCharsForLikeQuery((String) value, contextualParameters);
            query = criterion.getQuery(wdValue, Operator.LIKE, Collections.emptyMap(), language, contextualParameters);
            if ("not-ends-with".equals(op))
            {
                query = new NotQuery(query);
            }
        }
        else if (StringUtils.isNotBlank(op))
        {
            Operator operator = Operator.fromName(op);
            query = criterion.getQuery(value, operator, Collections.emptyMap(), language, contextualParameters);
        }

        return query;
    }

    /**
     * Escape special Solr query characters of the user input, before building the query in order to append '*' character(s)
     * @param string The string to escape.
     * @param contextualParameters the search contextual parameters.
     * @return The escaped string.
     */
    protected String escapeQueryCharsForLikeQuery(String string, Map<String, Object> contextualParameters)
    {
        contextualParameters.put(QueryBuilder.VALUE_IS_ESCAPED, Boolean.TRUE);
        return ClientUtils.escapeQueryChars(string);
    }

}