/*
 *  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.ContentTypeQuery;
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 <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(new ContentTypeQuery(_contentTypes));
            }
            
            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);
//                SearchField searchField = 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.";
        }
        
//        /**
//         * Get a {@link SearchField} from a field name.
//         * @param fieldName The field name, can be either a system property ID or a metadata path (not joined).
//         * @return The {@link SearchField} corresponding to the 
//         */
//        public SearchField getSearchField(Collection<String> contentTypes, String fieldName)
//        {
//            SearchField searchField = null;
//            
//            if (_sysPropEP.hasExtension(fieldName))
//            {
//                SystemProperty property = _sysPropEP.getExtension(fieldName);
//                searchField = property.getSearchField();
//            }
//            else
//            {
//                String metadataPath = fieldName.replace('.', '/');
//                _searchHelper.getMetadataSearchField(contentTypes, metadataPath);
//            }
//            
//            return searchField;
//        }
        
//        /**
//         * Get a {@link SearchField} from a field name.
//         * @param fieldName The field name, can be either a system property ID or a metadata path (not joined).
//         * @return The {@link SearchField} corresponding to the 
//         */
//        protected SearchField getSearchField(String fieldName)
//        {
//            SearchField searchField = null;
//            
//            if (_sysPropEP.hasExtension(fieldName))
//            {
//                SystemProperty property = _sysPropEP.getExtension(fieldName);
//                searchField = property.getSearchField();
//            }
//            else
//            {
//                String metaPath = fieldName.replace('.', '/');
//                if (_contentTypeId != null)
//                {
//                    ContentType cType = _cTypeEP.getExtension(_contentTypeId);
//                    List<MetadataDefinition> metaDefs = _cTypeHelper.getMetadataDefinitionsByPath(cType, metaPath);
//                    
//                    boolean joinedMetadata = isJoinedMetadata(metaDefs);
//                    
//                    if (!joinedMetadata)
//                    {
//                        MetadataType type = metaDefs.get(metaDefs.size() - 1).getType();
//                        searchField = IndexingFieldSearchUICriterion.getSearchField(fieldName, type);
//                    }
//                    else
//                    {
//                        throw new IllegalArgumentException("The metadata '" + fieldName + "' can't be used as it is joined.");
//                    }
//                }
//                else if (fieldName.equals("title"))
//                {
//                    // No specific content type: allow only title.
//                    // TODO Provide a standard "title" metadata definition to avoid getting it on a random content type.
//                    ContentType cType = _cTypeEP.getExtension(_contentTypes.iterator().next());
//                    MetadataDefinition metaDef = cType.getMetadataDefinition("title");
//                    searchField = IndexingFieldSearchUICriterion.getSearchField(fieldName, metaDef.getType());
//                }
//            }
//            
//            if (searchField == null)
//            {
//                throw new IllegalArgumentException("The field '" + fieldName + "' can't be found in the selected content types.");
//            }
//            
//            return searchField;
//        }
//        
//        /**
//         * Test if a metadata, represented by a list of successive definitions, is joined.
//         * @param metaDefs The list of successive definitions.
//         * @return <code>true</code> if the metadata is joined, <code>false</code> otherwise.
//         */
//        protected boolean isJoinedMetadata(List<MetadataDefinition> metaDefs)
//        {
//            boolean joinedMetadata = false;
//            Iterator<MetadataDefinition> metaDefIt = metaDefs.iterator();
//            while (metaDefIt.hasNext())
//            {
//                MetadataType type = metaDefIt.next().getType();
//                // The column represents a "joined" value if it has a content metadata (except if it's the last one).
//                if ((type == MetadataType.CONTENT || type == MetadataType.SUB_CONTENT) && metaDefIt.hasNext())
//                {
//                    joinedMetadata = true;
//                }
//            }
//            return joinedMetadata;
//        }
        
    }
    
}