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

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.cms.search.advanced.WrappedValue;
import org.ametys.web.frontoffice.search.metamodel.SearchCriterionDefinition;

/**
 * The mode of a {@link FOSearchCriterion}
 */
public enum FOSearchCriterionMode
{
    /**
     * The criterion is static, i.e. valued by the webmaster and is not a proposed criterion to the final user.
     */
    STATIC
    {
        @Override
        public FoWrappedValue getValue(FOSearchCriterion searchCriterion, Map<String, Object> userCriteria, Map<String, Object> contextualParameters)
        {
            Object staticValue = searchCriterion.getStaticValue().get();
            FoWrappedValue result = new FoWrappedValue(staticValue);
            __LOGGER.debug("Value for static criterion '{}': {}", searchCriterion.getId(), result);
            return result;
        }
    },
    
    /**
     * The criterion is proposed to the final user.
     */
    USER_INPUT
    {
        @Override
        public FoWrappedValue getValue(FOSearchCriterion searchCriterion, Map<String, Object> userCriteria, Map<String, Object> contextualParameters)
        {
            String criterionId = searchCriterion.getId();
            Object val = userCriteria.get(criterionId);
            SearchCriterionDefinition criterionDefinition = searchCriterion.getCriterionDefinition();
            if (val != null)
            {
                boolean requestEmptyValue = val.equals(NONE_VALUE) 
                        && !searchCriterion.isMandatory()
                        && criterionDefinition.isEnumerated();
                
                FoWrappedValue result = new FoWrappedValue(val, requestEmptyValue);
                __LOGGER.debug("Value from user for criterion '{}': {}", criterionId, result);
                return result;
            }
            
            // val is null
            // no need to build a collection of all existing entries of the enumerated values as all are allowed, and empty is allowed too => avoid an unnecessary query on the indexed field
            __LOGGER.debug("Value from user for criterion '{}': null", criterionId);
            return new FoWrappedValue(null);
        }
    },
    
    /**
     * The criterion is proposed to the final user, with a restricted enumeration of choices.
     */
    RESTRICTED_USER_INPUT
    {
        @Override
        public FoWrappedValue getValue(FOSearchCriterion searchCriterion, Map<String, Object> userCriteria, Map<String, Object> contextualParameters)
        {
            String criterionId = searchCriterion.getId();
            Object val = userCriteria.get(criterionId);
            if (val != null)
            {
                boolean requestEmptyValue = val.equals(NONE_VALUE) && !searchCriterion.isMandatory();
                FoWrappedValue result = new FoWrappedValue(val, requestEmptyValue);
                __LOGGER.debug("Value from user for (restricted) criterion '{}': {}", criterionId, result);
                return result;
            }
            else
            {
                // The criterion was not filled by the visitor
                // Consider it as the 'All' option to filter results matching with at least one value in the restricted values
                List<Object> vals = searchCriterion
                        .getRestrictedValues()
                        .get()
                        .values()
                        .keySet()
                        .stream()
                        .collect(Collectors.toList());
                
                boolean requestEmptyValue = !searchCriterion.isMandatory();
                FoWrappedValue result = new FoWrappedValue(vals, requestEmptyValue);
                __LOGGER.debug("Value for criterion '{}' (computed because not filled by user but is restricted): {}", criterionId, result);
                return result;
            }
        }
    },
    
    /**
     * The criterion is proposed for content profiled by user group tag.
     */
    PROFILED_GROUPS_TAGS_INPUT
    {
        @Override
        public FoWrappedValue getValue(FOSearchCriterion searchCriterion, Map<String, Object> userCriteria, Map<String, Object> contextualParameters)
        {
            return new FoWrappedValue(PROFILED_GROUPS_TAGS_VALUE);
        }
    };
    
    /** The none value */
    public static final String NONE_VALUE = "__ametys_none";
    
    /** The profiled groups tags value */
    public static final String PROFILED_GROUPS_TAGS_VALUE = "__ametys_profiled_groups_tags";
    
    static final Logger __LOGGER = LoggerFactory.getLogger(FOSearchCriterionMode.class);

    /**
     * Gets the value from the {@link FOSearchCriterion criterion} and the final user criteria.
     * @param searchCriterion The {@link FOSearchCriterion} which is in this mode
     * @param finalUserCriteria The criteria from the final user
     * @param contextualParameters The contextual parameters
     * @return the value
     */
    public abstract FoWrappedValue getValue(FOSearchCriterion searchCriterion, Map<String, Object> finalUserCriteria, Map<String, Object> contextualParameters);
    
    /**
     * <code>true</code> if the criterion is static
     * @return <code>true</code> if the criterion is static
     */
    public boolean isStatic()
    {
        return this.equals(STATIC) || this.equals(PROFILED_GROUPS_TAGS_INPUT);
    }
    
    /**
     * A {@link WrappedValue}, being the return type of {@link FOSearchCriterionMode#getValue}. It can notify for enumerated criteria if empty value need to be requested, through {@link #requestEmptyValue()}
     */
    public static final class FoWrappedValue extends WrappedValue
    {
        private final boolean _requestEmptyValue;
        
        private FoWrappedValue(Object value)
        {
            super(value);
            _requestEmptyValue = false;
        }
        
        private FoWrappedValue(Object values, boolean requestEmptyValue)
        {
            super(values);
            _requestEmptyValue = requestEmptyValue;
        }
        
        /**
         * <code>true</code> if the wrapped value is from enumerated and no mandatory data. The caller has selected none value or all value for restricted user input.
         * @return <code>true</code> if the wrapped value is from enumerated and no mandatory data. The caller has selected none value or all value for restricted user input.
         */
        public boolean requestEmptyValue()
        {
            return _requestEmptyValue;
        }
        
        @Override
        public String toString()
        {
            return super.toString() + "{requestEmptyValue:" + _requestEmptyValue + "}";
        }
    }
}