package Torello.HTML;

import Torello.HTML.helper.AttrRegEx;

import Torello.Java.StringParse;

import java.util.Map;
import java.util.AbstractMap;

import java.util.function.Predicate;
import java.util.function.IntFunction;
import java.util.function.IntPredicate;

import java.util.regex.Matcher;

class HasAndTest
{
    static boolean testAV(
            final TagNode           tn,
            final String            attributeName,
            final Predicate<String> attributeValueTest
        )
    {
        // Closing TagNode's (</DIV>, </A>) cannot attributes, or attribute-values
        if (tn.isClosing) return false;


        // OPTIMIZATION: TagNode's whose String-length is less than this computed length 
        // are simply too short to have the attribute named by the input parameter

        if (tn.str.length() < (tn.tok.length() + attributeName.length() + 4)) return false;


        // This Reg-Ex will allow us to iterate through each attribute key-value pair
        // contained / 'inside' this instance of TagNode.

        Matcher m = AttrRegEx.KEY_VALUE_REGEX.matcher(tn.str);


        // Test each attribute key-value pair, and return the test results if an attribute
        // whose name matches 'attributeName' is found.

        while (m.find())
            if (m.group(2).equalsIgnoreCase(attributeName))
                return attributeValueTest.test
                    (StringParse.ifQuotesStripQuotes(m.group(3)));


        // No attribute key-value pair was found whose 'key' matched input-parameter
        // 'attributeName'

        return false;
    }

    static boolean hasLogicOp(
            final TagNode               tn,
            final boolean               checkAttributeStringsForErrors,
            final IntFunction<Boolean>  onMatchFunction,
            final IntPredicate          reachedEndFunction,
            final String...             attributesInput
        )
    {
        ClosingTagNodeException.check(tn);

        // Keep a tally of how many of the input attributes are found
        int matchCount = 0;

        // Don't clobber the user's input
        String[] attributes = attributesInput.clone();

        // If no attributes are passed to 'attributes' parameter, throw exception.
        if (attributes.length == 0) throw new IllegalArgumentException
            ("Input variable-length String[] array parameter, 'attributes', has length zero.");


        // OPTIMIZATION: TagNode's whose String-length is less than this computed length 
        // are simply too short to have any attribute-value pairs.
        // 4 (characters) are: '<', '>', ' ' and 'X'
        // SHORTEST POSSIBLE SUCH-ELEMENT: <DIV X>
        //
        // This TagNode doesn't have any attributes in it.
        // There is no need to check anything, so return FALSE immediately ("OR" fails)

        if (tn.str.length() < (tn.tok.length() + 4)) return false;

        if (checkAttributeStringsForErrors) InnerTagKeyException.check(attributes);


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Check the main key=value attributes
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // 
        // Get all inner-tag key-value pairs.  If even one of these is inside the 'attributes'
        // input-parameter string-array,  Then we must return true, since this is OR

        Matcher keyValueInnerTags = AttrRegEx.KEY_VALUE_REGEX.matcher(tn.str);

        while (keyValueInnerTags.find())
        {
            // Retrieve the key of the key-value pair
            String innerTagKey = keyValueInnerTags.group(2);                   

            // Iterate every element of the String[] 'attributes' parameter
            SECOND_FROM_TOP:
            for (int i=0; i < attributes.length; i++)


                // No need to check attributes that have already been matched.
                // When an attribute matches, it's place in the array is set to null

                if (attributes[i] != null)


                    // Does the latest keyOnlyInnerTag match one of the user-requested
                    // attribute names?

                    if (innerTagKey.equalsIgnoreCase(attributes[i]))
                    {
                        // NAND & OR will exit immediately on a match.  XOR and AND
                        // will return 'null' meaning they are not sure yet.

                        Boolean whatToDo = onMatchFunction.apply(++matchCount);

                        if (whatToDo != null) return whatToDo;


                        // Increment the matchCounter, if this ever reaches the length
                        // of the input array, there is no need to continue with the loop

                        if (matchCount == attributes.length)
                            return reachedEndFunction.test(matchCount); 


                        // There are still more matches to be found (not every element in
                        // this array is null yet)... Keep Searching, but eliminated the
                        // recently identified attribute from the list, because it has
                        // already been found.

                        attributes[i] = null;
                        continue SECOND_FROM_TOP;
                    }
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Check the main key-only (Boolean) Attributes
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        //
        // Also check the "Boolean Attributes" also known as the "Key-Word Only Attributes"
        // Use the "Inverse Reg-Ex Matcher" (which matches all the strings that are "between" the
        // real matches)
        //
        // substring eliminates the leading "<TOK ..." and the trailing '>' character
        // 2: '<' character *PLUS* the space (' ') character

        String strToSplit = tn.str.substring(
            2 + tn.tok.length(),
            tn.str.length() - ((tn.str.charAt(tn.str.length() - 2) == '/') ? 2 : 1)
        ).trim();

        // 'split' => inverse-matches  (text between KEY-VALUE pairs)
        for (String unMatchedStr : AttrRegEx.KEY_VALUE_REGEX.split(strToSplit))  

            // Of that stuff, now do a white-space split for connected characters
            SECOND_FROM_TOP:
            for (String keyOnlyInnerTag : unMatchedStr.split("\\s+"))          

                // Just-In-Case, usually not necessary
                if ((keyOnlyInnerTag = keyOnlyInnerTag.trim()).length() > 0)

                    // Iterate all the input-parameter String-array attributes
                    for (int i=0; i < attributes.length; i++)


                        // No need to check attributes that have already been matched.
                        // When an attribute matches, it's place in the array is set to null

                        if (attributes[i] != null)


                            // Does the latest keyOnlyInnerTag match one of the user-requested
                            // attribute names?

                            if (keyOnlyInnerTag.equalsIgnoreCase(attributes[i]))
                            {
                                // NAND & OR will exit immediately on a match.  XOR and AND
                                // will return 'null' meaning they are not sure yet.

                                Boolean whatToDo = onMatchFunction.apply(++matchCount);

                                if (whatToDo != null) return whatToDo;


                                // Increment the matchCounter, if this ever reaches the length
                                // of the input array, there is no need to continue with the loop
        
                                if (matchCount == attributes.length)
                                    return reachedEndFunction.test(matchCount); 


                                // There are still more matches to be found (not every element in
                                // this array is null yet)... Keep Searching, but eliminated the
                                // recently identified attribute from the list, because it has
                                // already been found.

                                attributes[i] = null;
                                continue SECOND_FROM_TOP;
                            }

        // Let them know how many matches there were
        return reachedEndFunction.test(matchCount);
    }

    static boolean has(
            final TagNode           tn,
            final Predicate<String> attributeNameTest
        )
    {
        // Closing HTML Elements may not have attribute-names or values.
        // Exit gracefully, and immediately.

        if (tn.isClosing) return false;


        // OPTIMIZATION: TagNode's whose String-length is less than this computed length 
        // are simply too short to have such an attribute-value pair.
        // 4 (characters) are: '<', '>', ' ' and 'X'
        // SHORTEST POSSIBLE SUCH-ELEMENT: <DIV X>

        if (tn.str.length() < (tn.tok.length() + 4)) return false;


        // Get all inner-tag key-value pairs.  If any of them match with the 'attributeNameTest'
        // Predicate, return TRUE immediately.

        Matcher keyValueInnerTags = AttrRegEx.KEY_VALUE_REGEX.matcher(tn.str);

        // the matcher.group(2) has the key (not the value)
        while (keyValueInnerTags.find())
            if (attributeNameTest.test(keyValueInnerTags.group(2)))
                return true;


        // Also check the "Boolean Attributes" also known as the "Key-Word Only Attributes"
        // Use the "Inverse Reg-Ex Matcher" (which matches all the strings that are "between" the
        // real matches)
        // 
        // 'split' => inverse-matches  (text between KEY-VALUE pairs)

        for (String unMatchedStr : AttrRegEx.KEY_VALUE_REGEX.split(tn.str))  

            // Of that stuff, now do a white-space split for connected characters
            for (String keyOnlyInnerTag : unMatchedStr.split("\\s+"))          

                // Just-In-Case, usually not necessary
                if ((keyOnlyInnerTag = keyOnlyInnerTag.trim()).length() > 0)   

                    if (attributeNameTest.test(keyOnlyInnerTag))
                        return true;

        // A match was not found in either the "key-value pairs", or the boolean "key-only list."
        return false;
    }

    static Map.Entry<String, String> hasValue(
            final TagNode           tn,
            final Predicate<String> attributeValueTest,
            final boolean           retainQuotes,
            final boolean           preserveKeysCase
        )
    {
        // Closing HTML Elements may not have attribute-names or values.
        // Exit gracefully, and immediately.

        if (tn.isClosing) return null;


        // OPTIMIZATION: TagNode's whose String-length is less than this computed length 
        // are simply too short to have such an attribute-value pair.
        // 5 (characters) are: '<', '>', ' ', 'X' and '=' 
        // SHORTEST POSSIBLE SUCH-ELEMENT: <DIV X=>

        if (tn.str.length() < (tn.tok.length() + 5)) return null;


        // Get all inner-tag key-value pairs.  If any are 'equal' to parameter attributeName,
        // return TRUE immediately.

        Matcher keyValueInnerTags = AttrRegEx.KEY_VALUE_REGEX.matcher(tn.str);

        while (keyValueInnerTags.find())
        {
            // Matcher.group(3) has the key's value, of the inner-tag key-value pair
            // (matcher.group(2) has the key's name)

            String foundAttributeValue = keyValueInnerTags.group(3);


            // The comparison must be performed on the version of the value that DOES NOT HAVE the
            // surrounding quotation-marks

            String foundAttributeValueNoQuotes =
                StringParse.ifQuotesStripQuotes(foundAttributeValue);


            // Matcher.group(3) has the key-value, make sure to remove quotation marks (if present)
            // before comparing.

            if (attributeValueTest.test(foundAttributeValueNoQuotes))


                // matcher.group(2) has the key's name, not the value.  This is returned via the
                // Map.Entry key

                return retainQuotes

                    ? new AbstractMap.SimpleImmutableEntry<>(
                        preserveKeysCase
                            ? keyValueInnerTags.group(2)
                            : keyValueInnerTags.group(2).toLowerCase(),
                        foundAttributeValue
                    )

                    : new AbstractMap.SimpleImmutableEntry<>(
                        preserveKeysCase
                            ? keyValueInnerTags.group(2)
                            : keyValueInnerTags.group(2).toLowerCase(),
                        foundAttributeValueNoQuotes
                    );
        }

        // No match was identified, return null.
        return null;
    }
}