/*
 *  Copyright 2017 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;

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.Map.Entry;
import java.util.Optional;
import java.util.stream.Collectors;

import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.slf4j.Logger;

import org.ametys.cms.search.SearchField;
import org.ametys.cms.search.SearchResult;
import org.ametys.cms.search.SearchResults;
import org.ametys.cms.search.SearchResultsIterable;
import org.ametys.cms.search.solr.SearcherFactory;
import org.ametys.cms.search.solr.SolrSearchResults;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;

/**
 * {@link SearcherFactory} for creating a searcher for {@link AbstractSearchGenerator}
 */
public class FrontOfficeSearcherFactory extends SearcherFactory
{
    /** The component role. */
    @SuppressWarnings("hiding")
    public static final String ROLE = FrontOfficeSearcherFactory.class.getName();
    
    @Override
    public FrontOfficeSearcher create()
    {
        return new FrontOfficeSearcher(getLogger());
    }
    
    /**
     * Searcher for {@link AbstractSearchGenerator}
     */
    public class FrontOfficeSearcher extends Searcher
    {
        private Collection<QueryFacet> _queryFacets;
        private Collection<String> _queryFacetValues;
        
        /**
         * Build a Searcher with default values.
         * @param logger The logger.
         */
        protected FrontOfficeSearcher(Logger logger)
        {
            super(logger);
            _queryFacets = new ArrayList<>();
            _queryFacetValues = new HashSet<>();
        }
        
        /**
         * Sets the query facets (facet.query parameters)
         * @param queryFacets The facets
         * @return The Searcher object itself.
         */
        public FrontOfficeSearcher withQueryFacets(Collection<QueryFacet> queryFacets)
        {
            _queryFacets = new ArrayList<>(queryFacets);
            return this;
        }
        
        /**
         * Set the facet.query values
         * @param queryFacetValues The values
         * @return The Searcher object itself.
         */
        public FrontOfficeSearcher withQueryFacetValues(Collection<String> queryFacetValues)
        {
            _queryFacetValues = new HashSet<>(queryFacetValues);
            return this;
        }
        
        @Override
        protected void modifySolrQuery(SolrQuery query)
        {
            if (_queryFacets.size() > 0)
            {
                // unlimited facet values
                query.setFacetLimit(-1);
                query.setFacet(true);
            }
            
            _queryFacets.forEach(facet ->
            {
                String keyName = facet.getKeyName();
                String excludedTagName = facet.getExcludedTagName();
                String facetQuery = facet.getFacetQuery();
                boolean queryFacetValue = _queryFacetValues.contains(keyName);
                
                if (queryFacetValue)
                {
                    StringBuilder fq = new StringBuilder();
                    fq.append("{!tag=").append(excludedTagName)
                      .append("}(")
                      .append(facetQuery)
                      .append(')');
                    query.addFilterQuery(fq.toString());
                }
                
                query.addFacetQuery("{!ex=" + excludedTagName + " key=" + keyName + "}" + facetQuery);
            });
        }
        
        @Override
        public <A extends AmetysObject> SearchResults<A> _buildResults(QueryResponse response, List<SearchField> facets) throws Exception
        {
            SearchResults<A> wrappedRes = super._buildResults(response, facets);
            Collection<String> queryFacetKeys = _queryFacets.stream().map(QueryFacet::getKeyName).collect(Collectors.toList());
            Map<String, Integer> facetQueryResults = Optional.ofNullable(response.getFacetQuery())
                                                      .orElseGet(HashMap::new)
                                                      .entrySet()
                                                      .stream()
                                                      .filter(e -> queryFacetKeys.contains(e.getKey()))
                                                      .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
            return new FrontOfficeSolrSearchResults<>(wrappedRes, response, facetQueryResults);
        }
    }
    
    /**
     * Wraps a 'facet.query' parameter
     */
    public static class QueryFacet
    {
        private final String _keyName;
        private final String _excludedTagName;
        private final String _facetQuery;

        /**
         * Creates a QueryFacet
         * @param keyName The name of the query facet
         * @param excludedTagName The tag for exclusion for facet counting
         * @param facetQuery The value of the query
         */
        public QueryFacet(String keyName, String excludedTagName, String facetQuery)
        {
            _keyName = keyName;
            _excludedTagName = excludedTagName;
            _facetQuery = facetQuery;
        }

        /**
         * Gets the keyName
         * @return the keyName
         */
        public String getKeyName()
        {
            return _keyName;
        }

        /**
         * Gets the excludedTagName
         * @return the excludedTagName
         */
        public String getExcludedTagName()
        {
            return _excludedTagName;
        }

        /**
         * Gets the facetQuery
         * @return the _acetQuery
         */
        public String getFacetQuery()
        {
            return _facetQuery;
        }
    }
    
    /**
     * Wrapper of a {@link SolrSearchResults} for {@link AbstractSearchGenerator} (add the possibility to add facet.queries)
     * @param <A> the actual type of {@link AmetysObject}s. 
     */
    public static class FrontOfficeSolrSearchResults<A extends AmetysObject>/* extends SolrSearchResults<A>*/implements SearchResults<A>
    {
        private Map<String, Integer> _facetQueryResults;
        private SearchResults<A> _searchResults;
        
        /**
         * Build a FrontOfficeSolrSearchResults object.
         * @param searchResults The wrapped {@link SearchResults} object
         * @param response the solr search response.
         * @param facetQueryResults The facet.query results.
         */
        public FrontOfficeSolrSearchResults(SearchResults<A> searchResults, 
                                            QueryResponse response, 
                                            Map<String, Integer> facetQueryResults)
        {
            _searchResults = searchResults;
            _facetQueryResults = facetQueryResults;
        }
        
        @Override
        public SearchResultsIterable<SearchResult<A>> getResults()
        {
            return _searchResults.getResults();
        }
        
        @Override
        public AmetysObjectIterable<A> getObjects()
        {
            return _searchResults.getObjects();
        }
        
        @Override
        public Iterable<String> getObjectIds()
        {
            return _searchResults.getObjectIds();
        }
        
        @Override
        public Map<String, Map<String, Integer>> getFacetResults()
        {
            return _searchResults.getFacetResults();
        }
        
        /**
         * Gets the facet.query results as a Map
         * @return the facet.query results
         */
        public Map<String, Integer> getFacetQueryResults()
        {
            return Collections.unmodifiableMap(_facetQueryResults);
        }
        
        @Override
        public long getTotalCount()
        {
            return _searchResults.getTotalCount();
        }
        
        @Override
        public float getMaxScore()
        {
            return _searchResults.getMaxScore();
        }
        
        @Override
        public Optional<Map<String, Object>> getDebugMap()
        {
            return _searchResults.getDebugMap();
        }
    }
}