package Torello.Java;

import java.util.function.Predicate;

import static Torello.Java.StrTokCmpr.AND;
import static Torello.Java.StrTokCmpr.OR;
import static Torello.Java.StrTokCmpr.XOR;
import static Torello.Java.StrTokCmpr.NAND;


class TokCmprCN 
{
    // This method remains 'protected' because it utilizes a specialized Loop-Control
    // Variable Class Version of 'LV'.  It is used internally by the search methods above.

    static boolean contains(
            final String    srcStr,
            final LV        l,
            final String    token
        )
    {
        // String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
        // Tests if two string regions are equal.  A substring of this String object is
        // compared to a substring of the argument other.  The result is true if these substrings
        // represent character sequences that are the same, ignoring case if and only if ignoreCase
        // is true.

        final int tokenLen  = token.length();
        final int loopLen   = l.end - tokenLen;

        if ((l.end - l.start) < token.length())
            return false;

        for (int i=l.start; i <= loopLen; i++)

            if (    srcStr.regionMatches(i, token, 0, tokenLen)
                &&  (   (i == 0)
                    ||  Character.isWhitespace(srcStr.charAt(i-1)))
                &&  (   ((i + tokenLen) == srcStr.length())
                    ||  Character.isWhitespace(srcStr.charAt(i + tokenLen)))
            )

                return true;

        return false;
    }


    // This method remains 'protected' because it utilizes a specialized Loop-Control
    // Variable Class Version of 'LV'.  It is used internally by the search methods above.

    static boolean containsIgnoreCase(
            final String    srcStr,
            final LV        l,
            final String    token
        )
    {
        // String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
        // Tests if two string regions are equal.  A substring of this String object is
        // compared to a substring of the argument other.  The result is true if these substrings
        // represent character sequences that are the same, ignoring case if and only if ignoreCase
        // is true.

        int tokenLen    = token.length();
        int loopLen     = l.end - tokenLen;

        if ((l.end - l.start) < token.length()) return false;

        for (int i=l.start; i <= loopLen; i++)
            if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                &&  (   (i == 0)
                    ||  Character.isWhitespace(srcStr.charAt(i-1)))
                &&  (   ((i + tokenLen) == srcStr.length())
                    ||  Character.isWhitespace(srcStr.charAt(i + tokenLen)))
                )
                return true;

        return false;
    }


    // This method remains 'protected' because it utilizes a specialized Loop-Control
    // Variable Class Version of 'LV'.  It is used internally by the search methods above.

    static boolean contains(
            final String                srcStr,
            final LV                    l, 
            final Predicate<Character>  extraDelimiterTest,
            final String                token
        )
    {
        // String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
        // Tests if two string regions are equal.  A substring of this String object is
        // compared to a substring of the argument other.  The result is true if these substrings
        // represent character sequences that are the same, ignoring case if and only if ignoreCase
        // is true.

        final int tokenLen  = token.length();
        final int loopLen   = l.end - tokenLen;

        if ((l.end - l.start) < token.length())
            return false;

        for (int i=l.start; i <= loopLen; i++)

            if (    srcStr.regionMatches(i, token, 0, tokenLen)
                &&  (   (i == 0)
                    ||  Character.isWhitespace(srcStr.charAt(i-1))
                    ||  extraDelimiterTest.test(srcStr.charAt(i-1)))
                &&  (   ((i + tokenLen) == srcStr.length())
                    ||  Character.isWhitespace(srcStr.charAt(i + tokenLen))
                    ||  extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
                )

                return true;

        return false;
    }


    // This method remains 'protected' because it utilizes a specialized Loop-Control
    // Variable Class Version of 'LV'.  It is used internally by the search methods above.

    static boolean containsIgnoreCase(
            final String                srcStr,
            final LV                    l,
            final Predicate<Character>  extraDelimiterTest,
            final String                token
        )
    {
        // String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
        // Tests if two string regions are equal.  A substring of this String object is
        // compared to a substring of the argument other.  The result is true if these substrings
        // represent character sequences that are the same, ignoring case if and only if ignoreCase
        // is true.

        final int tokenLen  = token.length();
        final int loopLen   = l.end - tokenLen;

        if ((l.end - l.start) < token.length())
            return false;

        for (int i=l.start; i <= loopLen; i++)

            if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                &&  (   (i == 0)
                    ||  Character.isWhitespace(srcStr.charAt(i-1))
                    ||  extraDelimiterTest.test(srcStr.charAt(i-1)))
                &&  (   ((i + tokenLen) == srcStr.length())
                    ||  Character.isWhitespace(srcStr.charAt(i + tokenLen))
                    ||  extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
                )

                return true;

        return false;
    }

    /**
     * Implementing a 'contains' is more efficient by performing only one loop iteration.
     * Therefore, the methods that implement some variant of the String.contains method
     * will use this general-purpose contains-testing method.
     * 
     * @param ignoresCase This is used to signify whether to ignore case when performing the
     * String-comparison operations.
     * 
     * @param booleanOperation This is designed to take one of four values.  This method will
     * throw an exception if it does not.
     * 
     * @param l Loop end-point parameter
     * @param srcStr Any non-null instance of java.lang.String
     * @param extraDelimiterTest <EMBED CLASS='external-html' DATA-FILE-ID='XTRADELIM'>
     * 
     * @param tokens This is one (or many) java String's, each of which shall be
     * checked whether it is contained by 'srcStr'.
     * 
     * @return The appropriate response based on the inputs for boolean logic.
     */
    static boolean CONTAINS(
            final boolean               ignoresCase,
            final byte                  booleanOperation, 
            final LV                    l,
            final String                srcStr,
            final Predicate<Character>  extraDelimiterTest,
            final String[]              tokens
        )
    {
        int count = (booleanOperation == XOR) ? 0 : tokens.length;

        final int   len         = srcStr.length();
        final int[] tokLenArr   = new int[tokens.length];

        for (int i=0; i < tokLenArr.length; i++)
            tokLenArr[i] = tokens[i].length();

        for (int i=l.start; i < l.end; i++)

            for (int j=0; j < tokens.length; j++)

                if (tokLenArr[j] != -1)

                    if (srcStr.regionMatches(ignoresCase, i, tokens[j], 0, tokLenArr[j]))

                        if (    (   (i==0)
                                ||  Character.isWhitespace(srcStr.charAt(i-1))
                                ||  extraDelimiterTest.test(srcStr.charAt(i-1)))
                            &&  (   ((i + tokLenArr[j]) == len)
                                ||  Character.isWhitespace(srcStr.charAt(i + tokLenArr[j]))
                                ||  extraDelimiterTest.test(srcStr.charAt(i + tokLenArr[j])))
                        )

                            switch (booleanOperation)
                            {
                                case AND :
                                    tokLenArr[j] = -1;
                                            if (--count == 0)   return true;
                                            else                break;

                                case XOR :
                                    tokLenArr[j] = -1;
                                    if (++count > 1)    return false;
                                    else                break;

                                case OR     : return true;
                                case NAND   : return false;

                                default :
                                    throw new IllegalArgumentException
                                        (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
                            }

        switch(booleanOperation)
        {
            case AND    : return false;
            case OR     : return false;
            case XOR    : return count == 1;
            case NAND   : return true;

            default :
                throw new IllegalArgumentException
                    (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
        }
    }

    /**
     * Implementing a 'contains' is more efficient by performing only one loop iteration.
     * Therefore, the methods that implement some variant of the String.contains method
     * will use this general-purpose contains-testing method.
     *
     * @param ignoresCase This is used to signify whether to ignore case when performing the
     * String-comparison operations.
     * 
     * @param booleanOperation This is designed to take one of four values.  This method will
     * throw an exception if it does not.
     * 
     * @param srcStr Any non-null instance of java.lang.String
     * @param extraDelimiterTest <EMBED CLASS='external-html' DATA-FILE-ID='XTRADELIM'>
     * 
     * @param tokens This is one (or many) java String's, each of which shall be
     * checked whether it is contained by 'srcStr'.
     * 
     * @return The appropriate response based on the inputs for boolean logic.
     */
    static boolean CONTAINS(
            final boolean               ignoresCase,
            final byte                  booleanOperation,
            final String                srcStr, 
            final Predicate<Character>  extraDelimiterTest,
            final String[]              tokens
        )
    {
        int count = (booleanOperation == XOR) ? 0 : tokens.length;

        final int   len         = srcStr.length();
        final int[] tokLenArr   = new int[tokens.length];
        
        for (int i=0; i < tokLenArr.length; i++)
            tokLenArr[i] = tokens[i].length();

        for (int i=0; i < len; i++)

            for (int j=0; j < tokens.length; j++)

                if (tokLenArr[j] != -1)

                    if (srcStr.regionMatches(ignoresCase, i, tokens[j], 0, tokLenArr[j]))

                        if (    (   (i==0)
                                ||  Character.isWhitespace(srcStr.charAt(i-1))
                                ||  extraDelimiterTest.test(srcStr.charAt(i-1)))
                            &&  (   ((i+tokLenArr[j]) == len)
                                ||  Character.isWhitespace(srcStr.charAt(i+tokLenArr[j]))
                                ||  extraDelimiterTest.test(srcStr.charAt(i+tokLenArr[j])))
                        )

                            switch (booleanOperation)
                            {
                                case AND :
                                    tokLenArr[j] = -1;
                                    if (--count == 0)   return true;
                                    else                break;

                                case XOR :
                                    tokLenArr[j] = -1;
                                    if (++count > 1)    return false;
                                    else                break;

                                case OR     : return true;
                                case NAND   : return false;

                                default :
                                    throw new IllegalArgumentException
                                        (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
                            }

        switch(booleanOperation)
        {
            case AND    : return false;
            case OR     : return false;
            case XOR    : return count == 1;
            case NAND   : return true;

            default :
                throw new IllegalArgumentException
                    (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
        }
    }


    private static final String CONTAINS_EX = 
        "The value passed to parameter 'booleanOperation' was [BOOL]." +
        "However, this parameter is intended to must be chosen from one of the four boolean " +
        "static-constants available in this class.  Valid values for this parameter include: " +
        "StrCmpr.AND, StrCmpr.OR, StrCmpr.XOR and StrCmpr.NAND.";

    /**
     * Implementing a 'contains' is more efficient by performing only one loop iteration.
     * Therefore, the methods that implement some variant of the String.contains method
     * will use this general-purpose contains-testing method.
     * 
     * @param ignoresCase This is used to signify whether to ignore case when performing the
     * String-comparison operations.
     * 
     * @param booleanOperation This is designed to take one of four values.  This method will
     * throw an exception if it does not.
     * 
     * @param l Loop end-point parameter
     * @param srcStr Any non-null instance of java.lang.String
     * 
     * @param tokens This is one (or many) java String's, each of which shall be
     * checked whether it is contained by 'srcStr'.
     * 
     * @return The appropriate response based on the inputs for boolean logic.
     */
    static boolean CONTAINS_LV(
            final boolean   ignoresCase,
            final byte      booleanOperation,
            final LV        l,
            final String    srcStr,
            final String[]  tokens
        )
    {
        int count = (booleanOperation == XOR) ? 0 : tokens.length;

        final int   len         = srcStr.length();
        final int[] tokLenArr   = new int[tokens.length];

        for (int i=0; i < tokens.length; i++)
            tokLenArr[i] = tokens[i].length();

        for (int i=l.start; i < l.end; i++)

            for (int j=0; j < tokens.length; j++)

                if (tokLenArr[j] != -1)

                    if (srcStr.regionMatches(ignoresCase, i, tokens[j], 0, tokLenArr[j]))

                        if (    (   (i==0)
                                ||  Character.isWhitespace(srcStr.charAt(i-1)))
                            &&  (   ((i + tokLenArr[j]) == len)
                                ||  Character.isWhitespace(srcStr.charAt(i + tokLenArr[j])))
                        )

                            switch (booleanOperation)
                            {
                                case AND :
                                    tokLenArr[j] = -1;
                                    if (--count == 0)   return true;
                                    else                break;

                                case XOR :
                                    tokLenArr[j] = -1;
                                    if (++count > 1)    return false;
                                    else                break;

                                case OR     : return true;
                                case NAND   : return false;

                                default :
                                    throw new IllegalArgumentException
                                        (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
                            }

        switch(booleanOperation)
        {
            case AND    : return false;
            case OR     : return false;
            case XOR    : return count == 1;
            case NAND   : return true;

            default :
                throw new IllegalArgumentException
                    (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
        }
    }

    /**
     * Implementing a 'contains' is more efficient by performing only one loop iteration.
     * Therefore, the methods that implement some variant of the String.contains method
     * will use this general-purpose contains-testing method.
     * 
     * @param ignoresCase This is used to signify whether to ignore case when performing the
     * String-comparison operations.
     * 
     * @param booleanOperation This is designed to take one of four values.  This method will
     * throw an exception if it does not.
     * 
     * @param srcStr Any non-null instance of java.lang.String
     * 
     * @param tokens This is one (or many) java String's, each of which shall be
     * checked whether it is contained by 'srcStr'.
     * 
     * @return The appropriate response based on the inputs for boolean logic.
     */
    static boolean CONTAINS(
            final boolean   ignoresCase,
            final byte      booleanOperation,
            final String    srcStr,
            final String[]  tokens
        )
    {
        int count = (booleanOperation == XOR) ? 0 : tokens.length;

        final int   len         = srcStr.length();
        final int[] tokLenArr   = new int[tokens.length];

        for (int i=0; i < tokens.length; i++)
            tokLenArr[i] = tokens[i].length();

        for (int i=0; i < len; i++)

            for (int j=0; j < tokens.length; j++)

                if (tokLenArr[j] != -1)

                    if (srcStr.regionMatches(ignoresCase, i, tokens[j], 0, tokLenArr[j]))

                        if (    (   (i==0)
                                ||  Character.isWhitespace(srcStr.charAt(i-1)))
                            &&  (   ((i + tokens[j].length()) == len)
                                ||  Character.isWhitespace(srcStr.charAt(i + tokens[j].length())))
                        )

                            switch (booleanOperation)
                            {
                                case AND :
                                    tokLenArr[j] = -1;
                                    if (--count == 0)   return true;
                                    else                break;

                                case XOR :
                                    tokLenArr[j] = -1;
                                    if (++count > 1)    return false;
                                    else                break;

                                case OR     : return true;
                                case NAND   : return false;

                                default :
                                    throw new IllegalArgumentException
                                        (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
                            }

        switch(booleanOperation)
        {
            case AND    : return false;
            case OR     : return false;
            case XOR    : return count == 1;
            case NAND   : return true;

            default :
                throw new IllegalArgumentException
                    (CONTAINS_EX.replace("BOOL", "" + booleanOperation));
        }
    }

}