/*
 *  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.net.URLDecoder;
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 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.JoinableSearchField;
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.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
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 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);
    }
    
    @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;
        
        /**
         * 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;
        }
        
        /**
         * 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
        {
            Map<String, Map<String, Integer>> facetResults = getFacetResults(response, facets);
            return new SolrSearchResults<>(response, _resolver, facetResults);
        }
        
        private QueryResponse _querySolrServer() throws Exception
        {
            String query = getQuery();
            List<String> filterQueries = getFilterQueries();
            
            SolrQuery solrQuery = getSolrQuery(query, filterQueries, _start, _maxResults, _searchContext, _checkRights);
            
            // 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: " + URLDecoder.decode(solrQuery.toString(), "UTF-8"));
            }
            
            // Use POST to avoid problems with large requests.
            return _solrClient.query(_solrClientProvider.getCollectionName(), solrQuery, METHOD.POST);
        }
        
        /**
         * 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.
         * @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) 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)
            {
                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());
                }
                aclFilterQuery.append("}");
                // {!acl anonymous=} or {!acl populationId=users login=user1} to check acl
                solrQuery.addFilterQuery(aclFilterQuery.toString());
            }
            
            return solrQuery;
        }
        
        /**
         * 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);
            }
            
            for (SearchField facetField : facets)
            {
                String fieldName = facetField.getName();
                String solrFieldName = facetField.getFacetField();
                
                if (StringUtils.isNotBlank(fieldName))
                {
                    if (facetField instanceof JoinableSearchField && ((JoinableSearchField) facetField).isJoined())
                    {
                        _setJoinedFacet(solrQuery, fieldName, facetValues, (JoinableSearchField) facetField);
                    }
                    else
                    {
                        _setNonJoinedFacet(solrQuery, fieldName, solrFieldName, facetValues);
                    }
                }
            }
        }
        
        private void _setJoinedFacet(SolrQuery solrQuery, String fieldName, Map<String, List<String>> facetValues, JoinableSearchField metadataFacetField)
        {
            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(metadataFacetField.getJoinedPath()).append(" q=\"");
                for (String facetValue : fieldFacetValues)
                {
                    if (i > 0)
                    {
                        fq.append(" OR ");
                    }
                    fq.append(metadataFacetField.getFacetField()).append(":\\\"").append(facetValue).append("\\\"");
                    i++;
                }
                fq.append("\"})");
                solrQuery.addFilterQuery(fq.toString());
            }

            solrQuery.add("facet.function", "{!ex=" + fieldName + " key=" + fieldName + "}" + metadataFacetField.getFacetFunction());
        }
        
        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
        }
    }
    
}