/*
 *  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.content;

import java.util.ArrayList;
import java.util.Arrays;
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.Set;

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.ametys.cms.content.indexing.solr.SolrFieldNames;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.QueryBuilder;
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.model.ResultField;
import org.ametys.cms.search.model.SearchCriterion;
import org.ametys.cms.search.model.SearchModel;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.query.DocumentTypeQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.solr.SearcherFactory;
import org.ametys.cms.search.solr.SearcherFactory.Searcher;
import org.ametys.cms.search.ui.model.SearchUIModel;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component creating content searchers from {@link SearchModel}s or content type IDs.
 */
public class ContentSearcherFactory extends AbstractLogEnabled implements Component, Serviceable
{
    
    /** The component role. */
    public static final String ROLE = ContentSearcherFactory.class.getName();
    
    /** The searcher factory. */
    protected SearcherFactory _searcherFactory;
    
    /** The query builder. */
    protected QueryBuilder _queryBuilder;
    
    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _sysPropEP;
    
    /** The search helper. */
    protected ContentSearchHelper _searchHelper;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _searcherFactory = (SearcherFactory) manager.lookup(SearcherFactory.ROLE);
        _queryBuilder = (QueryBuilder) manager.lookup(QueryBuilder.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _sysPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
        
        _searchHelper = (ContentSearchHelper) manager.lookup(ContentSearchHelper.ROLE);
    }
    
    /**
     * Create a ContentSearcher from a search model.
     * @param searchModel The reference search model.
     * @return a ContentSearcher backed by the given search model.
     */
    public SearchModelContentSearcher create(SearchModel searchModel)
    {
        return new SearchModelContentSearcher(searchModel);
    }
    
    /**
     * Create a simple ContentSearcher from a list of content types.
     * @param contentTypes The content types to search on.
     * @return a ContentSearcher referencing the given content types.
     */
    public SimpleContentSearcher create(String... contentTypes)
    {
        return new SimpleContentSearcher(Arrays.asList(contentTypes));
    }
    
    /**
     * Create a simple ContentSearcher from a list of content types.
     * @param contentTypes The content types to search on.
     * @return a ContentSearcher referencing the given content types.
     */
    public SimpleContentSearcher create(Collection<String> contentTypes)
    {
        return new SimpleContentSearcher(contentTypes);
    }
    
    /**
     * A ContentSearcher backed by a {@link SearchModel}.
     */
    public class SearchModelContentSearcher
    {
        private SearchUIModel _searchModel;
        private List<Sort> _sort;
        private String _searchMode;
        private int _start;
        private int _maxResults;
        private boolean _checkRights;
        
        /**
         * Build a ContentSearcher referencing a {@link SearchModel}.
         * @param searchModel the {@link SearchModel}.
         */
        public SearchModelContentSearcher(SearchModel searchModel)
        {
            // TODO Do not cast.
            this._searchModel = (SearchUIModel) searchModel;
            this._sort = new ArrayList<>();
            this._searchMode = "simple";
            this._start = 0;
            this._maxResults = Integer.MAX_VALUE;
            this._checkRights = true;
        }
        
        /**
         * Add a sort criterion.
         * @param fieldRef The field reference (name of a SearchField).
         * @param order The sort order.
         * @return The ContentSearcher itself.
         */
        public SearchModelContentSearcher addSort(String fieldRef, Order order)
        {
            _sort.add(new Sort(fieldRef, order));
            return this;
        }
        
        /**
         * Set the sort criteria.
         * @param sortCriteria The sort criteria as a List.
         * @return The ContentSearcher itself.
         */
        public SearchModelContentSearcher withSort(List<Sort> sortCriteria)
        {
            _sort = new ArrayList<>(sortCriteria);
            return this;
        }
        
        /**
         * Set the search mode.
         * @param searchMode The search mode.
         * @return The ContentSearcher itself.
         */
        public SearchModelContentSearcher withSearchMode(String searchMode)
        {
            _searchMode = searchMode;
            return this;
        }
        
        /**
         * Set the limits to use.
         * @param start The start index.
         * @param maxResults The maximum number of results.
         * @return The ContentSearcher itself.
         */
        public SearchModelContentSearcher withLimits(int start, int maxResults)
        {
            this._start = start;
            this._maxResults = maxResults;
            return this;
        }
        
        /**
         * Whether to check rights when searching, false otherwise.
         * @param checkRights <code>true</code> to check rights, <code>false</code> otherwise.
         * @return The ContentSearcher itself.
         */
        public SearchModelContentSearcher setCheckRights(boolean checkRights)
        {
            _checkRights = checkRights;
            return this;
        }
        
        /**
         * Search the contents.
         * @param values The values for search criteria defined in the model.
         * @param <C> The type Content
         * @return The search results as {@link AmetysObject}s.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> AmetysObjectIterable<C> search(Map<String, Object> values) throws Exception
        {
            return _searcher(values, Collections.emptyMap(), Collections.emptyMap()).search();
        }
        
        /**
         * Search the contents.
         * @param values The values for search criteria defined in the model.
         * @param contextualParameters The search contextual parameters.
         * @param <C> The type Content
         * @return The search results as {@link AmetysObject}s.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> AmetysObjectIterable<C> search(Map<String, Object> values, Map<String, Object> contextualParameters) throws Exception
        {
            return _searcher(values, Collections.emptyMap(), contextualParameters).search();
        }
        
        /**
         * Search the contents.
         * @param values The values for search criteria defined in the model.
         * @param <C> The type Content         * 
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(Map<String, Object> values) throws Exception
        {
            return searchWithFacets(values, Collections.emptyMap());
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param values The values for search criteria defined in the model.
         * @param contextualParameters The search contextual parameters.
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(Map<String, Object> values, Map<String, Object> contextualParameters) throws Exception
        {
            return searchWithFacets(values, Collections.emptyMap(), contextualParameters);
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param values The values for search criteria defined in the model.
         * @param facetValues The facet values, indexed 
         * @param contextualParameters The search contextual parameters. 
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(Map<String, Object> values, Map<String, List<String>> facetValues, Map<String, Object> contextualParameters) throws Exception
        {
            return _searcher(values, facetValues, contextualParameters).searchWithFacets();
        }
        
        private Searcher _searcher(Map<String, Object> values, Map<String, List<String>> facetValues, Map<String, Object> contextualParameters)
        {
            Query query = _queryBuilder.build(_searchModel, _searchMode, true, values, contextualParameters);
            
            List<Sort> sort = getSort(contextualParameters);
            List<SearchField> facets = getFacets(contextualParameters);
            
            return _searcherFactory.create()
                                    .withQuery(query)
                                    .withFilterQueries(new DocumentTypeQuery(SolrFieldNames.TYPE_CONTENT))
                                    .withSort(sort)
                                    .withFacets(facets)
                                    .withFacetValues(facetValues)
                                    .withLimits(_start, _maxResults)
                                    .setCheckRights(_checkRights);
        }
        
        /**
         * Get the sort criteria.
         * @param contextualParameters The search contextual parameters.
         * @return The sort criteria.
         */
        @SuppressWarnings("synthetic-access")
        protected List<Sort> getSort(Map<String, Object> contextualParameters)
        {
            List<Sort> sort = new ArrayList<>();
            
            if (!_sort.isEmpty())
            {
                // Index criterion and results by search field name.
                Map<String, SearchCriterion> criteriaByName = new HashMap<>();
                for (SearchCriterion criterion : _searchModel.getCriteria(contextualParameters).values())
                {
                    if (criterion.getSearchField() != null)
                    {
                        criteriaByName.put(criterion.getSearchField().getName(), criterion);
                    }
                }
                Map<String, ResultField> resultsByName = new HashMap<>();
                for (ResultField resultField : _searchModel.getResultFields(contextualParameters).values())
                {
                    if (resultField.getSearchField() != null)
                    {
                        resultsByName.put(resultField.getSearchField().getName(), resultField);
                    }
                }
                
                for (Sort sortCriterion : _sort)
                {
                    String id = sortCriterion.getField();
                    
                    SearchField searchField = null;
                    if (criteriaByName.containsKey(id))
                    {
                        searchField = criteriaByName.get(id).getSearchField();
                    }
                    else if (resultsByName.containsKey(id))
                    {
                        searchField = resultsByName.get(id).getSearchField();
                    }
                    
                    if (searchField == null)
                    {
                        throw new IllegalArgumentException("The field '" + id + "' can't be found in the selected search model.");
                    }
                    else if (searchField.getSortField() == null)
                    {
                        getLogger().warn("The field '{}' is not sortable. The search will execute, but without the sort on this field.", id);
                    }
                    else
                    {
                        sort.add(new Sort(searchField, sortCriterion.getOrder()));
                    }
                }
            }
            else
            {
                // Get the default sort from the search model.
            }
            
            return sort;
        }
        
        /**
         * Get the facet fields.
         * @param contextualParameters The search contextual parameters.
         * @return The facet fields as a List.
         */
        protected List<SearchField> getFacets(Map<String, Object> contextualParameters)
        {
            List<SearchField> facets = new ArrayList<>();
            
            for (SearchCriterion criterion : _searchModel.getFacetedCriteria(contextualParameters).values())
            {
                if (criterion.getSearchField() != null)
                {
                    facets.add(criterion.getSearchField());
                }
            }
            
            return facets;
        }
        
    }
    
    /**
     * A ContentSearcher on a list of content types.
     */
    public class SimpleContentSearcher
    {
        
        private Set<String> _contentTypes;
        private List<Sort> _sort;
        private List<String> _facets;
        private int _start;
        private int _maxResults;
        private boolean _checkRights;
        private List<String> _filterQueryStrings;
        private List<Query> _filterQueries;
        
        /**
         * Build a content searcher on a list of content types.
         * @param contentTypes A collection of content types to search on.
         */
        public SimpleContentSearcher(Collection<String> contentTypes)
        {
            this._contentTypes = contentTypes != null ? new HashSet<>(contentTypes) : Collections.emptySet();
            this._sort = new ArrayList<>();
            this._facets = new ArrayList<>();
            this._start = 0;
            this._maxResults = Integer.MAX_VALUE;
            this._checkRights = true;
        }
        
        /**
         * Set the filter queries.
         * @param filterQueries the filter queries.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withFilterQueries(List<Query> filterQueries)
        {
            _filterQueries = filterQueries;
            return this;
        }
        
        /**
         * Set the filter queries.
         * @param filterQueryStrings the filter queries.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withFilterQueryStrings(List<String> filterQueryStrings)
        {
            _filterQueryStrings = filterQueryStrings;
            return this;
        }
        
        /**
         * Set the sort criteria.
         * @param sortCriteria The sort criteria as a List.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withSort(List<Sort> sortCriteria)
        {
            _sort = new ArrayList<>(sortCriteria);
            return this;
        }
        
        /**
         * Add a sort criterion.
         * @param fieldRef The field reference (name of a SearchField).
         * @param order The sort order.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher addSort(String fieldRef, Order order)
        {
            _sort.add(new Sort(fieldRef, order));
            return this;
        }
        
        /**
         * Set the facets.
         * @param facets The facets list.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withFacets(Collection<String> facets)
        {
            _facets = new ArrayList<>(facets);
            return this;
        }
        
        /**
         * Set the facets.
         * @param facets The facets list.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withFacets(String... facets)
        {
            _facets = Arrays.asList(facets);
            return this;
        }
        
        /**
         * Set the limits to use.
         * @param start The start index.
         * @param maxResults The maximum number of results.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher withLimits(int start, int maxResults)
        {
            this._start = start;
            this._maxResults = maxResults;
            return this;
        }
        
        /**
         * Whether to check rights when searching, false otherwise.
         * @param checkRights <code>true</code> to check rights, <code>false</code> otherwise.
         * @return The ContentSearcher itself.
         */
        public SimpleContentSearcher setCheckRights(boolean checkRights)
        {
            _checkRights = checkRights;
            return this;
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query object to execute.
         * @return The search results as {@link AmetysObject}s.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> AmetysObjectIterable<C> search(Query query) throws Exception
        {
            return _searcher(query, Collections.emptyMap()).search();
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query string to execute.
         * @return The search results as {@link AmetysObject}s.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> AmetysObjectIterable<C> search(String query) throws Exception
        {
            return _searcher(query, Collections.emptyMap()).search();
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query objet to execute.
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(Query query) throws Exception
        {
            return searchWithFacets(query, Collections.emptyMap());
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query string to execute.
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(String query) throws Exception
        {
            return searchWithFacets(query, Collections.emptyMap());
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query object to execute.
         * @param facetValues The facet values.
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(Query query, Map<String, List<String>> facetValues) throws Exception
        {
            return _searcher(query, facetValues).searchWithFacets();
        }
        
        /**
         * Search the contents.
         * @param <C> The type Content
         * @param query The query string to execute.
         * @param facetValues The facet values.
         * @return The search results.
         * @throws Exception if an error occurs.
         */
        public <C extends Content> SearchResults<C> searchWithFacets(String query, Map<String, List<String>> facetValues) throws Exception
        {
            return _searcher(query, facetValues).searchWithFacets();
        }
        
        private Searcher _searcher(String query, Map<String, List<String>> facetValues)
        {
            return _searcher(facetValues).withQueryString(query);
        }
        
        private Searcher _searcher(Query query, Map<String, List<String>> facetValues)
        {
            return _searcher(facetValues).withQuery(query);
        }
        
        private Searcher _searcher(Map<String, List<String>> facetValues)
        {
            List<Sort> sort = getSort();
            List<SearchField> facets = getFacets();
            
            List<Query> filterQueries = new ArrayList<>();
            filterQueries.add(new DocumentTypeQuery(SolrFieldNames.TYPE_CONTENT));
            
            if (!_contentTypes.isEmpty())
            {
                filterQueries.add(_queryBuilder.createContentTypeOrMixinQuery(_contentTypes, null, true));
            }
            
            if (_filterQueries != null)
            {
                filterQueries.addAll(_filterQueries);
            }
            
            List<String> filterQueryStrings = new ArrayList<>();
            
            if (_filterQueryStrings != null)
            {
                filterQueryStrings.addAll(_filterQueryStrings);
            }
            
            return _searcherFactory.create()
                                   .withFilterQueries(filterQueries)
                                   .withFilterQueryStrings(filterQueryStrings)
                                   .withSort(sort)
                                   .withFacets(facets)
                                   .withFacetValues(facetValues)
                                   .withLimits(_start, _maxResults)
                                   .setCheckRights(_checkRights);
        }
        
        /**
         * Get the sort criteria from the specified field names.
         * @return The sort criteria.
         */
        protected List<Sort> getSort()
        {
            List<Sort> sortCriteria = new ArrayList<>();
            
            for (Sort sort : _sort)
            {
                String fieldName = sort.getField();
                Order order = sort.getOrder();
                
                Optional<SearchField> searchField = _searchHelper.getSearchField(_contentTypes, fieldName);
//                SearchField searchField = getSearchField(_contentTypes, fieldName);
                if (searchField.isPresent())
                {
                    sortCriteria.add(new Sort(searchField.get(), order));
                }
                else
                {
                    throw new IllegalArgumentException(_exceptionMessageForEmptySearchField(fieldName));
                }
            }
            
            return sortCriteria;
        }
        
        /**
         * Get the facet criteria as a list of SearchField from the specified field names.
         * @return The facets as a List of SearchField. 
         */
        protected List<SearchField> getFacets()
        {
            List<SearchField> facets = new ArrayList<>();
            
            for (String fieldName : _facets)
            {
                Optional<SearchField> searchField = _searchHelper.getSearchField(_contentTypes, fieldName);
                if (searchField.isPresent())
                {
                    facets.add(searchField.get());
                }
                else
                {
                    throw new IllegalArgumentException(_exceptionMessageForEmptySearchField(fieldName));
                }
            }
            
            return facets;
        }
        
        private String _exceptionMessageForEmptySearchField(String fieldName)
        {
            return "The field '" + fieldName + "' can't be found in the selected content types.";
        }
    }
}