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

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
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.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrQuery.ORDER;
import org.apache.solr.client.solrj.SolrRequest.METHOD;
import org.apache.solr.client.solrj.response.FacetField;
import org.apache.solr.client.solrj.response.FacetField.Count;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.slf4j.Logger;

import org.ametys.cms.search.SearchField;
import org.ametys.cms.search.SearchResults;
import org.ametys.cms.search.Sort;
import org.ametys.cms.search.Sort.Order;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.QuerySyntaxException;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.group.GroupManager;
import org.ametys.core.right.AllowedUsers;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.URIUtils;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component searching objects corresponding to a {@link Query}.
 */
public class SearcherFactory extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    
    /** The component role. */
    public static final String ROLE = SearcherFactory.class.getName();
    
    /** The {@link AmetysObjectResolver} */
    protected AmetysObjectResolver _resolver;
    
    /** The solr client provider */
    protected SolrClientProvider _solrClientProvider;
    
    /** The current user provider. */
    protected CurrentUserProvider _currentUserProvider;
    
    /** The group manager */
    protected GroupManager _groupManager;
    
    /** The solr client */
    protected SolrClient _solrClient;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _solrClientProvider = (SolrClientProvider) serviceManager.lookup(SolrClientProvider.ROLE);
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _groupManager = (GroupManager) serviceManager.lookup(GroupManager.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _solrClient = _solrClientProvider.getReadClient();
    }
    
    /**
     * Create a Searcher.
     * @return a Searcher object.
     */
    public Searcher create()
    {
        return new Searcher(getLogger());
    }
    
    /**
     * Class searching objects corresponding to a query, with optional sort, facets, and so on.
     */
    public class Searcher
    {
        private Logger _logger;
        
        private String _queryString;
        private Query _query;
        private List<String> _filterQueryStrings;
        private List<Query> _filterQueries;
        private List<Sort> _sortClauses;
        private List<SearchField> _facets;
        private Map<String, List<String>> _facetValues;
        private int _start;
        private int _maxResults;
        private Map<String, Object> _searchContext;
        private boolean _checkRights;
        private AllowedUsers _checkRightsComparingTo;
        private boolean _debug;
        
        /**
         * Build a Searcher with default values.
         * @param logger The logger.
         */
        protected Searcher(Logger logger)
        {
            _logger = logger;
            
            _filterQueryStrings = new ArrayList<>();
            _filterQueries = new ArrayList<>();
            _sortClauses = new ArrayList<>();
            _facets = new ArrayList<>();
            _facetValues = new HashMap<>();
            _start = 0;
            _maxResults = Integer.MAX_VALUE;
            _searchContext = new HashMap<>();
            _checkRights = true;
        }
        
        /**
         * Set the query (as a String).
         * @param query the query (as a String).
         * @return The Searcher object itself.
         */
        public Searcher withQueryString(String query)
        {
            if (this._query != null)
            {
                throw new IllegalArgumentException("Query and query string can't be used at the same time.");
            }
            this._queryString = query;
            return this;
        }
        
        /**
         * Set the query (as a {@link Query} object).
         * @param query the query (as a {@link Query} object).
         * @return The Searcher object itself.
         */
        public Searcher withQuery(Query query)
        {
            if (this._queryString != null)
            {
                throw new IllegalArgumentException("Query and query string can't be used at the same time.");
            }
            this._query = query;
            return this;
        }
        
        /**
         * Set the filter queries (as Strings).
         * @param queries the filter queries (as Strings).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher withFilterQueryStrings(String... queries)
        {
            _filterQueryStrings = new ArrayList<>(queries.length);
            CollectionUtils.addAll(_filterQueryStrings, queries);
            return this;
        }
        
        /**
         * Set the filter queries (as Strings).
         * @param queries the filter queries (as Strings).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher withFilterQueryStrings(Collection<String> queries)
        {
            _filterQueryStrings = new ArrayList<>(queries);
            return this;
        }
        
        /**
         * Add a filter query to the existing ones (as a String).
         * @param query the filter query to add (as a String).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher addFilterQueryString(String query)
        {
            _filterQueryStrings.add(query);
            return this;
        }
        
        /**
         * Set the filter queries (as {@link Query} objects).
         * @param queries the filter queries (as {@link Query} objects).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher withFilterQueries(Query... queries)
        {
            _filterQueries = new ArrayList<>(queries.length);
            CollectionUtils.addAll(_filterQueries, queries);
            return this;
        }
        
        /**
         * Set the filter queries (as {@link Query} objects).
         * @param queries the filter queries (as {@link Query} objects).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher withFilterQueries(Collection<Query> queries)
        {
            _filterQueries = new ArrayList<>(queries);
            return this;
        }
        
        /**
         * Add a filter query to the existing ones (as a {@link Query} object).
         * @param query the filter query to add (as a {@link Query} object).
         * @return The Searcher object itself. The Searcher object itself.
         */
        public Searcher addFilterQuery(Query query)
        {
            _filterQueries.add(query);
            return this;
        }
        
        /**
         * Set the sort clauses.
         * @param sortClauses the sort clauses.
         * @return The Searcher object itself.
         */
        public Searcher withSort(Sort... sortClauses)
        {
            _sortClauses = new ArrayList<>(sortClauses.length);
            CollectionUtils.addAll(_sortClauses, sortClauses);
            return this;
        }
        
        /**
         * Set the sort clauses.
         * @param sortClauses the sort clauses.
         * @return The Searcher object itself.
         */
        public Searcher withSort(List<Sort> sortClauses)
        {
            _sortClauses = new ArrayList<>(sortClauses);
            return this;
        }
        
        /**
         * Add a sort clause to the existing ones.
         * @param sortClause The sort clause to add.
         * @return The Searcher object itself.
         */
        public Searcher addSort(Sort sortClause)
        {
            _sortClauses.add(sortClause);
            return this;
        }
        
        /**
         * Set the faceted fields.
         * @param facets the faceted fields.
         * @return The Searcher object itself.
         */
        public Searcher withFacets(SearchField... facets)
        {
            _facets = new ArrayList<>(facets.length);
            CollectionUtils.addAll(_facets, facets);
            return this;
        }
        
        /**
         * Set the faceted fields.
         * @param facets the faceted fields.
         * @return The Searcher object itself.
         */
        public Searcher withFacets(Collection<SearchField> facets)
        {
            _facets = new ArrayList<>(facets);
            return this;
        }
        
        /**
         * Add a faceted field.
         * @param facet The faceted field to add.
         * @return The Searcher object itself.
         */
        public Searcher addFacet(SearchField facet)
        {
            _facets.add(facet);
            return this;
        }
        
        /**
         * Set the facet values.
         * @param facetValues The facet values.
         * @return The Searcher object itself.
         */
        public Searcher withFacetValues(Map<String, List<String>> facetValues)
        {
            _facetValues = new HashMap<>(facetValues);
            return this;
        }
        
        /**
         * Set the search offset and limit.
         * @param start The start index (offset).
         * @param maxResults The maximum number of results.
         * @return The Searcher object itself.
         */
        public Searcher withLimits(int start, int maxResults)
        {
            this._start = start;
            this._maxResults = maxResults;
            return this;
        }
        
        /**
         * Set the search context.
         * @param searchContext The search context.
         * @return The Searcher object itself.
         */
        public Searcher withContext(Map<String, Object> searchContext)
        {
            _searchContext = new HashMap<>(searchContext);
            return this;
        }
        
        /**
         * Add a value to the search context.
         * @param key The context key.
         * @param value The value.
         * @return The Searcher object itself.
         */
        public Searcher addContextElement(String key, Object value)
        {
            _searchContext.put(key, value);
            return this;
        }
        
        /**
         * Whether to check rights when searching, false otherwise.
         * @param checkRights <code>true</code> to check rights, <code>false</code> otherwise.
         * @return The Searcher object itself.
         */
        public Searcher setCheckRights(boolean checkRights)
        {
            _checkRights = checkRights;
            return this;
        }
        
        /**
         * Check rights when searching, <b>not</b> according to the current user, 
         * but according to the given {@link AllowedUsers visibilty} to compare each
         * result with.
         * @param compareTo the {@link AllowedUsers visibilty} to compare each result with.
         * @return The Searcher object itself.
         */
        public Searcher checkRightsComparingTo(AllowedUsers compareTo)
        {
            _checkRights = false;
            _checkRightsComparingTo = compareTo;
            return this;
        }
        
        /**
         * Sets the debug on the Solr query 
         * @return The Searcher object itself.
         */
        public Searcher setDebugOn()
        {
            _debug = true;
            return this;
        }
        
        /**
         * Execute the search with the current parameters.
         * @param <A> The type of search results
         * @return An iterable on the result ametys objects.
         * @throws Exception If an error occurs.
         */
        public <A extends AmetysObject> AmetysObjectIterable<A> search() throws Exception
        {
            SearchResults<A> searchResults = searchWithFacets();
            return searchResults.getObjects();
        }
        
        /**
         * Execute the search with the current parameters.
         * @param <A> The type of search results
         * @return An iterable on the search result objects.
         * @throws Exception If an error occurs.
         */
        public <A extends AmetysObject> SearchResults<A> searchWithFacets() throws Exception
        {
            QueryResponse response = _querySolrServer();
            return _buildResults(response, _facets);
        }
        
        /**
         * From the Solr server response, builds the {@link SearchResults} object.
         * @param <A> The type of search results
         * @param response The response from the Solr server
         * @param facets The facet fields to return
         * @return An iterable on the search result objects.
         * @throws Exception If an error occurs.
         */
        protected <A extends AmetysObject> SearchResults<A> _buildResults(QueryResponse response, List<SearchField> facets) throws Exception
        {
            _handleDebug(response);
            Map<String, Map<String, Integer>> facetResults = getFacetResults(response, facets);
            return new SolrSearchResults<>(response, _resolver, facetResults);
        }
        
        private void _handleDebug(QueryResponse response)
        {
            if (_debug && _logger.isDebugEnabled())
            {
                Map<String, Object> debugMap = response.getDebugMap();
                _logger.debug("Debug response: \n{}", debugMap);
            }
        }
        
        private QueryResponse _querySolrServer() throws Exception
        {
            _logSearchQueries();
            String query = getQuery();
            List<String> filterQueries = getFilterQueries();
            
            SolrQuery solrQuery = getSolrQuery(query, filterQueries, _start, _maxResults, _searchContext, _checkRights, _checkRightsComparingTo);
            
            // Set the sort specification and facets in the solr query object.
            setSort(solrQuery, _sortClauses);
            setFacets(solrQuery, _facets, _facetValues);
            
            modifySolrQuery(solrQuery);
            
            if (_logger.isInfoEnabled())
            {
                _logger.info("Solr query: " + URIUtils.decode(solrQuery.toString()));
            }
            
            // Use POST to avoid problems with large requests.
            return _solrClient.query(_solrClientProvider.getCollectionName(), solrQuery, METHOD.POST);
        }
        
        private void _logSearchQueries()
        {
            if (!_logger.isDebugEnabled())
            {
                return;
            }
            
            if (_queryString == null && _query != null)
            {
                _logger.debug("Query before building: \n{}", _query.toString(0));
            }
            if (!_filterQueries.isEmpty())
            {
                _logger.debug("Filter Queries before building: \n{}", _filterQueries
                        .stream()
                        .map(fq -> fq.toString(0))
                        .collect(Collectors.joining("\n###\n")));
            }
        }
        
        /**
         * Get the query string from the parameters.
         * @return The query string.
         * @throws QuerySyntaxException If the query is invalid.
         */
        protected String getQuery() throws QuerySyntaxException
        {
            String query = "*:*";
            if (_queryString != null)
            {
                query = _queryString;
            }
            else if (_query != null)
            {
                query = _query.build();
            }
            return query;
        }
        
        /**
         * Get the filter queries from the parameters.
         * @return The list of filter queries.
         * @throws QuerySyntaxException If one of the queries is invalid.
         */
        protected List<String> getFilterQueries() throws QuerySyntaxException
        {
            List<String> filterQueries = new ArrayList<>();
            if (!_filterQueryStrings.isEmpty())
            {
                filterQueries = _filterQueryStrings;
            }
            
            if (!_filterQueries.isEmpty())
            {
                for (Query fq : _filterQueries)
                {
                    filterQueries.add(fq.build());
                }
            }
            
            return filterQueries;
        }
        
        /**
         * Get the solr query object.
         * @param query The solr query string.
         * @param filterQueries The filter queries (as Strings).
         * @param start The start index.
         * @param maxResults The maximum number of results.
         * @param searchContext The search context.
         * @param checkRights Whether to check rights when searching or not.
         * @param allowedUsersToCompare The {@link AllowedUsers} object to compare with for checking rights
         * @return The solr query object.
         * @throws Exception If an error occurs.
         */
        protected SolrQuery getSolrQuery(String query, Collection<String> filterQueries, int start, int maxResults, Map<String, Object> searchContext, boolean checkRights, AllowedUsers allowedUsersToCompare) throws Exception
        {
            SolrQuery solrQuery = new SolrQuery();
            
            String queryString = StringUtils.isNotBlank(query) ? query : "*:*";
            
            // Set the query string, pagination spec and fields to be returned.
            solrQuery.setQuery(queryString);
            solrQuery.setStart(start);
            solrQuery.setRows(maxResults);
            // Return only ID + score fields.
            solrQuery.setFields("id", "score");
            
            // Add filter queries.
            for (String fq : filterQueries)
            {
                solrQuery.addFilterQuery(fq);
            }
            
            if (checkRights)
            {
                _checkRightsQuery(solrQuery);
            }
            else if (allowedUsersToCompare != null)
            {
                _checkAllowedUsers(solrQuery, allowedUsersToCompare);
            }
            
            if (_debug)
            {
                solrQuery.setShowDebugInfo(true);
            }
            
            return solrQuery;
        }
        
        private void _checkRightsQuery(SolrQuery solrQuery)
        {
            StringBuilder aclFilterQuery = new StringBuilder("{!acl ");
            UserIdentity user = _currentUserProvider.getUser();
            if (user == null)
            {
                aclFilterQuery.append("anonymous=");
            }
            else
            {
                aclFilterQuery.append("populationId=");
                aclFilterQuery.append(user.getPopulationId());
                aclFilterQuery.append(" login=");
                aclFilterQuery.append(user.getLogin());
                Set<GroupIdentity> groups = _groupManager.getUserGroups(user);
                if (!groups.isEmpty())
                {
                    String groupsAsStr = groups.stream()
                            .map(GroupIdentity::groupIdentityToString)
                            .collect(Collectors.joining(","));
                    aclFilterQuery.append(" groups=").append('"');
                    aclFilterQuery.append(groupsAsStr).append('"');
                }
            }
            aclFilterQuery.append("}");
            // {!acl anonymous=} or {!acl populationId=users login=user1 groups="group1#groupDirectory,group2#groupDirectory"} to check acl
            solrQuery.addFilterQuery(aclFilterQuery.toString());
        }
        
        private void _checkAllowedUsers(SolrQuery solrQuery, AllowedUsers allowedUsersToCompare)
        {
            StringBuilder fq = new StringBuilder("{!aclCompare ");
            if (allowedUsersToCompare.isAnonymousAllowed())
            {
                fq.append("anonymous=true");
            }
            else
            {
                if (allowedUsersToCompare.isAnyConnectedUserAllowed())
                {
                    fq.append("anyConnected=true ");
                }
                Set<String> allowedUsers = allowedUsersToCompare.getAllowedUsers().stream().map(UserIdentity::userIdentityToString).collect(Collectors.toSet());
                Set<String> deniedUsers = allowedUsersToCompare.getDeniedUsers().stream().map(UserIdentity::userIdentityToString).collect(Collectors.toSet());
                Set<String> allowedGroups = allowedUsersToCompare.getAllowedGroups().stream().map(GroupIdentity::groupIdentityToString).collect(Collectors.toSet());
                Set<String> deniedGroups = allowedUsersToCompare.getDeniedGroups().stream().map(GroupIdentity::groupIdentityToString).collect(Collectors.toSet());
                if (!allowedUsers.isEmpty())
                {
                    fq.append("allowedUsers=").append(String.join(",", allowedUsers)).append(" ");
                }
                if (!deniedUsers.isEmpty())
                {
                    fq.append("deniedUsers=").append(String.join(",", deniedUsers)).append(" ");
                }
                if (!allowedGroups.isEmpty())
                {
                    fq.append("allowedGroups=").append(String.join(",", allowedGroups)).append(" ");
                }
                if (!deniedGroups.isEmpty())
                {
                    fq.append("deniedGroups=").append(String.join(",", deniedGroups));
                }
            }
            fq.append("}");
            solrQuery.addFilterQuery(fq.toString());
        }
        
        /**
         * Set the sort definition in the solr query object.
         * @param solrQuery The solr query object.
         * @param sortCriteria The sort criteria.
         */
        protected void setSort(SolrQuery solrQuery, List<Sort> sortCriteria)
        {
            if (sortCriteria.isEmpty())
            {
                solrQuery.addSort("score", ORDER.desc);
            }
            for (Sort sortCriterion : sortCriteria)
            {
                solrQuery.addSort(sortCriterion.getField(), sortCriterion.getOrder() == Order.ASC ? ORDER.asc : ORDER.desc);
            }
        }
        
        /**
         * Set the facet definition in the solr query object and return a mapping from solr field name to criterion ID.
         * @param solrQuery the solr query object to fill.
         * @param facets The facet definitions to use.
         * @param facetValues the facet values.
         */
        protected void setFacets(SolrQuery solrQuery, Collection<SearchField> facets, Map<String, List<String>> facetValues)
        {
            if (facets.size() > 0)
            {
                // unlimited facet values
                solrQuery.setFacetLimit(-1);
                solrQuery.setFacet(true);
                solrQuery.setFacetMinCount(1);
            }
            
            for (SearchField facetField : facets)
            {
                String fieldName = facetField.getName();
                String solrFieldName = facetField.getFacetField();
                
                if (StringUtils.isNotBlank(fieldName))
                {
                    if (facetField.isJoined())
                    {
                        _setJoinedFacet(solrQuery, fieldName, facetField.getJoinedPaths(), solrFieldName, facetField.getFacetFunction(), facetValues);
                    }
                    else
                    {
                        _setNonJoinedFacet(solrQuery, fieldName, solrFieldName, facetValues);
                    }
                }
            }
        }
        
        private void _setJoinedFacet(SolrQuery solrQuery, String fieldName, List<String> joinedPaths, String solrFieldName, String facetFunction, Map<String, List<String>> facetValues)
        {
            List<String> fieldFacetValues = facetValues.get(fieldName);
            if (fieldFacetValues != null && !fieldFacetValues.isEmpty())
            {
                StringBuilder fq = new StringBuilder();
                fq.append("{!tag=").append(fieldName).append("}(");
                
                int i = 0;
                fq.append("{!ametys join=").append(StringUtils.join(joinedPaths, "->")).append(" q=\"");
                for (String facetValue : fieldFacetValues)
                {
                    if (i > 0)
                    {
                        fq.append(" OR ");
                    }
                    fq.append(solrFieldName).append(":\\\"").append(facetValue).append("\\\"");
                    i++;
                }
                fq.append("\"})");
                solrQuery.addFilterQuery(fq.toString());
            }

            solrQuery.add("facet.function", "{!ex=" + fieldName + " key=" + fieldName + "}" + facetFunction);
        }
        
        private void _setNonJoinedFacet(SolrQuery solrQuery, String fieldName, String solrFieldName, Map<String, List<String>> facetValues)
        {
            List<String> fieldFacetValues = facetValues.get(fieldName);
            if (fieldFacetValues != null && !fieldFacetValues.isEmpty())
            {
                StringBuilder fq = new StringBuilder();
                fq.append("{!tag=").append(fieldName).append("}(");
                
                int i = 0;
                for (String facetValue : fieldFacetValues)
                {
                    if (i > 0)
                    {
                        fq.append(" OR ");
                    }
                    // TODO escape query chars?
                    fq.append(solrFieldName).append(":\"").append(facetValue).append('"');
                    i++;
                }
                fq.append(')');
                solrQuery.addFilterQuery(fq.toString());
            }
            
            String facetFieldDef = "{!ex=" + fieldName + " key=" + fieldName + "}" + solrFieldName;
            solrQuery.addFacetField(facetFieldDef);
        }
        
        /**
         * Retrieve the facet results from the solr response.
         * @param response the solr response.
         * @param facets The facet fields to return.
         * @return the facet results.
         */
        protected Map<String, Map<String, Integer>> getFacetResults(QueryResponse response, Collection<SearchField> facets)
        {
            Map<String, Map<String, Integer>> facetResults = new LinkedHashMap<>();
            
            for (SearchField facetField : facets)
            {
                String fieldName = facetField.getName();
                FacetField solrFacetField = response.getFacetField(fieldName);
                
                List<Count> values = solrFacetField.getValues();
                
                Map<String, Integer> solrFacetValues = new HashMap<>();
                facetResults.put(fieldName, solrFacetValues);
                
                for (Count count : values)
                {
                    solrFacetValues.put(count.getName(), (int) count.getCount());
                }
            }
            
            return facetResults;
        }
        
        /**
         * Template method to do additional operations on the Solr query before passing it to the Solr client
         * @param query the Solr query
         */
        protected void modifySolrQuery(SolrQuery query)
        {
            // do nothing by default
        }
    }
    
}