/*
 *  Copyright 2019 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.search.misc;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.NotQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.core.util.JSONUtils;
import org.ametys.web.repository.site.Site;
import org.ametys.web.search.query.SiteQuery;

import com.google.common.collect.ImmutableMap;

/**
 * Helper for getting a {@link SiteQuery} from a user-submitted value.
 */
public class SiteQueryHelper implements Component, Serviceable, Contextualizable
{
    /** Avalon Role */
    public static final String ROLE = SiteQueryHelper.class.getName();
    
    private JSONUtils _jsonUtils;
    private Context _context;
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
    }
    
    /**
     * Gets a {@link Query} testing {@link Site} from a user-submitted value
     * @param value a user-submitted value
     * @param operator The operator
     * @param contextualParameters  the search contextual parameters.
     * @param criterionId The criterion id (for logging purposes only)
     * @return The {@link Query}
     */
    @SuppressWarnings("unchecked")
    public Query getQuery(Object value, Operator operator, Map<String, Object> contextualParameters, String criterionId)
    {
        // Handles a list of given site names (SITES_LIST) as well as "CURRENT_SITE", "OTHER_SITES" and "SITES" (all sites).
        Map<String, Object> valueMap = _parseSite(value, criterionId);
        
        String context = (String) valueMap.get("context");
        
        Request request = ContextHelper.getRequest(_context);
        String currentSite = (String) request.getAttribute("siteName");
        if (StringUtils.isBlank(currentSite))
        {
            currentSite = (String) contextualParameters.get("siteName");
        }
        
        if ("CURRENT_SITE".equals(context))
        {
            return new SiteQuery(operator, currentSite);
        }
        else if ("OTHER_SITES".equals(context))
        {
            // other sites than current one
            // so 'normal case' (i.e. operator = EQ) is testing <NE current_site>
            // and 'NE case' is testing the opposite (site is not equal to other sites), <EQ current_site>
            return new AndQuery(
                    new SiteQuery(), 
                    new SiteQuery(Operator.NE == operator
                            ? Operator.EQ
                            : Operator.NE
                        , currentSite));
        }
        else if ("SITES".equals(context))
        {
            return Operator.NE == operator
                    ? new NotQuery(new SiteQuery())
                    : new SiteQuery();
        }
        
        // "SITES_LIST" context: get the site list from the value map.
        List<String> names = (List<String>) valueMap.get("sites");
        
        // Standard context: site list.
        return new SiteQuery(operator, names);
    }
    
    @SuppressWarnings("unchecked")
    private Map<String, Object> _parseSite(Object value, String criterionId)
    {
        if (value instanceof Map)
        {
            return (Map<String, Object>) value;
        }
        else if (value instanceof Collection)
        {
            String strValue = ((Collection<?>) value).stream()
                    .filter(String.class::isInstance)
                    .map(String.class::cast)
                    .collect(Collectors.joining(","));
            return _parseSite(strValue, criterionId);
        }
        else if (value instanceof String)
        {
            String strValue = (String) value;
            if (strValue.startsWith("{"))
            {
                // Usually when coming from BO site widget
                return _jsonUtils.convertJsonToMap(strValue);
            }
            else
            {
                // Consider it as the list of sites itself
                // Usually when coming from FO
                return ImmutableMap.of(
                        "context", "SITES_LIST", 
                        "sites", Arrays.asList(strValue.split(","))
                );
            }
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + criterionId + " is not a valid Site value.");
        }
    }
}