/*
 * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation
//
package org.eclipse.persistence.jpa.jpql;

import java.util.regex.Pattern;

/**
 * A utility class containing various methods related to the Hermes parser.
 * <p>
 * Provisional API: This interface is part of an interim API that is still under development and
 * expected to change significantly before reaching stability. It is available at this early stage
 * to solicit feedback from pioneering adopters on the understanding that any code that uses this
 * API will almost certainly be broken (repeatedly) as the API evolves.
 *
 * @version 2.6
 * @since 2.3
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
public final class ExpressionTools {

    /**
     * The {@link Pattern} representing the regular expression of a numerical value as a double.
     */
    public static final Pattern DOUBLE_REGEXP = Pattern.compile("^[-+]?[0-9]*(\\.[0-9]+)?([dD]|([eE][-+]?[0-9]+))?$");

    /**
     * The constant of an empty array.
     */
    public static final Object[] EMPTY_ARRAY = new Object[0];

    /**
     * The constant for an empty string.
     */
    public static final String EMPTY_STRING = "";

    /**
     * The constant of an empty String array.
     */
    public static final String[] EMPTY_STRING_ARRAY = new String[0];

    /**
     * The {@link Pattern} representing the regular expression of a numerical value as a float.
     */
    public static final Pattern FLOAT_REGEXP = Pattern.compile("^[-+]?[0-9]*(\\.[0-9]+)?[fF]$");

    /**
     * The {@link Pattern} representing the regular expression of a numerical value as an integer.
     */
    public static final Pattern INTEGER_REGEXP = Pattern.compile("^[-+]?[0-9]+$");

    /**
     * The {@link Pattern} representing the regular expression of a numerical value as a long.
     */
    public static final Pattern LONG_REGEXP = Pattern.compile("^[-+]?[0-9]+[lL]?$");

    /**
     * ExpressionTools cannot be instantiated.
     */
    private ExpressionTools() {
        super();
        throw new IllegalAccessError("ExpressionTools cannot be instantiated");
    }

    /**
     * Converts the escape characters contained in the given {@link CharSequence} to their literal
     * representation. For example, '\b' is converted to '\\b'.
     *
     * @param value The sequence of characters to convert any escape character
     * @param position This is a one element array that needs to be adjusted when an escape
     * character is converted
     * @return The new sequence of characters that does not contain any escape character but it's
     * literal representation
     */
    public static String escape(CharSequence value, int[] position) {

        StringBuilder sb = new StringBuilder(value.length());
        int originalPosition = position[0];

        for (int index = 0, count = value.length(); index < count; index++) {
            char character = value.charAt(index);

            switch (character) {
                case '\b':
                    sb.append("\\b");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\t':
                    sb.append("\\t");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\n':
                    sb.append("\\n");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\f':
                    sb.append("\\f");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\r':
                    sb.append("\\r");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\"':
                    sb.append("\\\"");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\\':
                    sb.append("\\\\");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\0':
                    sb.append("\\0");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\1':
                    sb.append("\\1");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\2':
                    sb.append("\\2");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\3':
                    sb.append("\\3");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\4':
                    sb.append("\\4");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\5':
                    sb.append("\\5");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\6':
                    sb.append("\\6");
                    if (index < originalPosition) position[0]++;
                    break;
                case '\7':
                    sb.append("\\7");
                    if (index < originalPosition) position[0]++;
                    break;
                default:
                    sb.append(character);
            }
        }

        return sb.toString();
    }

    /**
     * Determines whether the JPQL fragment is an expression of the form <code>&lt;IDENTIFIER&gt;(</code>.
     *
     * @param wordParser The text to parse based on the current position of the cursor
     * @param identifier The identifier to verify if it's for an expression or for possibly for a
     * variable name
     * @return <code>true</code> if the identifier is followed by '('; <code>false</code> otherwise
     */
    public static boolean isFunctionExpression(WordParser wordParser, String identifier) {

        // Skip the identifier
        int count = identifier.length();
        wordParser.moveForward(identifier);

        // Check to see if ( is following the identifier
        int whitespace = wordParser.skipLeadingWhitespace();
        boolean function = wordParser.startsWith('(');

        // Revert the changes
        wordParser.moveBackward(count + whitespace);

        return function;
    }

    /**
     * Determines whether the given character should be escaped when being part of a string, i.e.
     * '\r' should be "\\r".
     *
     * @param character The character to check if it can directly be used in a string or should be escaped
     * @return <code>true</code> if the given character cannot be used directly in a string
     * @since 2.5
     */
    public static boolean isJavaEscapedCharacter(char character) {

        switch (character) {
            case '\b':
            case '\t':
            case '\n':
            case '\f':
            case '\r':
            case '\"':
            case '\\':
            case '\0':
            case '\1':
            case '\2':
            case '\3':
            case '\4':
            case '\5':
            case '\6':
            case '\7': return true;
            default:   return false;
        }
    }

    /**
     * Determines whether the given character is the character used to identify an input parameter,
     * either a named parameter or position parameter.
     *
     * @param character The character to check if it's a parameter
     * @return <code>true</code> if the given character is either : or ?; <code>false</code> otherwise
     */
    public static boolean isParameter(char character) {
        return character == ':' ||
               character == '?';
    }

    /**
     * Determines whether the given character is the single or double quote.
     *
     * @param character The character to check if it's a quote
     * @return <code>true</code> if the given character is either ' or "; <code>false</code> otherwise
     */
    public static boolean isQuote(char character) {
        return character == '\'' ||
               character == '\"';
    }

    /**
     * Returns the given string literal by wrapping it with single quotes. Any single quote within
     * the string will be escaped with another single quote.
     *
     * @param text The original text to quote
     * @return The quoted text
     * @since 2.4
     */
    public static String quote(String text) {
        text = text.replace("'", "''");
        text = "'" + text + "'";
        return text;
    }

    /**
     * Adjusts the positions contained by the given array of either one or two elements, which is
     * based on the given <em>query1</em>, by translating those positions to be at the equivalent
     * position within <em>query2</em>.
     * <p>
     * <b>Important:</b> The two JPQL queries should contain the same characters but the amount of
     * whitespace can differ. One cannot have the escape characters and the other one has the Unicode
     * characters.
     *
     * @param query1 The query where the positions are pointing
     * @param positions An array of either one or two elements positioned within <em>query1</em>
     * @param query2 The query for which the positions might need adjustment
     * @since 2.5
     */
    public static void reposition(CharSequence query1, int[] positions, CharSequence query2) {

        // Nothing to adjust
        if ((positions[0] <= 0) && (positions.length == 1)) {
            return;
        }

        int queryLength1 = query1.length();
        int queryLength2 = query2.length();

        // Queries 1 and 2 have the same length, no translation required
        if (queryLength1 == queryLength2) {
            return;
        }

        int index1 = 0;
        int index2 = 0;
        boolean position1Done = false;
        boolean position2Done = false;

        while ((index1 < queryLength1) && (index2 < queryLength2) && (!position1Done || !position2Done)) {

            char character1 = Character.toUpperCase(query1.charAt(index1));
            char character2 = Character.toUpperCase(query2.charAt(index2));

            boolean whitespace1 = Character.isWhitespace(character1);
            boolean whitespace2 = Character.isWhitespace(character2);

            if (character1 != character2) {

                // Query 2 does not have a whitespace but query 1 does
                if (whitespace1 && !whitespace2) {
                    index1++;

                    if (!position1Done) {
                        positions[0]--;
                    }

                    if (!position2Done && (positions.length > 1)) {
                        positions[1]--;
                    }
                }
                // Query 1 does not have a whitespace but the query 2 does
                else if (!whitespace1 && whitespace2) {
                    index2++;

                    if (!position1Done) {
                        positions[0]++;
                    }

                    if (!position2Done && (positions.length > 1)) {
                        positions[1]++;
                    }
                }
                // Continue with the next character
                else {
                    index1++;
                    index2++;
                }
            }
            // Continue with the next character
            else {
                index1++;
                index2++;
            }

            // Check to see if the position has been fully updated
            if ((!whitespace1 && !whitespace2) || (queryLength1 > queryLength2)) {

                if (positions[0] <= index2) {
                    position1Done = true;
                }

                if ((positions.length > 1) && positions[1] <= index2) {
                    position2Done = true;
                }
            }
        }

        // Make sure the positions are not outside of length of query2
        positions[0] = Math.min(positions[0], queryLength2);
        positions[0] = Math.max(positions[0], 0);

        if (positions.length > 1) {
            positions[1] = Math.min(positions[1], queryLength2);
            positions[1] = Math.max(positions[1], 0);
        }
    }

    /**
     * Adjusts the position, which is based on the given <em>query1</em>, by translating it to be at
     * the equivalent position within <em>query2</em>.
     * <p>
     * <b>Important:</b> The two JPQL queries should contain the same characters but the amount of
     * whitespace can differ. One cannot have the escape characters and the other one has the Unicode
     * characters.
     *
     * @param query1 The query where the positions are pointing
     * @param position1 The position of a cursor within <em>query1</em>
     * @param query2 The query for which the position might need adjustment
     * @return The adjusted position by moving it based on the difference between <em>query1</em> and
     * <em>query2</em>
     * @see #reposition(CharSequence, int[], CharSequence)
     */
    public static int repositionCursor(CharSequence query1, int position1, CharSequence query2) {
        int[] positions = { position1, position1 };
        reposition(query1, positions, query2);
        return positions[0];
    }

    /**
     * Re-adjusts the given positions, which is based on the non-escaped version of the given
     * <em>query</em>, by making sure it is pointing at the same position within <em>query</em>,
     * which contains references (escape characters).
     * <p>
     * The escape characters are either \b, \t, \n, \f, \r, \", \' and \0 through \7.
     * <p>
     * <b>Important:</b> The given query should contain the exact same amount of whitespace than the
     * query used to calculate the given positions.
     *
     * @param query The query that may contain escape characters
     * @param positions The position within the non-escaped version of the given query, which is
     * either a single element position or two positions that is used as a text range. After execution
     * contains the adjusted positions by moving it based on the difference between the escape and
     * non-escaped versions of the query
     * @since 2.5
     */
    public static void repositionJava(CharSequence query, int[] positions) {

        if ((query == null) || (query.length() == 0)) {
            return;
        }

        StringBuilder sb = new StringBuilder(query);

        for (int index = 0, count = sb.length(); index < count; index++) {

            char character = sb.charAt(index);

            if (isJavaEscapedCharacter(character)) {

                // Translate both positions because the special
                // character is written with its escape character
                if (index < positions[0]) {
                    positions[0]++;
                    positions[1]++;
                }
                // Only translate the end position because the start
                // position is before the current index
                else if (index < positions[1]) {
                    positions[1]++;
                }
            }
        }
    }

    /**
     * Determines whether the given string starts with the given prefix and ignores the case. If the
     * prefix is <code>null</code> or an empty string, then <code>true</code> is always returned.
     *
     * @param string The string to check if its beginning matches the prefix
     * @param prefix The prefix used to test matching the beginning of the sequence of characters
     * @return <code>true</code> if the given string begins with the given prefix and ignores the
     * case; <code>false</code> otherwise
     *
     * @since 2.5
     */
    public static boolean startWithIgnoreCase(String string, String prefix) {

        if (stringIsEmpty(prefix)) {
            return true;
        }

        return string.regionMatches(true, 0, prefix, 0, prefix.length());
    }

    /**
     * Determines whether the specified string is <code>null</code>, empty, or contains only
     * whitespace characters.
     *
     * @param text The sequence of character to test if it is <code>null</code> or only contains
     * whitespace
     * @return <code>true</code> if the given string is <code>null</code> or only contains whitespace;
     * <code>false</code> otherwise
     */
    public static boolean stringIsEmpty(CharSequence text) {

        if ((text == null) || (text.length() == 0)) {
            return true;
        }

        for (int i = text.length(); i-- > 0;) {
            if (!Character.isWhitespace(text.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * Determines whether the specified string is NOT <code>null</code>, NOT empty, or contains at
     * least one non-whitespace character.
     *
     * @param text The sequence of character to test if it is NOT <code>null</code> or does not only
     * contain whitespace
     * @return <code>true</code> if the given string is NOT <code>null</code> or has at least one
     * non-whitespace character; <code>false</code> otherwise
     */
    public static boolean stringIsNotEmpty(CharSequence text) {
        return !stringIsEmpty(text);
    }

    /**
     * Determines whether the two sequence of characters are different, with the appropriate
     * <code>null</code> checks and the case is ignored.
     *
     * @param value1 The first value to check for equality and equivalency
     * @param value2 The second value to check for equality and equivalency
     * @return <code>true</code> if both values are different; <code>false</code> otherwise
     */
    public static boolean stringsAreDifferentIgnoreCase(CharSequence value1, CharSequence value2) {
        return !stringsAreEqualIgnoreCase(value1, value2);
    }

    /**
     * Determines whether the two sequence of characters are equal or equivalent, with the
     * appropriate <code>null</code> checks and the case is ignored.
     *
     * @param value1 The first value to check for equality and equivalency
     * @param value2 The second value to check for equality and equivalency
     * @return <code>true</code> if both values are <code>null</code>, equal or equivalent;
     * <code>false</code> otherwise
     */
    public static boolean stringsAreEqualIgnoreCase(CharSequence value1, CharSequence value2) {

        // Both are equal or both are null
        if ((value1 == value2) || (value1 == null) && (value2 == null)) {
            return true;
        }

        // One is null but the other is not
        if ((value1 == null) || (value2 == null)) {
            return false;
        }

        return value1.toString().equalsIgnoreCase(value2.toString());
    }

    /**
     * Converts the string representation of the escape characters contained by the given {@link
     * CharSequence} into the actual escape characters. For example, the string '\\b' is converted
     * into the character value '\b'.
     *
     * @param value The sequence of characters to convert to an escaped version
     * @param position This is a one element array that needs to be adjusted when an escape
     * character is converted
     * @return The new sequence of characters that contains escape characters rather than their
     * string representation
     */
    public static String unescape(CharSequence value, int[] position) {

        StringBuilder sb = new StringBuilder(value.length());
        int originalPosition = position[0];

        for (int index = 0, count = value.length(); index < count; index++) {

            char character = value.charAt(index);

            if ((character == '\\') && (index + 1 < count)) {
                character = value.charAt(++index);

                switch (character) {
                    // Standard escape character
                    case 'b':  sb.append("\b"); if (index <= originalPosition) position[0]--; break;
                    case 't':  sb.append("\t"); if (index <= originalPosition) position[0]--; break;
                    case 'n':  sb.append("\n"); if (index <= originalPosition) position[0]--; break;
                    case 'f':  sb.append("\f"); if (index <= originalPosition) position[0]--; break;
                    case 'r':  sb.append("\r"); if (index <= originalPosition) position[0]--; break;
                    case '"':  sb.append("\""); if (index <= originalPosition) position[0]--; break;
                    case '\\': sb.append("\\"); if (index <= originalPosition) position[0]--; break;
                    case '0':  sb.append("\0"); if (index <= originalPosition) position[0]--; break;
                    case '1':  sb.append("\1"); if (index <= originalPosition) position[0]--; break;
                    case '2':  sb.append("\2"); if (index <= originalPosition) position[0]--; break;
                    case '3':  sb.append("\3"); if (index <= originalPosition) position[0]--; break;
                    case '4':  sb.append("\4"); if (index <= originalPosition) position[0]--; break;
                    case '5':  sb.append("\5"); if (index <= originalPosition) position[0]--; break;
                    case '6':  sb.append("\6"); if (index <= originalPosition) position[0]--; break;
                    case '7':  sb.append("\7"); if (index <= originalPosition) position[0]--; break;

                    // Unicode
                    case 'u': {
                        // Convert the hexadecimal digit into a char
                        String hexadecimals = value.subSequence(index + 1, index + 5).toString();
                        char unicode = (char) Integer.parseInt(hexadecimals, 16);
                        sb.append(unicode);

                        // Adjust the position and make sure if the position is within the unicode
                        // value, then it's only adjusted to be at the beginning of the unicode value
                        if ((originalPosition > index - 1) && (originalPosition <= index + 5)) {
                            position[0] -= (originalPosition - index + 1);
                        }
                        else if (index <= originalPosition) {
                            position[0] -= 5;
                        }

                        index += 4;
                        break;
                    }
                    // Non-escape character
                    default: {
                        sb.append(character);
                    }
                }
            }
            else {
                sb.append(character);
            }
        }

        return sb.toString();
    }

    /**
     * Returns the string literal without the single or double quotes. Any two consecutive single
     * quotes will be converted into a single quote.
     *
     * @param text The original text to unquote if it has ' at the beginning and the end
     * @return The unquoted text
     */
    public static String unquote(String text) {

        // Nothing to unquote
        if ((text == null) || (text.length() == 0)) {
            return text;
        }

        int startIndex = 0;
        int endIndex = text.length();

        // Skip the leading single quote
        if (isQuote(text.charAt(0))) {
            startIndex = 1;
        }

        // Skip the trailing single quote
        if ((endIndex - 1 >= startIndex) && isQuote(text.charAt(endIndex - 1))) {
            endIndex--;
        }

        text = text.substring(startIndex, endIndex);
        text = text.replace("''", "'");
        return text;
    }

    /**
     * Determines whether the values are different, with the appropriate <code>null</code> checks.
     *
     * @param value1 The first value to check for equality and equivalency
     * @param value2 The second value to check for equality and equivalency
     * @return <code>true</code> if both values are different; <code>true</code> if they are both
     * <code>null</code>, equal or equivalent
     */
    public static boolean valuesAreDifferent(Object value1, Object value2) {
        return !valuesAreEqual(value1, value2);
    }

    /**
     * Determines whether the values are equal or equivalent, with the appropriate <code>null</code>
     * checks.
     *
     * @param value1 The first value to check for equality and equivalency
     * @param value2 The second value to check for equality and equivalency
     * @return <code>true</code> if both values are <code>null</code>, equal or equivalent;
     * <code>false</code> otherwise
     */
    public static boolean valuesAreEqual(Object value1, Object value2) {

        // Both are equal or both are null
        if ((value1 == value2) || (value1 == null) && (value2 == null)) {
            return true;
        }

        // One is null but the other is not
        if ((value1 == null) || (value2 == null)) {
            return false;
        }

        return value1.equals(value2);
    }
}