/*
 *  Copyright 2014 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.regex.Matcher;
import java.util.regex.Pattern;

import org.ametys.cms.search.QueryBuilder;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * Represents a {@link Query} testing a string field.
 */
public class StringQuery extends AbstractFieldQuery
{
    
    /** Escape '{', '}', ':' and '!' characters to prevent the user from changing the query field. */
    //   '(?<!(?<!\\)\\)([{}:!])'
    // = '(?<!'                     Negative Lookbehind (Assert that the Regex below does not match)
    // + '(?<!'                     Negative Lookbehind (Assert that the Regex below does not match)
    // + '\\)'                      matches the character '\'
    // + '\\)'                      matches the character '\'
    // + '([{}:!])'                 Matches a single character in the list, so '{', '}', ':' or '!'
    //                  In order to match '{', '}', ':' or '!' only if they are not escaped yet (not preceded by a '\')
    protected static final Pattern FULLTEXT_ESCAPE_CHARS = Pattern.compile("(?<!(?<!\\\\)\\\\)([{}:!])");
    
    /** The replacement. */
    // '\\$1' = '\' + '\$1'. 
    // We want to escape the found characters, so add a '\' in front of them. '\$1' is the references to the captured subsequences
    protected static final String FULLTEXT_ESCAPE_CHARS_REPLACEMENT = "\\\\$1";
    
    /** The operator. */
    protected Operator _operator;
    /** The value to test. */
    protected String _value;
    /** The language. */
    protected String _language;
    
    /**
     * Build a StringQuery testing the existence of the field.
     * @param fieldPath the field path
     */
    public StringQuery(String fieldPath)
    {
        this(fieldPath, Operator.EXISTS, null, null);
    }
    
    /**
     * Build a string query.
     * @param fieldPath the field's path
     * @param value the value.
     */
    public StringQuery(String fieldPath, String value)
    {
        this(fieldPath, value, null);
    }
    
    /**
     * Build a string query.
     * @param fieldPath the field's path
     * @param value the value.
     * @param language the query language (can be null).
     */
    public StringQuery(String fieldPath, String value, String language)
    {
        this(fieldPath, Operator.EQ, value, language);
    }
    
    /**
     * Build a string query.
     * @param fieldPath the field's path
     * @param op the operator.
     * @param value the value.
     * @param language the query language (can be null).
     */
    public StringQuery(String fieldPath, Operator op, String value, String language)
    {
        super(fieldPath);
        _operator = op;
        _value = value;
        _language = language;
    }
    
    /**
     * 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();
        
        if (_operator == Operator.EXISTS)
        {
            query.append(_fieldPath).append("_s:").append(QueryHelper.EXISTS_VALUE);
            return query.toString();
        }
        
        // TODO Params?
        String language = _language != null ? _language : QueryBuilder.DEFAULT_LANGUAGE;
        
        checkStringValue(_value);
        
        String escapedValue = escapeStringValue(_value);
        
        if (_operator == Operator.NE)
        {
            query.append('-');
        }
        
        query.append(_fieldPath);
        
        if (_operator == Operator.SEARCH)
        {
            // Test query, unstemmed.
            query.append("_txt_").append(language).append(":(").append(escapedValue).append(')');
        }
        else if (_operator == Operator.SEARCH_STEMMED)
        {
            // Full-text query.
            query.append("_txt_stemmed_").append(language).append(":(").append(escapedValue).append(')');
        }
        else if (_operator == Operator.LIKE)
        {
            // Wildcard query: run a lower-case search.
            query.append("_s_lower:").append('(').append(escapedValue.toLowerCase()).append(')');
        }
        else
        {
            // Strict string comparison (enumerator value, ID, ...)
            query.append("_s:").append('"').append(escapedValue).append('"');
        }
        
        return query.toString();
    }
    
    /**
     * 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 (':', '{' and '}').
     * @param value the string value.
     * @return the escaped value.
     */
    public static String escapeStringValue(String value)
    {
        Matcher matcher = FULLTEXT_ESCAPE_CHARS.matcher(value);
        if (matcher.find())
        {
            return matcher.replaceAll(FULLTEXT_ESCAPE_CHARS_REPLACEMENT);
        }
        else
        {
            return value;
        }
    }
    
}