/*
 *  Copyright 2018 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.search.instance.model;

import java.lang.reflect.Constructor;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.MatchAllQuery;
import org.ametys.cms.search.query.MatchNoneQuery;
import org.ametys.cms.search.query.NotQuery;
import org.ametys.cms.search.query.OrQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.Query.LogicalOperator;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.query.TagQuery;
import org.ametys.web.frontoffice.search.metamodel.Returnable;
import org.ametys.web.frontoffice.search.metamodel.context.ContextQueriesWrapper;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.SitemapElement;
import org.ametys.web.repository.site.Site;
import org.ametys.web.search.query.ChildPageQuery;
import org.ametys.web.search.query.DescendantPageQuery;
import org.ametys.web.search.query.SiteQuery;

/**
 * A search context
 */
public class SearchContext
{
    private SiteContext _sites;
    private SitemapContext _sitemap;
    private ContextLang _langs;
    // keep id instead of real tag objects and then re-resolve them to avoid RepositoryException about session closed
    private List<String> _tagIds;
    private boolean _tagAutoposting;

    /**
     * Creates a SearchContext
     * @param sites The site context
     * @param sitemap The sitemap context
     * @param langs The lang of the context
     * @param tags The tags of the context
     * @param tagAutoposting <code>true</code> if search on tags should be with autoposting
     */
    public SearchContext(SiteContext sites,
            SitemapContext sitemap,
            ContextLang langs,
            List<String> tags,
            boolean tagAutoposting)
    {
        _sites = sites;
        _sitemap = sitemap;
        _langs = langs;
        _tagIds = tags;
        _tagAutoposting = tagAutoposting;
    }
    
    /**
     * Gets the site context
     * @return the site context
     */
    public SiteContext siteContext()
    {
        return _sites;
    }
    
    /**
     * Gets the sitemap context
     * @return the sitemap context
     */
    public SitemapContext sitemapContext()
    {
        return _sitemap;
    }
    
    /**
     * Gets the lang context
     * @return the lang context
     */
    public ContextLang langContext()
    {
        return _langs;
    }
    
    /**
     * Gets the tag context
     * @return the tag context
     */
    public Pair<List<String>, Boolean> tagContext()
    {
        return Pair.of(_tagIds, _tagAutoposting);
    }
    
    /**
     * Gets the query corresponding to the site part of the context
     * @param currentSite the current site
     * @return the query corresponding to the site part of the context
     */
    public Query getSiteQuery(Site currentSite)
    {
        String currentSiteName = currentSite.getName();
        switch (_sites.getType())
        {
            case CURRENT:
                // test is current
                return new SiteQuery(Operator.EQ, currentSiteName);
                
            case AMONG:
                // test is one of sites of SiteContext
                List<String> siteNames = _sites.getSites()
                    .get()
                    .stream()
                    .map(Site::getName)
                    .collect(Collectors.toList());
                return new SiteQuery(Operator.EQ, siteNames);
                
            case ALL:
                // test existence
                return new SiteQuery();
                
            case OTHERS:
                // test existence and is not current
                return new AndQuery(
                        new SiteQuery(),
                        new SiteQuery(Operator.NE, currentSiteName));
                
            default:
                throw new NotImplementedException("This SiteContextType is not handled: " + _sites.getType());
        }
    }
    
    /**
     * Gets the query corresponding to the sitemap part of the context
     * @param currentPage the current page
     * @return the query corresponding to the sitemap part of the context
     */
    public Query getSitemapQuery(SitemapElement currentPage)
    {
        Stream<Query> childPageQueriesStream;
        switch (_sitemap.getType())
        {
            case CURRENT_SITE:
                // Do nothing more
                return null;
                
            case CHILD_PAGES:
                return new DescendantPageQuery(currentPage.getId());
            case CHILD_PAGES_OF:
                childPageQueriesStream = _sitemap.getPages().get()
                        .stream()
                        .map(Page::getId)
                        .map(ancestorPageId -> new DescendantPageQuery(ancestorPageId));
                break;
            case DIRECT_CHILD_PAGES:
                return new ChildPageQuery(currentPage.getId());
            case DIRECT_CHILD_PAGES_OF:
                childPageQueriesStream = _sitemap.getPages().get()
                        .stream()
                        .map(Page::getId)
                        .map(parentPageId -> new ChildPageQuery(parentPageId));
                break;
            default:
                throw new NotImplementedException("This SitemapContextType is not handled: " + _sitemap.getType());
        }
        
        // If no selected page, we do not want any result => in this special case, return a MatchNoneQuery
        List<Query> childPageQueries = childPageQueriesStream.collect(Collectors.toList());
        return childPageQueries.isEmpty() ? new MatchNoneQuery() : new OrQuery(childPageQueries);
    }
    
    /**
     * Gets the {@link ContextLang} and the current lang
     * @param currentLang The current lang
     * @return the wrapper of the {@link ContextLang} and the current lang
     */
    public ContextLangAndCurrentLang getContextLang(String currentLang)
    {
        return new ContextLangAndCurrentLang(_langs, currentLang);
    }
    
    /**
     * Class wrapping a {@link ContextLang} and the current lang.
     * <br>Needed because at the time of the {@link ContextLangAndCurrentLang} constructor call, the Query cannot be created yet, even though the current lang is known (the {@link Returnable}s are responsible for creating the query via {@link LangQueryProducer})
     * @see LangQueryProducer
     * @see Returnable#filterReturnedDocumentQuery
     * @see ContextQueriesWrapper#getQuery
     */
    public static final class ContextLangAndCurrentLang
    {
        ContextLang _contextLangs;
        String _currentLang;

        ContextLangAndCurrentLang(ContextLang contextLangs, String currentLang)
        {
            _contextLangs = contextLangs;
            _currentLang = currentLang;
        }
    }
    
    /**
     * Class wrapping an implementation of {@link Query} in order to {@link #produce} the final query executed for limiting the context language for a given {@link Returnable}.
     * <br>Instances of this class should be created only in {@link Returnable#filterReturnedDocumentQuery} methods, and then passed to {@link ContextQueriesWrapper#getQuery}
     * @see Returnable#filterReturnedDocumentQuery
     * @see ContextQueriesWrapper#getQuery
     */
    public static final class LangQueryProducer
    {
        private Constructor< ? extends Query> _noArgConstructor;
        private Constructor< ? extends Query> _opAndStrConstructor;
        private boolean _acceptDocWithNolang;
        
        /**
         * Constructs a {@link LangQueryProducer}
         * <br>The given class must have at least two constructors:
         * <ul>
         * <li>one with no arguments in order to test {@link Operator#EXISTS  existence};</li>
         * <li>one with an {@link Operator} and an array of {@link String} values in order to test {@link Operator#EQ equality} of the current language.</li>
         * </ul>
         * @param languageQueryClass The implementation of {@link Query} for testing the lang
         * @param acceptDocWithNolang <code>true</code> to accept documents with no lang
         */
        public LangQueryProducer(Class<? extends Query> languageQueryClass, boolean acceptDocWithNolang)
        {
            try
            {
                _noArgConstructor = languageQueryClass.getConstructor();
                _opAndStrConstructor = languageQueryClass.getConstructor(Operator.class, String[].class);
            }
            catch (NoSuchMethodException | SecurityException e)
            {
                throw new IllegalArgumentException("The provided class is not valid. It should have a no arg constructor, and a constructor with an Operator and String...", e);
            }
            _acceptDocWithNolang = acceptDocWithNolang;
        }
        
        /**
         * Produces the Query for testing the context language
         * @param contextLangAndCurrentLang The wrapper of the {@link ContextLang} and the real current language
         * @return a {@link Query}
         * @throws Exception if an error occurs
         */
        public final Query produce(ContextLangAndCurrentLang contextLangAndCurrentLang) throws Exception
        {
            String currentLang = contextLangAndCurrentLang._currentLang;
            ContextLang contextLang = contextLangAndCurrentLang._contextLangs;
            
            Query equalityQuery = _opAndStrConstructor.newInstance(Operator.EQ, new String[] {currentLang});
            Query nonEqualityQuery = _opAndStrConstructor.newInstance(Operator.NE, new String[] {currentLang});
            Query existenceQuery = _noArgConstructor.newInstance();
            Query nonExistenceQuery = new NotQuery(existenceQuery);
            
            switch (contextLang)
            {
                case CURRENT:
                    if (_acceptDocWithNolang)
                    {
                        // test is current, or not present
                        return new OrQuery(equalityQuery, nonExistenceQuery);
                    }
                    else
                    {
                        // test is current
                        return equalityQuery;
                    }
                    
                case OTHERS:
                    if (_acceptDocWithNolang)
                    {
                        // is not current (we do not care about existence)
                        return nonEqualityQuery;
                    }
                    else
                    {
                        // test existence and is not current
                        return new AndQuery(nonEqualityQuery, existenceQuery);
                    }
                    
                case ALL:
                    if (_acceptDocWithNolang)
                    {
                        // nothing to test, whether the doc has or not the lang field, it is accepted
                        return new MatchAllQuery();
                    }
                    else
                    {
                        // test existence 
                        return existenceQuery;
                    }
                    
                default:
                    throw new NotImplementedException("This ContextLang is not handled: " + contextLang);
            }
        }
    }
    
    /**
     * Gets the query corresponding to the tag part of the context
     * @return the query corresponding to the tag part of the context
     */
    public Query getTagQuery()
    {
        return _tagIds.isEmpty() ? null : new TagQuery(Operator.EQ, _tagAutoposting, LogicalOperator.AND, _tagIds.toArray(new String[_tagIds.size()]));
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((_langs == null) ? 0 : _langs.hashCode());
        result = prime * result + ((_sitemap == null) ? 0 : _sitemap.hashCode());
        result = prime * result + ((_sites == null) ? 0 : _sites.hashCode());
        result = prime * result + (_tagAutoposting ? 1231 : 1237);
        result = prime * result + ((_tagIds == null) ? 0 : _tagIds.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (!(obj instanceof SearchContext))
        {
            return false;
        }
        SearchContext other = (SearchContext) obj;
        if (_langs != other._langs)
        {
            return false;
        }
        if (_sitemap == null)
        {
            if (other._sitemap != null)
            {
                return false;
            }
        }
        else if (!_sitemap.equals(other._sitemap))
        {
            return false;
        }
        if (_sites == null)
        {
            if (other._sites != null)
            {
                return false;
            }
        }
        else if (!_sites.equals(other._sites))
        {
            return false;
        }
        if (_tagAutoposting != other._tagAutoposting)
        {
            return false;
        }
        if (_tagIds == null)
        {
            if (other._tagIds != null)
            {
                return false;
            }
        }
        else if (!_tagIds.equals(other._tagIds))
        {
            return false;
        }
        return true;
    }
}