/*
 *  Copyright 2020 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.web.frontoffice.search.requesttime.impl;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
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.slf4j.Logger;

import org.ametys.cms.search.advanced.AbstractTreeNode;
import org.ametys.cms.search.advanced.AdvancedQueryBuilder;
import org.ametys.cms.search.advanced.TreeLeaf;
import org.ametys.cms.search.advanced.TreeMaker;
import org.ametys.cms.search.advanced.utils.TreePrinter;
import org.ametys.cms.search.query.MatchNoneQuery;
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.QuerySyntaxException;
import org.ametys.core.util.I18nUtils;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.Errors;
import org.ametys.runtime.parameter.Validator;
import org.ametys.web.frontoffice.search.instance.SearchServiceInstance;
import org.ametys.web.frontoffice.search.instance.model.FOSearchCriterion;
import org.ametys.web.frontoffice.search.instance.model.FOSearchCriterionMode;
import org.ametys.web.frontoffice.search.instance.model.FOSearchCriterionMode.FoWrappedValue;
import org.ametys.web.frontoffice.search.instance.model.SearchContext;
import org.ametys.web.frontoffice.search.metamodel.AdditionalParameterValueMap;
import org.ametys.web.frontoffice.search.metamodel.EnumeratedValues.RestrictedValues;
import org.ametys.web.frontoffice.search.metamodel.Returnable;
import org.ametys.web.frontoffice.search.metamodel.SearchCriterionDefinition;
import org.ametys.web.frontoffice.search.metamodel.Searchable;
import org.ametys.web.frontoffice.search.metamodel.context.ContextQueriesWrapper;
import org.ametys.web.frontoffice.search.requesttime.SearchComponentArguments;
import org.ametys.web.frontoffice.search.requesttime.input.SearchUserInputs;
import org.ametys.web.frontoffice.search.requesttime.input.impl.UserPrefsSearchUserInputs;
import org.ametys.web.repository.page.SitemapElement;
import org.ametys.web.repository.site.Site;

import com.google.common.collect.ImmutableMap;

/**
 * A helper for all search component
 */
public class SearchComponentHelper implements Serviceable, Component
{
    /** The avalon role. */
    public static final String ROLE = SearchComponentHelper.class.getName();
    
    /** The {@link Query} building to the empty string */
    public static final Query EMPTY_QUERY = new Query()
    {
        @Override
        public String build() throws QuerySyntaxException
        {
            return StringUtils.EMPTY;
        }
        @Override
        public String toString(int indent)
        {
            return StringUtils.repeat(' ', indent) + "EmptyQuery()";
        }
    };
    
    /** The builder of advanced queries */
    protected AdvancedQueryBuilder _advancedQueryBuilder;
    
    /** The Advanced tree maker */
    protected TreeMaker _treeMaker;

    /** The utils for i18nizable texts */
    protected I18nUtils _i18nUtils;
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _advancedQueryBuilder = (AdvancedQueryBuilder) manager.lookup(AdvancedQueryBuilder.ROLE);
        _treeMaker = (TreeMaker) manager.lookup(TreeMaker.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
    }
    
    /**
     * Get the criterion tree query from arguments
     * @param args the search arguments
     * @param checkValidInputs true if inputs needs to be checked
     * @param logTree true if the criterion tree need to be logged
     * @return the criterion tree query
     * @throws InvalidUserInputException if an invalid user input occurred
     */
    public Query getCriterionTreeQuery(SearchComponentArguments args, boolean checkValidInputs, boolean logTree) throws InvalidUserInputException
    {
        SearchServiceInstance serviceInstance = args.serviceInstance();
        AbstractTreeNode<FOSearchCriterion> criterionTree = serviceInstance.getCriterionTree().get();
        SearchUserInputs userInputs = args.userInputs();
        Map<String, Object> userCriteria = checkValidInputs 
                ? checkValidInputs(criterionTree, userInputs.criteria(), userInputs instanceof UserPrefsSearchUserInputs, args.logger())
                : userInputs.criteria();
        
        if (logTree)
        {
            _logTree(args.logger(), criterionTree, userCriteria);
        }
        
        Collection<Returnable> returnables = serviceInstance.getReturnables();
        Collection<Searchable> searchables = serviceInstance.getSearchables();
        AdditionalParameterValueMap additionalParameters = serviceInstance.getAdditionalParameterValues();
        Map<String, Object> contextualParameters = _contextualParameters(args.currentSite());
        
        
        List<Query> buildQueries = searchables.stream()
                .map(s -> s.buildQuery(criterionTree, userCriteria, returnables, searchables, additionalParameters, args.currentLang(), contextualParameters))
                .collect(Collectors.toList());
        
        return buildQueries.isEmpty() 
                ? null 
                : buildQueries.size() == 1 ? buildQueries.get(0) : new OrQuery(buildQueries);
    }
    
    /**
     * Checks the user inputs are valid.
     * @param criterionTree The criterion tree of the service instance
     * @param userCriteria The user input criteria
     * @param isFromUserPref <code>true</code> if the criteria are from user pref. Then return only the valid input, otherwise throw an exception
     * @param logger The logger
     * @return the filtered user criteria
     * @throws InvalidUserInputException if at least one user input is invalid
     */
    protected Map<String, Object> checkValidInputs(AbstractTreeNode<FOSearchCriterion> criterionTree, Map<String, Object> userCriteria, boolean isFromUserPref, Logger logger) throws InvalidUserInputException
    {
        Map<String, Object> filteredUserCriteria = userCriteria;
        
        List<FOSearchCriterion> criteria = criterionTree.getFlatLeaves()
                .stream()
                .map(TreeLeaf::getValue)
                .collect(Collectors.toList());
        
        // Check user inputs are all declared by the service instance
        Set<String> criterionIds = criteria.stream()
                .filter(crit -> !crit.getMode().isStatic())
                .map(FOSearchCriterion::getId)
                .collect(Collectors.toSet());
        
        // If the user input is from user pref, just ignore the invalid input
        if (isFromUserPref)
        {
            filteredUserCriteria = filteredUserCriteria.entrySet()
                                .stream()
                                .filter(c -> this._isFromCriteria(criterionIds, c.getKey(), logger))
                                .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
        }
        else if (!CollectionUtils.containsAll(criterionIds, filteredUserCriteria.keySet()))
        {
            throw new InvalidUserInputException("At least one of the user input criterion is invalid because it was not declared by the service instance.");
        }
        
        // Check values are among restricted ones (if so) and validate
        for (FOSearchCriterion criterion : criteria)
        {
            String criterionId = criterion.getId();
            
            if (filteredUserCriteria.containsKey(criterionId))
            {
                FOSearchCriterionMode mode = criterion.getMode();
                Optional<RestrictedValues> restrictedValues = criterion.getRestrictedValues();
                boolean isMandatory = criterion.isMandatory();
                Validator validator = criterion.getCriterionDefinition().getValidator();
                Object userCriterionValues = filteredUserCriteria.get(criterionId);
                try
                {
                    checkValidInputValues(userCriterionValues, criterionId, mode, restrictedValues, validator, isMandatory);
                }
                catch (InvalidUserInputException e) 
                {
                    // If the user input is from user pref, just ignore the invalid input
                    if (isFromUserPref)
                    {
                        filteredUserCriteria.remove(criterionId);
                        if (logger.isDebugEnabled())
                        {
                            logger.debug("The user input criterion ({}) from user preferences is invalid because of the following error: {}", criterionId, e);
                        }
                    }
                    else
                    {
                        throw e;
                    }
                }
            }
        }
        
        return filteredUserCriteria;
    }
    
    private boolean _isFromCriteria(Set<String> criterionIds, String criterionId, Logger logger)
    {
        boolean isFromCriteria = criterionIds.contains(criterionId);
        if (!isFromCriteria)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("The user input criterion ({}) from user preferences is invalid because it was not declared by the service instance.", criterionId);
            }
        }
        return isFromCriteria;
    }
    
    /**
     * Checks the user inputs for one criterion (can be multiple) are valid
     * @param userCriterionValues The multiple user values (then it is a List) or the single user value
     * @param criterionId The criterion id
     * @param mode The criterion mode
     * @param optionalRestrictedValues The {@link RestrictedValues} if mode is {@link FOSearchCriterionMode#RESTRICTED_USER_INPUT}
     * @param validator The criterion validator
     * @param isMandatory true if the criterion is linked to a mandatory data
     * @throws InvalidUserInputException if at least one user input is invalid
     */
    protected void checkValidInputValues(Object userCriterionValues, String criterionId, FOSearchCriterionMode mode, Optional<RestrictedValues> optionalRestrictedValues, Validator validator, boolean isMandatory) throws InvalidUserInputException
    {
        if (userCriterionValues instanceof List<?>)
        {
            List<?> userCriterionMultipleValues = (List<?>) userCriterionValues;
            for (Object userCriterionSingleValue : userCriterionMultipleValues)
            {
                checkValidInputSingleValue(userCriterionSingleValue, criterionId, mode, optionalRestrictedValues, validator, isMandatory);
            }
        }
        else
        {
            checkValidInputSingleValue(userCriterionValues, criterionId, mode, optionalRestrictedValues, validator, isMandatory);
        }
    }
    
    /**
     * Checks a single value of one user input for one criterion is valid
     * @param userCriterionSingleValue The single user value
     * @param criterionId The criterion id
     * @param mode The criterion mode
     * @param optionalRestrictedValues The {@link RestrictedValues} if mode is {@link FOSearchCriterionMode#RESTRICTED_USER_INPUT}
     * @param validator The criterion validator
     * @param isMandatory true if the criterion is linked to a mandatory data
     * @throws InvalidUserInputException if the user input is invalid
     */
    protected void checkValidInputSingleValue(Object userCriterionSingleValue, String criterionId, FOSearchCriterionMode mode, Optional<RestrictedValues> optionalRestrictedValues, Validator validator, boolean isMandatory) throws InvalidUserInputException
    {
        if (mode == FOSearchCriterionMode.RESTRICTED_USER_INPUT)
        {
            Set<Object> restrictedValues = optionalRestrictedValues.get().values().keySet();
            
            if (!restrictedValues.contains(userCriterionSingleValue)
                && (!FOSearchCriterionMode.NONE_VALUE.equals(userCriterionSingleValue) || isMandatory))
            {
                throw new InvalidUserInputException("The user input criterion '" + userCriterionSingleValue + "' for criterion '" + criterionId + "' is invalid because it is not among declared restricted values (" + restrictedValues + ").");
            }
        }
        
        Errors errorStructure = new Errors();
        Optional.ofNullable(validator)
                .ifPresent(val -> val.validate(userCriterionSingleValue, errorStructure));
        List<I18nizableText> errors = errorStructure.getErrors();
        if (!errors.isEmpty())
        {
            String translatedErrors = errors.stream()
                .map(_i18nUtils::translate)
                .collect(Collectors.joining("\n"));
            throw new InvalidUserInputException("The user input '" + userCriterionSingleValue + "' for criterion '" + criterionId + "' is invalid because of the following errors:\n" + translatedErrors);
        }
    }
    
    private Map<String, Object> _contextualParameters(Site currentSite)
    {
        return new HashMap<>(ImmutableMap.of("siteName", currentSite.getName()));
    }
    
    /**
     * Builds the query of the criterion tree
     * @param criterionTree The criterion tree of the service instance
     * @param userCriteria The user input criteria
     * @param returnables The returnables of the service instance
     * @param searchables The searchables of the service instance
     * @param additionalParameters The values of additional parameters of the service instance
     * @param currentLang The current lang
     * @param filterCriterionPredicate A function to filter criterion. Can be null for TruePredicate
     * @param contextualParameters the search contextual parameters. 
     * @return The query of the criterion tree
     */
    public Query buildQuery(
            AbstractTreeNode<FOSearchCriterion> criterionTree, 
            Map<String, Object> userCriteria, 
            Collection<Returnable> returnables, 
            Collection<Searchable> searchables, 
            AdditionalParameterValueMap additionalParameters, 
            String currentLang,
            Predicate<FOSearchCriterion> filterCriterionPredicate,
            Map<String, Object> contextualParameters)
    {
        Predicate<FOSearchCriterion> predicate = filterCriterionPredicate != null ? filterCriterionPredicate : crit -> true;
        Function<FOSearchCriterion, Query> queryMapper = crit -> singleCriterionToQuery(crit, userCriteria, returnables, searchables, additionalParameters, currentLang, predicate, contextualParameters);
        return _advancedQueryBuilder.build(criterionTree, queryMapper);
    }
    
    /**
     * Builds the query of the single criterion
     * @param searchCriterion The criterion
     * @param userCriteria The user input criteria
     * @param returnables The returnables of the service instance
     * @param searchables The searchables of the service instance
     * @param additionalParameters The values of additional parameters of the service instance
     * @param currentLang The current lang
     * @param filterCriterionPredicate A function to filter criterion
     * @param contextualParameters the search contextual parameters. 
     * @return The query of the single criterion
     */
    public Query singleCriterionToQuery(
            FOSearchCriterion searchCriterion, 
            Map<String, Object> userCriteria, 
            Collection<Returnable> returnables, 
            Collection<Searchable> searchables, 
            AdditionalParameterValueMap additionalParameters, 
            String currentLang, 
            Predicate<FOSearchCriterion> filterCriterionPredicate, 
            Map<String, Object> contextualParameters)
    {
        FOSearchCriterionMode mode = searchCriterion.getMode();
        FoWrappedValue val = mode.getValue(searchCriterion, userCriteria, contextualParameters);
        
        // The criterion was not filled by the visitor or it is filtered
        // Put an empty query. It will be ignored by And/OrQuery
        Query joinedQuery;
        if (val.getValue() == null || !filterCriterionPredicate.test(searchCriterion))
        {
            joinedQuery = EMPTY_QUERY;
        }
        else
        {
            BiFunction<FoWrappedValue, Operator, Query> queryFunctionFromTransformedValAndRealOperator = (transformedVal, realOperator) -> _queryFromTransformedValAndRealOperator(
                    searchCriterion.getCriterionDefinition(), 
                    transformedVal, 
                    realOperator, 
                    returnables, 
                    searchables, 
                    additionalParameters, 
                    currentLang, 
                    contextualParameters);
            
            joinedQuery = _treeMaker.toQuery(val, searchCriterion.getOperator(), queryFunctionFromTransformedValAndRealOperator, currentLang, contextualParameters);
        }
        
        return Optional.ofNullable(joinedQuery).orElse(new MatchNoneQuery());
    }
    
    private Query _queryFromTransformedValAndRealOperator(
            SearchCriterionDefinition criterionDefinition, 
            FoWrappedValue transformedVal, 
            Operator realOperator, 
            Collection<Returnable> returnables, 
            Collection<Searchable> searchables, 
            AdditionalParameterValueMap additionalParameters, 
            String currentLang, 
            Map<String, Object> contextualParameters)
    {
        Query queryOnCriterion = _queryOnCriterion(criterionDefinition, transformedVal, realOperator, currentLang, contextualParameters);
        Optional<Searchable> searchable = criterionDefinition.getSearchable();
        Query joinedQuery;
        
        if (searchable.isPresent())
        {
            joinedQuery = searchable.get().joinQuery(queryOnCriterion, criterionDefinition, returnables, additionalParameters).orElse(null);
        }
        else
        {
            // common => all searchables are concerned
            List<Query> joinedQueries = searchables.stream()
                    .map(s -> s.joinQuery(queryOnCriterion, criterionDefinition, returnables, additionalParameters))
                    .filter(Optional::isPresent)
                    .map(Optional::get)
                    .collect(Collectors.toList());
            joinedQuery = joinedQueries.isEmpty() ? null : new OrQuery(joinedQueries);
        }
        return joinedQuery;
    }
    
    private Query _queryOnCriterion(
            SearchCriterionDefinition criterionDefinition, 
            FoWrappedValue transformedVal, 
            Operator realOperator, 
            String currentLang, 
            Map<String, Object> contextualParameters)
    {
        Object unwrappedValue = transformedVal.getValue();
        if (transformedVal.requestEmptyValue())
        {
            return (unwrappedValue instanceof Collection) 
                        ? new OrQuery(criterionDefinition.getEmptyValueQuery(currentLang, contextualParameters), criterionDefinition.getQuery(unwrappedValue, realOperator, currentLang, contextualParameters))
                        : criterionDefinition.getEmptyValueQuery(currentLang, contextualParameters);
        }
        
        return criterionDefinition.getQuery(unwrappedValue, realOperator, currentLang, contextualParameters);
    }
    
    private void _logTree(Logger logger, AbstractTreeNode<FOSearchCriterion> tree, Map<String, Object> userCriteria)
    {
        if (logger.isDebugEnabled())
        {
            Function<FOSearchCriterion, String> leafStringifier = c ->
            {
                String id = c.getId();
                String value = String.valueOf(userCriteria.get(id));
                return "{" + id + ": Operator=" + c.getOperator() + ", Mode=" + c.getMode() + ", Value=" + value + ", StaticValue=" + c.getStaticValue() + "}";
            };
            logger.debug("\n" + TreePrinter.print(tree, leafStringifier));
        }
    }
    
    /**
     * Get the filter query from arguments
     * @param args the search arguments
     * @return the filter query
     */
    public Query getFilterQuery(SearchComponentArguments args)
    {
        SitemapElement currentPage = args.currentPage();
        Site currentSite = args.currentSite();
        String currentLang = args.currentLang();
        SearchServiceInstance serviceInstance = args.serviceInstance();
        AdditionalParameterValueMap additionalParameterValues = serviceInstance.getAdditionalParameterValues();
        
        List<ContextQueriesWrapper> contextQueriesWrappers = serviceInstance.getContexts()
            .stream()
            .map(searchCtx -> _createContextQueriesWrapper(searchCtx, currentSite, currentPage, currentLang))
            .collect(Collectors.toList());
        
        return args.serviceInstance().getReturnables()
                .stream()
                .map(returnable -> returnable.filterReturnedDocumentQuery(contextQueriesWrappers, additionalParameterValues))
                .collect(OrQuery.collector());
    }
    
    /**
     * Creates a {@link ContextQueriesWrapper} given one {@link SearchContext} and the current site, page and lang.
     * @param searchContext The search context
     * @param currentSite The current site
     * @param currentPage The current page
     * @param currentLang The current lang
     * @return The created wrapper of queries of a {@link SearchContext}
     */
    protected ContextQueriesWrapper _createContextQueriesWrapper(SearchContext searchContext, Site currentSite, SitemapElement currentPage, String currentLang)
    {
        return new ContextQueriesWrapper(
                searchContext.getSiteQuery(currentSite),
                searchContext.getSitemapQuery(currentPage),
                searchContext.getContextLang(currentLang),
                searchContext.getTagQuery()
        );
    }
    
    /**
     * Retrieves a {@link Map} of contextual parameters
     * @param args the search component arguments
     * @return the {@link Map} of contextual parameters
     */
    public static Map<String, Object> getSearchComponentContextualParameters(SearchComponentArguments args)
    {
        Map<String, Object> contextualParameters = new HashMap<>();
        
        contextualParameters.put("searchContexts", args.serviceInstance().getContexts());
        contextualParameters.put("siteName", args.currentSite().getName());
        contextualParameters.put("lang", args.currentLang());
        
        return contextualParameters;
    }
}