/*
 *  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.function.BiFunction;
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.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.languages.Language;
import org.ametys.cms.languages.LanguagesManager;
import org.ametys.cms.search.advanced.AbstractTreeNode;
import org.ametys.cms.search.advanced.AdvancedQueryBuilder;
import org.ametys.cms.search.advanced.TreeMaker;
import org.ametys.cms.search.advanced.TreeMaker.ClientSideCriterionWrapper;
import org.ametys.cms.search.advanced.WrappedValue;
import org.ametys.cms.search.advanced.utils.TreePrinter;
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.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;

    /** The Advanced tree maker */
    protected TreeMaker _advancedTreeMaker;
    
    /** The advanced query builder */
    protected AdvancedQueryBuilder _advancedQueryBuilder;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _cTypeEP = (ContentTypeExtensionPoint) serviceManager.lookup(ContentTypeExtensionPoint.ROLE);
        _languagesManager = (LanguagesManager) serviceManager.lookup(LanguagesManager.ROLE);
        _advancedTreeMaker = (TreeMaker) serviceManager.lookup(TreeMaker.ROLE);
        _advancedQueryBuilder = (AdvancedQueryBuilder) serviceManager.lookup(AdvancedQueryBuilder.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.
     */
    @SuppressWarnings("unchecked")
    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, ? extends SearchCriterion> criteria = searchMode.equals("advanced") ? model.getAdvancedCriteria(contextualParameters) : model.getCriteria(contextualParameters);

        Query cTypeQuery = null;
        if (createContentTypeQuery)
        {
            cTypeQuery = createContentTypeQuery(modelContentTypes, copiedValues, (Map<String, SearchCriterion>) 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((Map<String, SearchUICriterion>) criteria, searchMode, copiedValues, contextualParameters);

        Query mixinQuery = createMixinTypeQuery(modelContentTypes, values, (Map<String, SearchCriterion>) criteria, searchMode);
        if (mixinQuery != null)
        {
            queries.add(mixinQuery);
        }
        
        Map<String, Object> modifiableContextualParameters = new HashMap<>(contextualParameters);
        if (_isMultilingualSearch(cTypeQuery))
        {
            modifiableContextualParameters.put(MULTILINGUAL_SEARCH, true);
        }

        if ("simple".equals(searchMode))
        {
            queries.addAll(getCriteriaQueries((Map<String, SearchUICriterion>) criteria, copiedValues, language, modifiableContextualParameters));
        }
        else if ("advanced".equals(searchMode))
        {
            Query advQuery = getAdvancedCriteriaQuery((Map<String, SearchCriterion>) criteria, copiedValues, language, modifiableContextualParameters);
            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}.
     */
    @SuppressWarnings("unchecked")
    protected Query createContentTypeQuery(Set<String> modelContentTypes, Map<String, Object> values, Map<String, SearchCriterion> criteria, String searchMode)
    {
        Operator op = Operator.EQ;
        String systemCriterionId = _findSystemCriterionId("contentTypes", criteria);
        Object cTypeParam = _getAndRemoveValueForSytemCriterionAndEqOperator(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId)
                .map(criteria::get)
                .map(SearchCriterion::isMultiple)
                .orElse(false);
        boolean emptyCTypeParam = criterionIsMultiple && CollectionUtils.isEmpty((Collection< ? >) cTypeParam) || !criterionIsMultiple && StringUtils.isEmpty((String) cTypeParam);

        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, SearchCriterion> criteria, String searchMode)
    {
        String systemCriterionId = _findSystemCriterionId("mixin", criteria);
        Object mixinParam = _getAndRemoveValueForSytemCriterionAndEqOperator(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId)
                .map(criteria::get)
                .map(SearchCriterion::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, SearchCriterion> criteria, String searchMode)
    {
        String systemCriterionId = _findSystemCriterionId("contentTypeOrMixin", criteria);
        Object cTypeOrMixinParam = _getAndRemoveValueForSytemCriterionAndEqOperator(systemCriterionId, values, searchMode);
        
        boolean criterionIsMultiple = Optional.ofNullable(systemCriterionId)
                .map(criteria::get)
                .map(SearchCriterion::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 _getAndRemoveValueForSytemCriterionAndEqOperator(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");
        final String eqOperator = Operator.EQ.getName();
        if ("criterion".equals(type) && systemCriterionId.equals(values.get("id")) && eqOperator.equals(values.get("op"))) // 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")))
                    .filter(exp -> eqOperator.equals(exp.get("op")))
                    .findFirst()
                    .orElse(null);
            if (systemPropertyExpr != null)
            {
                expressions.remove(systemPropertyExpr);
                return systemPropertyExpr.get("value");
            }
        }
        
        return null;
    }
    
    private String _findSystemCriterionId(String systemPropertyId, Map<String, SearchCriterion> criteria)
    {
        for (SearchCriterion criterion : criteria.values())
        {
            if (criterion instanceof SystemSearchCriterion && criterion.getOperator() == Operator.EQ)
            {
                SystemSearchCriterion systemCrit = (SystemSearchCriterion) criterion;
                if (!systemCrit.isJoined() && systemCrit.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, SearchCriterion> criteria, Map<String, Object> values, String language, Map<String, Object> contextualParameters)
    {
        AbstractTreeNode<ValuedSearchCriterion> tree = _createTreeNode(criteria, values);
        if (tree == null)
        {
            return null;
        }
        
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("\n" + TreePrinter.print(tree, c -> "{" + c._searchCriterion.getId() + ": Operator=" + c._op + ", Value=" + c._value + "}"));
        }
        return _advancedQueryBuilder.build(tree, valuedCrit -> valuedCrit.toQuery(language, contextualParameters));
    }
    
    private AbstractTreeNode<ValuedSearchCriterion> _createTreeNode(Map<String, SearchCriterion> criteria, Map<String, Object> values)
    {
        return _advancedTreeMaker.create(values, clientSideCrit -> new ValuedSearchCriterion(criteria.get(clientSideCrit.getId()), clientSideCrit, _advancedTreeMaker));
    }
    
    private static final class ValuedSearchCriterion
    {
        SearchCriterion _searchCriterion;
        String _op;
        Object _value;
        private TreeMaker _advancedTreeMaker;

        ValuedSearchCriterion(SearchCriterion searchCriterion, ClientSideCriterionWrapper clientSideCriterion, TreeMaker advancedTreeMaker)
        {
            _searchCriterion = searchCriterion;
            _op = clientSideCriterion.getStringOperator();
            _value = clientSideCriterion.getValue();
            _advancedTreeMaker = advancedTreeMaker;
        }
        
        Query toQuery(String language, Map<String, Object> contextualParameters)
        {
            BiFunction<WrappedValue, Operator, Query> toQuery = (transformedVal, realOperator) -> _searchCriterion.getQuery(transformedVal.getValue(), realOperator, Collections.emptyMap(), language, contextualParameters);
            // Hack of the death to get the value of reference attribute and use "string" operators (CMS-10773)
            WrappedValue wrappedValue = new WrappedValue(
                _value != null && _searchCriterion.getType() == MetadataType.REFERENCE
                ? Optional.of(_value).filter(Map.class::isInstance).map(v -> ((Map<String, String>) v).get("value")).orElse(StringUtils.EMPTY)
                : _value
            );
            return _advancedTreeMaker.toQuery(wrappedValue, _op, toQuery, language, contextualParameters);
        }
    }

}