/*
 *  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.cms.search.advanced;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.util.ClientUtils;

import org.ametys.cms.search.QueryBuilder;
import org.ametys.cms.search.query.NotQuery;
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.runtime.plugin.component.AbstractLogEnabled;

/**
 * Creates a {@link AbstractTreeNode} from a JSON object, typically got from client-side AdvancedSearchFormPanel.
 */
public class TreeMaker extends AbstractLogEnabled implements Component
{
    /** The component role. */
    public static final String ROLE = TreeMaker.class.getName();
    
    /**
     * Creates a {@link AbstractTreeNode} from JSON values
     * @param <T> the type of the values of the leaves of the tree to create
     * @param values the JSON values
     * @param leafValueMaker The function to create the value of a {@link TreeLeaf}
     * @return the created {@link AbstractTreeNode} from JSON values
     */
    public <T> AbstractTreeNode<T> create(Map<String, Object> values, Function<ClientSideCriterionWrapper, T> leafValueMaker)
    {
        return _create(values, leafValueMaker);
    }
    
    private <T> AbstractTreeNode<T> _create(Map<String, Object> values, Function<ClientSideCriterionWrapper, T> leafValueMaker)
    {
        String type = (String) values.get("type");

        if ("criterion".equals(type))
        {
            // Criterion node: create a leaf
            String id = (String) values.get("id");
            Object value = values.get("value");
            String op = (String) values.get("op");

            ClientSideCriterionWrapper clientSideCriterionWrapper = new ClientSideCriterionWrapper(id, value, op, values);
            return new TreeLeaf<>(leafValueMaker.apply(clientSideCriterionWrapper));
        }
        else if ("and".equalsIgnoreCase(type) || "or".equalsIgnoreCase(type))
        {
            // AND/OR node: create an internal node
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> expressions = (List<Map<String, Object>>) values.get("expressions");
            List<AbstractTreeNode<T>> children = expressions.stream()
                .map(exp -> _create(exp, leafValueMaker))
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
            
            return new TreeInternalNode<>(children, "and".equalsIgnoreCase(type) ? LogicalOperator.AND : LogicalOperator.OR);
        }
        else if (values.isEmpty())
        {
            return null;
        }
        else
        {
            throw new IllegalArgumentException("The object 'values' has an incorrect format (" + values + ")");
        }
    }
    
    /**
     * Gets the query given the parameters.
     * <br>If the provided operator as string represents a real server-side {@link Operator}, then it is just the provided {@link BiFunction} which is applied.
     * <br>Otherwise, the operator is a client-side one, and it will be transformed by modifying the value (by adding wildcards for instance), and deducting the server-side {@link Operator}.
     * Then, the {@link BiFunction} is applied with the transformed value and the deducted {@link Operator}.
     * @param value The value
     * @param stringOperator The operator as string
     * @param toQuery A function applied to a transformed value 
     * (not necessarily the one given by the method, as it can be transformed by adding wildcard chars, escaping...) 
     * and a real {@link Operator} (deducted from the given client-side string operator)
     * @param language Tha language
     * @param contextualParameters The contextual parameters
     * @return The result query
     */
    // TODO have those fake client-side operators as real server-side operators
    public Query toQuery(Object value, String stringOperator, BiFunction<Object, Operator, Query> toQuery, String language, Map<String, Object> contextualParameters)
    {
        Query query = null;
        String wdValue;
        
        // Special wildcard searches.
        switch (stringOperator)
        {
            case "contains":
            case "not-contains":
                wdValue = "*" + escapeQueryCharsForLikeQuery((String) value, contextualParameters) + "*";
                query = toQuery.apply(wdValue, Operator.LIKE);
                if ("not-contains".equals(stringOperator) && query != null)
                {
                    query = new NotQuery(query);
                }
                break;
            case "starts-with":
            case "not-starts-with":
                wdValue = escapeQueryCharsForLikeQuery((String) value, contextualParameters) + "*";
                query = toQuery.apply(wdValue, Operator.LIKE);
                if ("not-starts-with".equals(stringOperator) && query != null)
                {
                    query = new NotQuery(query);
                }
                break;
            case "ends-with":
            case "not-ends-with":
                wdValue = "*" + escapeQueryCharsForLikeQuery((String) value, contextualParameters);
                query = toQuery.apply(wdValue, Operator.LIKE);
                if ("not-ends-with".equals(stringOperator) && query != null)
                {
                    query = new NotQuery(query);
                }
                break;
            default:
                if (StringUtils.isNotBlank(stringOperator))
                {
                    Operator operator = Operator.fromName(stringOperator);
                    query = toQuery.apply(value, operator);
                }
        }
        
        return query;
    }
    
    /**
     * Escape special Solr query characters of the user input, before building the query in order to append '*' character(s)
     * @param string The string to escape.
     * @param contextualParameters the search contextual parameters.
     * @return The escaped string.
     */
    protected static String escapeQueryCharsForLikeQuery(String string, Map<String, Object> contextualParameters)
    {
        contextualParameters.put(QueryBuilder.VALUE_IS_ESCAPED, Boolean.TRUE);
        return ClientUtils.escapeQueryChars(string);
    }
    
    /**
     * A wrapper of a client-side criterion
     */
    public static class ClientSideCriterionWrapper
    {
        private String _id;
        private Object _value;
        private String _strOp;
        private Map<String, Object> _otherProperties;

        ClientSideCriterionWrapper(String id, Object value, String op, Map<String, Object> otherProperties)
        {
            _id = id;
            _value = value;
            _strOp = op;
            _otherProperties = otherProperties;
        }

        /**
         * Gets the id
         * @return the id
         */
        public String getId()
        {
            return _id;
        }

        /**
         * Gets the value
         * @return the value
         */
        public Object getValue()
        {
            return _value;
        }

        /**
         * Gets the string operator
         * @return the string operator
         */
        public String getStringOperator()
        {
            return _strOp;
        }

        /**
         * Gets the other properties
         * @return the other properties
         */
        public Map<String, Object> getOtherProperties()
        {
            return _otherProperties;
        }
    }
}