/*
 *  Copyright 2021 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.query;

import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.util.ClientUtils;

import org.ametys.runtime.i18n.I18nizableText;

/**
 * Represents a {@link Query} testing a text field.
 */
public abstract class AbstractTextQuery extends AbstractFieldQuery
{
    /** The operator. */
    protected Operator _operator;
    /** The value to test. */
    protected String _value;
    /** The language. */
    protected String _language;
    /** <code>true</code> if the value is already escaped and there is no need to escape again the value during {@link #build() the build of the query}. */
    protected boolean _valueAlreadyEscaped;
    
    /**
     * Build a AbstractTextQuery testing the existence of the field.
     * @param fieldPath the field path
     */
    public AbstractTextQuery(String fieldPath)
    {
        this(fieldPath, Operator.EXISTS, null, null);
    }
    
    /**
     * Build a text query.
     * @param fieldPath the field's path
     * @param value the value.
     */
    public AbstractTextQuery(String fieldPath, String value)
    {
        this(fieldPath, value, null);
    }
    
    /**
     * Build a text query.
     * @param fieldPath the field's path
     * @param value the value.
     * @param language the query language (can be null).
     */
    public AbstractTextQuery(String fieldPath, String value, String language)
    {
        this(fieldPath, Operator.EQ, value, language);
    }
    
    /**
     * Build a text query.
     * @param fieldPath the field's path
     * @param op the operator.
     * @param value the value.
     * @param language the query language (can be null).
     */
    public AbstractTextQuery(String fieldPath, Operator op, String value, String language)
    {
        this(fieldPath, op, value, language, false);
    }
    
    /**
     * Build a text query.
     * @param fieldPath the field's path
     * @param op the operator.
     * @param value the value.
     * @param language the query language (can be null).
     * @param alreadyEscaped true if the value is already escaped and there is no need to escape again the value during {@link #build() the build of the query}.
     */
    public AbstractTextQuery(String fieldPath, Operator op, String value, String language, boolean alreadyEscaped)
    {
        super(fieldPath);
        _operator = op;
        _value = value;
        _language = language;
        _valueAlreadyEscaped = alreadyEscaped;
    }
    
    /**
     * Get the operator.
     * @return the operator.
     */
    public Operator getOperator()
    {
        return _operator;
    }
    
    /**
     * Get the value.
     * @return the value.
     */
    public String getValue()
    {
        return _value;
    }
    
    /**
     * Get the language.
     * @return the language.
     */
    public String getLanguage()
    {
        return _language;
    }
    
    @Override
    public String build() throws QuerySyntaxException
    {
        StringBuilder query = new StringBuilder();
                
        checkStringValue(_value);
        
        String escapedValue = _valueAlreadyEscaped ? _value : escapeStringValue(_value, _operator);
        
        if (_operator == Operator.NE)
        {
            NotQuery.appendNegation(query);
        }
        
        query.append(_fieldPath);
        
        if (_operator == Operator.SEARCH)
        {
            // Test query, unstemmed.
            query.append("_txt");
            if (_language != null)
            {
                query.append("_").append(_language);
            }
            query.append(":(").append(escapedValue).append(')');
        }
        else if (_operator == Operator.SEARCH_STEMMED)
        {
            // Full-text query
            if (_language == null)
            {
                throw new IllegalArgumentException("Cannot build a string query with stemming without language");
            }
            query.append("_txt_stemmed_").append(_language).append(":(").append(escapedValue).append(')');
        }
        else if (_operator == Operator.LIKE)
        {
            if (_language != null)
            {
                query.append("_").append(_language);
            }
            // Wildcard query: run a lower-case search.
            query.append("_s_lower:").append('(').append(escapedValue.toLowerCase()).append(')');
        }
        else if (_operator == Operator.FUZZY)
        {
            if (_language != null)
            {
                query.append("_").append(_language);
            }
            // Run a lower-case fuzzy search with a maximum edit distance of 2 characters.
            query.append("_s_lower:").append('(').append(escapedValue.toLowerCase()).append("~2").append(')');
        }
        else
        {
            // Strict string comparison (enumerator value, ID, ...)
            query.append("_s:").append('"').append(escapedValue).append('"');
        }
        
        return query.toString();
    }
    
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + ((_language == null) ? 0 : _language.hashCode());
        result = prime * result + ((_operator == null) ? 0 : _operator.hashCode());
        result = prime * result + ((_value == null) ? 0 : _value.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!super.equals(obj))
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        AbstractTextQuery other = (AbstractTextQuery) obj;
        if (_language == null)
        {
            if (other._language != null)
            {
                return false;
            }
        }
        else if (!_language.equals(other._language))
        {
            return false;
        }
        if (_operator != other._operator)
        {
            return false;
        }
        if (_value == null)
        {
            if (other._value != null)
            {
                return false;
            }
        }
        else if (!_value.equals(other._value))
        {
            return false;
        }
        return true;
    }

    /**
     * Ensure that the string value is valid (i.e. the parentheses are balanced),
     * and throw an exception if it isn't.
     * @param value the string value to check.
     * @throws QuerySyntaxException if the value is invalid.
     */
    public static void checkStringValue(String value) throws QuerySyntaxException
    {
        // The parenthesis nesting level.
        boolean invalid = false;
        int level = 0;
        
        for (int i = 0; i < value.length() && !invalid; i++)
        {
            char ch = value.charAt(i);
            // The current character is escaped if the previous character is a slash
            // that is not itself escaped (the previous-previous character must not be a slash).
            boolean escaped = i > 0 && value.charAt(i - 1) == '\\' && !(i > 1 && value.charAt(i - 2) == '\\');
            
            if (ch == '(' && !escaped)
            {
                level++;
            }
            else if (ch == ')' && !escaped)
            {
                level--;
                if (level < 0)
                {
                    // More closing than opening parentheses at this point: the value is invalid.
                    invalid = true;
                }
            }
        }
        
        // If the parentheses are balanced, the level is 0 at this point.
        if (level != 0 || invalid)
        {
            String message = "The string search " + value + " is illegal, check the parentheses.";
            I18nizableText details = new I18nizableText("plugin.cms", "UITOOL_SEARCH_ERROR_QUERY_LABEL", Collections.singletonMap("value", new I18nizableText(value)));
            
            throw new QuerySyntaxException(message, details);
        }
    }
    
    /**
     * Escape from a string value the characters that can modify the query field
     * @param value the string value.
     * @param operator the operator
     * @return the escaped value.
     */
    public static String escapeStringValue(String value, Operator operator)
    {
        switch (operator)
        {
            case LIKE:
                // '*' are allowed characters
                // So escape all characters except '*'
                return Stream.of(StringUtils.splitByWholeSeparatorPreserveAllTokens(value, "*"))
                             .map(ClientUtils::escapeQueryChars)
                             .collect(Collectors.joining("*"));
            case SEARCH:
            case SEARCH_STEMMED:
                // '*' are allowed characters
                // So escape all characters (except '*' and whitespaces)
                return QueryHelper.escapeQueryCharsExceptStarsAndWhitespaces(value);

            default:
                return ClientUtils.escapeQueryChars(value);
        }
    }
}