/*
 *  Copyright 2020 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.metamodel.impl;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import org.apache.avalon.framework.service.ServiceException;

import org.ametys.cms.data.type.indexing.IndexableElementType;
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.Operator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.runtime.parameter.DefaultValidator;
import org.ametys.runtime.parameter.Validator;
import org.ametys.web.frontoffice.search.metamodel.RestrictedEnumerator;
import org.ametys.web.frontoffice.search.metamodel.SearchServiceCriterionDefinition;
import org.ametys.web.repository.page.Page;
import org.ametys.web.search.query.PageQuery;

/**
 * {@link SearchServiceCriterionDefinition} proposing a criterion definition on the page of the indexed document.
 */
public class PageCriterionDefinition extends AbstractSearchServiceCriterionDefinition<String>
{
    /** The ametys object resolver */
    private AmetysObjectResolver _resolver;
    
    @Override
    protected boolean isTooBigForStaticEnumerator() 
    {
        return true;
    }
    
    @Override
    public RestrictedEnumerator<String> getRestrictedEnumerator(Map<String, Object> contextualParameters)
    {
        return new PageEnumeratedValues(_getAmetysObjectResolver());
    }
    
    @Override
    public String getWidget()
    {
        return "edition.select-page";
    }
    
    @Override
    public Map<String, I18nizableText> getWidgetParameters()
    {
        Map<String, I18nizableText> parameters = new HashMap<>();
        parameters.put("siteContext", new I18nizableText("all"));
        
        return parameters;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public IndexableElementType<String> getType()
    {
        String typeId = ModelItemTypeConstants.STRING_TYPE_ID;
        return (IndexableElementType<String>) _getCriterionTypeExtensionPoint().getExtension(typeId);
    }
    
    @Override
    public Query getQuery(Object value, Operator operator, Map<String, Object> allValues, String language, Map<String, Object> contextualParameters)
    {
        String[] pageIds;
        if (value instanceof String)
        {
            pageIds = ((String) value).split(",");
        }
        else if (value instanceof Collection<?>)
        {
            pageIds = ((Collection<?>) value)
                    .stream()
                    .filter(String.class::isInstance)
                    .map(String.class::cast)
                    .toArray(String[]::new);
        }
        else
        {
            throw new IllegalArgumentException("Not handled type of value: '" + value + "'");
        }
        
        List<Query> queries = new ArrayList<>();
        for (String pageId : pageIds)
        {
            queries.add(new PageQuery(pageId, true));
        }
        
        OrQuery orQuery = new OrQuery(queries);
        return operator == Operator.NE ? new NotQuery(orQuery) : orQuery;
    }
    
    static class PageEnumeratedValues implements RestrictedEnumerator<String>
    {
        /** The ametys object resolver */
        private AmetysObjectResolver _resolver;
        
        public PageEnumeratedValues(AmetysObjectResolver resolver)
        {
            this._resolver = resolver;
        }
        
        public Map<String, I18nizableText> getEntries()  throws Exception
        {
            // Never calculate all values because too many page can be display
            return new HashMap<>();
        }

        public RestrictedValues<String> getRestrictedEntriesFor(List<String> objs)
        {
            return new PageRestrictedValues(objs, this._resolver);
        }
        
        static class PageRestrictedValues implements RestrictedValues<String>
        {
            private List<String> _forObjs;
            private AmetysObjectResolver _resolver;
            
            PageRestrictedValues(List<String> forObjs, AmetysObjectResolver resolver)
            {
                this._forObjs = forObjs;
                this._resolver = resolver;
            }
            
            @Override
            public Map<String, I18nizableText> values()
            {
                return this._forObjs.stream()
                    .filter(String.class::isInstance)
                    .map(String.class::cast)
                    .map(this::_getPage)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(Page::getId, page -> new I18nizableText(page.getTitle())));
            }
            
            private Page _getPage(String pageId)
            {
                try
                {
                    return this._resolver.resolveById(pageId);
                }
                catch (UnknownAmetysObjectException e) 
                {
                    return null;
                }
            }
        }
    }

    @Override
    public Validator getValidator()
    {
        return new DefaultValidator(null, true);
    }
    
    @Override
    public Query getEmptyValueQuery(String language, Map<String, Object> contextualParameters)
    {
        throw new UnsupportedOperationException("This method should not be called on the criteria PageCriterionDefinition");
    }
    
    /**
     * Retrieves the {@link AmetysObjectResolver}
     * @return the {@link AmetysObjectResolver}
     */
    protected AmetysObjectResolver _getAmetysObjectResolver()
    {
        if (_resolver == null)
        {
            try
            {
                _resolver = (AmetysObjectResolver) __serviceManager.lookup(AmetysObjectResolver.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException("Unable to lookup after the ametys object resolver", e);
            }
        }
        
        return _resolver;
    }
}