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

import org.apache.solr.client.solrj.request.json.DomainMap;
import org.apache.solr.client.solrj.request.json.JsonQueryRequest;
import org.apache.solr.client.solrj.request.json.QueryFacetMap;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.json.NestableJsonFacet;
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(JsonQueryRequest solrQuery)
        {
            _queryFacets.forEach(facet ->
            {
                String keyName = facet.getKeyName();
                String excludedTagName = facet.getExcludedTagName();
                String facetQuery = facet.getFacetQuery();

                boolean queryFacetValue = _queryFacetValues.contains(keyName);
                
                if (queryFacetValue)
                {
                    solrQuery.withFilter(Map.of("#" + excludedTagName, facetQuery));
                }
                
                QueryFacetMap facetMap = new QueryFacetMap(facetQuery).withDomain(new DomainMap().withTagsToExclude(excludedTagName));
                
                solrQuery.withFacet(keyName, facetMap);
            });
        }
        
        @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 = new HashMap<>();
            NestableJsonFacet facetingResponse = response.getJsonFacetingResponse();
            if (facetingResponse != null)
            {
                for (String query : facetingResponse.getQueryFacetNames())
                {
                    if (queryFacetKeys.contains(query))
                    {
                        facetQueryResults.put(query, (int) facetingResponse.getQueryFacet(query).getCount());
                    }
                }
            }

            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();
        }
    }
}