package Torello.HTML;

import Torello.HTML.helper.AttrRegEx;

import Torello.Java.StringParse;

import java.util.Properties;
import java.util.List;
import java.util.Set;

import java.util.stream.Collectors;
import java.util.regex.Matcher;

class GetSetAttr
{
    static String AV(
            final TagNode   tn, 
            final String    innerTagAttribute,
            final boolean   keepQuotes
        )
    {
        // All HTML element tags that start like: </DIV> with a front-slash.
        // They may not legally contain inner-tag attributes.

        if (tn.isClosing) return null;    

        final String itv = innerTagAttribute.trim();


        // All HTML element tags that contain only <TOK> (TOK <==> Tag-Name) in their 'str' field
        // Specifically: '<', TOKEN, '>',  (Where TOKEN is 'div', 'span', 'table', 'ul', etc...)
        // are TOO SHORT to have the attribute, so don't check... return null.
        // 
        // '4 + tok.length +itv.length'  ==>  '<', ' ', '=', '>'
        //                                      + DIV/SPAN/TABLE.length
        //                                      + CLASS/ID/HREF/AttrName.length
        // 
        // NOTE: This is **ALMOST** identical to "tn.isOpenTagPWA()", except that it adds the
        //       length of 'itv' into the number.

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

        // Matches "Attribute / Inner-Tag Key-Value" Pairs.
        Matcher m = AttrRegEx.KEY_VALUE_REGEX.matcher(tn.str);


        // This loop iterates the KEY_VALUE PAIRS THAT HAVE BEEN FOUND.
        /// NOTE: The REGEX Matches on Key-Value Pairs.

        while (m.find())


            // m.group(2) is the "KEY" of the Attribute KEY-VALUE Pair
            // m.group(3) is the "VALUE" of the Attribute.

            if (m.group(2).equalsIgnoreCase(innerTagAttribute))

                return keepQuotes 
                    ? m.group(3)
                    : StringParse.ifQuotesStripQuotes(m.group(3));

        // This means the attribute name provided to parameter 'innerTagAttribute' was not found.
        return null;
    }

    static TagNode setAV(
            final TagNode   tn,
            final String    attribute,
            final String    value,
            final SD        quote
        )
    {
        ClosingTagNodeException.check(tn);

        if (attribute == null) throw new NullPointerException(
            "You have passed 'null' to the 'attribute' (attribute-name) String-parameter, " +
            "but this is not allowed here."
        );

        if (value == null) throw new NullPointerException(
            "You have passed 'null' to the 'attribute' (attribute-value) String-parameter, " +
            "but this is not allowed here."
        );


        // Retrieve all "Key-Only" (Boolean) Attributes from 'this' (the original) TagNode
        // Use Java Streams to filter out any that match the newly-added attribute key-value pair.
        // SAVE: Save the updated / shortened list to a List<String>

        List<String> prunedOriginalKeyOnlyAttributes =
            KeyOnlyAttributes.allKeyOnlyAttributes(tn, true)
                .filter((String originalKeyOnlyAttribute) -> 
                    ! originalKeyOnlyAttribute.equalsIgnoreCase(attribute))
                .collect(Collectors.toList());


        // Retrieve all Inner-Tag Key-Value Pairs.  Preserve the Case of the Attributes.  Preserve
        // the Quotation-Marks.

        Properties  p                       = RetrieveAllAttr.allAV(tn, true, true);
        String      originalValueWithQuotes = null;
        String      computedQuote           = null;


        // NOTE, there should only be ONE instance of an attribute in an HTML element, but
        // malformed HTML happens all the time, so to keep this method safe, it checks
        // (and removes) the entire attribute-list for matches - not just the first found instance.

        for (String key : p.stringPropertyNames())

            if (key.equalsIgnoreCase(attribute))
            {
                Object temp = p.remove(key);
                if (temp instanceof String) originalValueWithQuotes = (String) temp;
            }


        // If the user does not wish to "change" the original quote choice, then find out what
        // the original-quote choice was...

        if (
                (quote == null) 
            &&  (originalValueWithQuotes != null)
            &&  (originalValueWithQuotes.length() >= 2)
        )
        {
            char s = originalValueWithQuotes.charAt(0);
            char e = originalValueWithQuotes.charAt(originalValueWithQuotes.length() - 1);

            if ((s == e) && (s == '\''))        computedQuote = "" + SD.SingleQuotes.quote;

            else if ((s == e) && (s == '"'))    computedQuote = "" + SD.DoubleQuotes.quote;

            else                                computedQuote = "";
        }

        else if (quote == null)                 computedQuote = "";

        else                                    computedQuote = "" + quote.quote;

        p.put(attribute, computedQuote + value + computedQuote);

        /* TagNode ret = */ return Torello.HTML.EXPORT_PORTAL.newTagNode(
            tn.tok,
            GeneralPurpose.generateElementString(
                // Rather than using '.tok' here, preserve the case of the original HTML Element
                tn.str.substring(1, 1 + tn.tok.length()), p,
                prunedOriginalKeyOnlyAttributes, null /* SD */, tn.str.endsWith("/>")
            ));

        /*
        System.out.println(
            "GetSetAttr.setAV.prunedOriginalKeyOnlyAttributes: [" + prunedOriginalKeyOnlyAttributes + "]\n" +
            "GetSetAttr.setAV.Before:                          [" + tn + "]\n" +
            "GetSetAttr.setAV.After:                           [" + ret + "]"
        );

        return ret;
        */
    }

    static TagNode setAV(
            final TagNode       tn,
            final Properties    attributes,
            final SD            defaultQuote
        )
    {
        ClosingTagNodeException.check(tn);

        // Check that this attributes has elements.
        if (attributes.size() == 0) throw new IllegalArgumentException(
            "You have passed an empty java.util.Properties instance to the " +
            "setAV(Properties, SD) method"
        );


        // Retrieve all Inner-Tag Key-Value Pairs.
        //      Preserve: the Case of the Attributes.
        //      Preserve: the Quotation-Marks.

        Properties originalAttributes = RetrieveAllAttr.allAV(tn, true, true);

        // Retrieve all "Key-Only" (Boolean) attributes from the new / update attribute-list
        Set<String> newAttributeKeys = attributes.stringPropertyNames();


        // Retrieve all "Key-Only" (Boolean) Attributes from 'this' (the original) TagNode
        // Use Java Streams to filter out all the ones that need to be clobbered by-virtue-of
        // the fact that they are present in the new / parameter-updated attribute key-value list.
        // SAVE: Save the updated / shortened list to a List<String>

        List<String> prunedOriginalKeyOnlyAttributes =
            KeyOnlyAttributes.allKeyOnlyAttributes(tn, true)
            .filter((String originalKeyOnlyAttribute) ->
            {
                // Returns false when the original key-only attribute matches one of the
                // new attributes being inserted.  Notice that a case-insensitive comparison
                // must be performed - to preserve case.

                for (String newKey : newAttributeKeys) 
                    if (newKey.equalsIgnoreCase(originalKeyOnlyAttribute)) 
                        return false;

                return true;
            })
            .collect(Collectors.toList());


        // NOTE: There is no need to check the validity of the new attributes.  The TagNode
        //       constructor that is invoked on the last line of this method will do a 
        //       validity-check on the attribute key-names provided to the 'attributes' 
        //       java.util.Properties instance passed to to this method.

        for (String newKey : newAttributeKeys)
        {
            String      originalValueWithQuotes = null;
            String      computedQuote           = null;


            // NOTE, there should only be ONE instance of an attribute in an HTML element, but
            // malformed HTML happens all the time, so to keep this method safe, it checks (and
            // removes) the entire attribute-list for matches - not just the first found instance.

            for (String originalKey : originalAttributes.stringPropertyNames())

                if (originalKey.equalsIgnoreCase(newKey))
                {
                    // Remove the original key-value inner-tag pair.
                    Object temp = originalAttributes.remove(originalKey);
                    if (temp instanceof String) originalValueWithQuotes = (String) temp;
                }


            // If the user does not wish to "change" the original quote choice, then find out what
            // the original-quote choice was...

            if (
                    (defaultQuote == null) 
                &&  (originalValueWithQuotes != null)
                &&  (originalValueWithQuotes.length() >= 2)
            )
            {
                char s = originalValueWithQuotes.charAt(0);
                char e = originalValueWithQuotes.charAt(originalValueWithQuotes.length() - 1);

                if ((s == e) && (s == '\''))        computedQuote = "" + SD.SingleQuotes.quote;

                else if ((s == e) && (s == '"'))    computedQuote = "" + SD.DoubleQuotes.quote;

                else                                computedQuote = "";
            }

            else if (defaultQuote == null)          computedQuote = "";

            else                                    computedQuote = "" + defaultQuote.quote;


            // Insert the newly, updated key-value inner-tag pair.  This 'Properties' will be
            // used to construct a new TagNode.

            originalAttributes.put(newKey, computedQuote + attributes.get(newKey) + computedQuote);
        }

        return Torello.HTML.EXPORT_PORTAL.newTagNode(
            tn.tok,
            GeneralPurpose.generateElementString(
                // Rather than using '.tok' here, preserve the case of the original HTML Element
                tn.str.substring(1, 1 + tn.tok.length()),
                originalAttributes,
                prunedOriginalKeyOnlyAttributes, null /* SD */,
                tn.str.endsWith("/>")
            ));
    }

    static TagNode appendToAV(
            final TagNode   tn,
            final String    attribute,
            final String    appendStr,
            final boolean   startOrEnd,
            final SD        quote
        )
    {
        ClosingTagNodeException.check(tn);

        if (attribute == null) throw new NullPointerException(
            "You have passed 'null' to the 'attribute' (attribute-name) String-parameter, " +
            "but this is not allowed here."
        );

        if (appendStr == null) throw new NullPointerException(
            "You have passed 'null' to the 'appendStr' (attribute-value-append-string) " +
            "String-parameter, but this is not allowed here."
        );

        String curVal = GetSetAttr.AV(tn, attribute, false);

        if (curVal == null) curVal = "";


        // This decides whether to insert the "appendStr" before the current value-string,
        // or afterwards.  This is based on the passed boolean-parameter 'startOrEnd'

        curVal = startOrEnd ? (appendStr + curVal) : (curVal + appendStr);

        /*
        TagNode ret = setAV(tn, attribute, curVal, quote);

        System.out.println(
            "GetSetAttr.appendToAV.curVal: [" + curVal + "]\n" +
            "GetSetAttr.appendToAV.Before: [" + tn + "]\n" +
            "GetSetAttr.appendToAV.After:  [" + ret + "]"
        );

        return ret;
        */

        // Reuse the 'setAV(String, String, SD)' method already defined in this class.
        return setAV(tn, attribute, curVal, quote);
    }   
}