package Torello.Java;

import java.util.TreeSet;

/**
 * Class String-Character provides an exhaustive-combinatoric suite of methods that extend the
 * basic Java <CODE>String</CODE> methods <CODE>equals, contains, startsWith</CODE> and
 * <CODE>endsWith</CODE>, using Java {@code char} primitives as the comparator element.
 * 
 * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH>
 */
@Torello.JavaDoc.StaticFunctional
public class StrCh
{
    private StrCh() { }


    // ********************************************************************************************
    // ********************************************************************************************
    // CONTAINS
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * <EMBED CLASS=defs DATA-DESC='contains at least one' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_NAND_OR(boolean, byte, String, char[])
     */
    public static boolean containsOR(String srcStr, char... compareChar)
    { return CONTAINS_NAND_OR(false, OR, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='contains every one' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_XOR_AND(boolean, byte, String, char[])
     */
    public static boolean containsAND(String srcStr, char... compareChar)
    { return CONTAINS_XOR_AND(false, AND, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='contains exactly one' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_XOR_NOTE>
     * @see #CONTAINS_XOR_AND(boolean, byte, String, char[])
     */
    public static boolean containsXOR(String srcStr, char... compareChar)
    { return CONTAINS_XOR_AND(false, XOR, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not contain any' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_NAND_OR(boolean, byte, String, char[])
     */
    public static boolean containsNAND(String srcStr, char... compareChar)
    { return CONTAINS_NAND_OR(false, NAND, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='contains at least one' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_NAND_OR(boolean, byte, String, char[])
     */
    public static boolean containsOR_CI(String srcStr, char... compareChar)
    { return CONTAINS_NAND_OR(true, OR, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='contains every one' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_XOR_AND(boolean, byte, String, char[])
     */
    public static boolean containsAND_CI(String srcStr, char... compareChar)
    { return CONTAINS_XOR_AND(true, AND, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='contains exactly one' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_XOR_NOTE>
     * @see #CONTAINS_XOR_AND(boolean, byte, String, char[])
     */
    public static boolean containsXOR_CI(String srcStr, char... compareChar)
    { return CONTAINS_XOR_AND(true, XOR, srcStr, compareChar); }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not contain any' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     * @see #CONTAINS_NAND_OR(boolean, byte, String, char[])
     */
    public static boolean containsNAND_CI(String srcStr, char... compareChar)
    { return CONTAINS_NAND_OR(true, NAND, srcStr, compareChar); }


    // ********************************************************************************************
    // ********************************************************************************************
    // STARTS-WITH, ENDS-WITH
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * <EMBED CLASS=defs DATA-DESC='ends with at least one' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean endsWithOR(String srcStr, char... compareChar)
    {
        char c = srcStr.charAt(srcStr.length() - 1);
        for (char c2 : compareChar) if (c2 == c) return true;
        return false;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not end with any' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean endsWithNAND(String srcStr, char... compareChar)
    {
        char c = srcStr.charAt(srcStr.length() - 1);
        for (char c2 : compareChar) if (c2 == c) return false;
        return true;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='starts with at least one' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean startsWithOR(String srcStr, char... compareChar)
    {
        char c = srcStr.charAt(0);
        for (char c2 : compareChar) if (c2 == c) return true;
        return false;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not start with any' DATA-CI='is'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean startsWithNAND(String srcStr, char... compareChar)
    {
        char c = srcStr.charAt(0);
        for (char c2 : compareChar) if (c2 == c) return false;
        return true;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // STARTS-WITH, ENDS-WITH - CASE INSENSITIVE
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * <EMBED CLASS=defs DATA-DESC='ends with at least one' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean endsWithOR_CI(String srcStr, char... compareChar)
    {
        char c = Character.toLowerCase(srcStr.charAt(srcStr.length() - 1));
        for (char c2 : compareChar) if (Character.toLowerCase(c2) == c) return true;
        return false;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not end with any' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean endsWithNAND_CI(String srcStr, char... compareChar)
    {
        char c = Character.toLowerCase(srcStr.charAt(srcStr.length() - 1));
        for (char c2 : compareChar) if (Character.toLowerCase(c2) == c) return false;
        return true;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='starts at least one' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean startsWithOR_CI(String srcStr, char... compareChar)
    {
        char c = Character.toLowerCase(srcStr.charAt(0));
        for (char c2 : compareChar) if (Character.toLowerCase(c2) == c) return true;
        return false;
    }

    /**
     * <EMBED CLASS=defs DATA-DESC='does not start with any' DATA-CI='is not'>
     * <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_DESC>
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char's} used in the comparison against {@code 'srcStr'}
     * @return <EMBED CLASS='external-html' DATA-FILE-ID=STR_CH_RET>
     */
    public static boolean startsWithNAND_CI(String srcStr, char ... compareChar)
    {
        char c = Character.toLowerCase(srcStr.charAt(0));
        for (char c2 : compareChar) if (Character.toLowerCase(c2) == c) return false;
        return true;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Single char-primitive methods
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Checks whether or not {@code 'srcStr'} <B STYLE='color: red;'>starts-with</B>
     * {@code 'compareChar'}.
     * 
     * <BR /><BR />This method <B STYLE='color: red;'>** is not**</B> case-sensitive.
     * 
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char} used in the comparison against {@code 'srcStr'}
     * @return {@code TRUE} if {@code 'srcStr'} begins with {@code 'compareChar'}, ignoring case.
     */
    public static boolean startsWithIgnoreCase(String srcStr, char compareChar)
    { return Character.toLowerCase(srcStr.charAt(0)) == Character.toLowerCase(compareChar); }

    /**
     * Checks whether or not {@code 'srcStr'} <B STYLE='color: red;'>ends-with</B>
     * {@code 'compareChar'}.
     * 
     * <BR /><BR />This method <B STYLE='color: red;'>** is not**</B> case-sensitive.
     * 
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char} used in the comparison against {@code 'srcStr'}
     * @return {@code TRUE} if {@code 'srcStr'} ends with {@code 'compareChar'}, ignoring case.
     */
    public static boolean endsWithIgnoreCase(String srcStr, char compareChar)
    {
        return Character.toLowerCase(srcStr.charAt(srcStr.length() - 1)) == 
            Character.toLowerCase(compareChar); 
    }

    /**
     * Checks whether or not {@code 'srcStr'} <B STYLE='color: red;'>contains</B>
     * {@code 'compareChar'}.
     * 
     * <BR /><BR />This method <B STYLE='color: red;'>** is not**</B> case-sensitive.
     * 
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char} used in the comparison against {@code 'srcStr'}
     * @return {@code TRUE} if {@code 'srcStr'} begins with {@code 'compareChar'}, ignoring case.
     */
    public static boolean containsIgnoreCase(String srcStr, char compareChar)
    {
        compareChar = Character.toLowerCase(compareChar);

        int len = srcStr.length();

        for (int i=0; i < len; i++)
            if (Character.toLowerCase(srcStr.charAt(i)) == compareChar)
                return true;

        return false;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // PROTECTED CONTAINS HELPER
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Signifies that an {@code 'AND'} operation is required, but only for methods that implement
     * one of the {@code 'contains'} variants.
     */
    protected static final byte AND = 0;

    /**
     * Signifies that an {@code 'AND'} operation is required, but only for methods that implement
     * one of the {@code 'contains'} variants.
     */
    protected static final byte OR = 1;

    /**
     * Signifies that an {@code 'AND'} operation is required, but only for methods that implement
     * one of the {@code 'contains'} variants.
     */
    protected static final byte NAND = 2;

    /**
     * Signifies that an {@code 'AND'} operation is required, but only for methods that implement
     * one of the {@code 'contains'} variants.
     */
    protected static final byte XOR = 3;

    /**
     * A protected helper method for <B>{@code NAND}</B> and <B>{@code OR}</B> 'contains' methods.
     * 
     * <BR /><BR /><B STYLE='color: red;'>NOTE:</B> Does not error check the value passed to
     * {@code 'booleanOperation'}.
     * 
     * @param ignoreCase Whether the comparisons performed should ignore case.
     * @param booleanOperation Accepts only {@link StrCh#NAND} and {@link StrCh#OR}.
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char} used in the comparison against {@code 'srcStr'}
     */
    protected static boolean CONTAINS_NAND_OR
        (boolean ignoreCase, byte booleanOperation, String srcStr, char[] compareChar)
    {
        if (ignoreCase)
        {
            char[] temp = new char[compareChar.length];

            for (int i=0; i < compareChar.length; i++)
                temp[i] = Character.toLowerCase(compareChar[i]);

            compareChar = temp;
        }

        int len = srcStr.length();

        for (int i=0; i < len; i++)
        {
            char c = ignoreCase ? Character.toLowerCase(srcStr.charAt(i)) : srcStr.charAt(i);

            for (char c2 : compareChar)

                if (c2 == c)

                    switch(booleanOperation)
                    {
                        case NAND:  return false;
                        case OR:    return true;
                    }
        }

        switch (booleanOperation)
        {
            case NAND:  return true;
            case OR:    return false;
        }

        throw new UnreachableError();
    }

    /**
     * A protected helper method for <B>{@code XOR}</B> and <B>{@code AND}</B> 'contains' methods.
     * 
     * <BR /><BR /><B STYLE='color: red;'>NOTE:</B> Does not error check the value passed to
     * {@code 'booleanOperation'}.
     * 
     * @param ignoreCase Whether the comparisons performed should ignore case.
     * @param booleanOperation Accepts only {@link StrCh#XOR} and {@link StrCh#AND}.
     * @param srcStr Any non-null instance of {@code java.lang.String}
     * @param compareChar The {@code char} used in the comparison against {@code 'srcStr'}
     */
    protected static boolean CONTAINS_XOR_AND
        (boolean ignoreCase, byte booleanOperation, String srcStr, char[] compareChar)
    {
        int count = 0;

        // There is a TreeSet so that multiple instances of the same character ARE NOT CHECKED.
        // Once a character has been found, it is more efficient to stop testing for it at all.

        TreeSet<Character> ts = new TreeSet<>();

        // When building the TreeSet of characters to check, if 'ignoreCase' has been requested,
        // then doing the case-conversion before entering the loop is more efficient.

        if (ignoreCase) for (char c : compareChar) ts.add(Character.toLowerCase(c));
        else            for (char c : compareChar) ts.add(c);

        // Iterate each character in the passed 'srcStr'
        int len = srcStr.length();

        for (int i=0; i < len; i++)
        {
            char c = ignoreCase ? Character.toLowerCase(srcStr.charAt(i)) : srcStr.charAt(i);

            // Iterate each of the remaining compare-characters in the TreeSet.  These characters
            // are removed when matches are found.

            INNER:
            for (char c2 : ts)

                if (c2 == c)
                {
                    ts.remove(c2);

                    switch (booleanOperation)
                    {
                        case AND: if (--count == 0) return true; else break INNER;
                        case XOR: if (++count > 1)  return false; else break INNER;
                    }
                }
        }

        switch (booleanOperation)
        {
            // If the count had reached zero, then true would ALREADY have been returned.
            case AND: return false;

            // Whether or not a match has been found is all that is left to check.
            case XOR: return count == 1;
        }

        throw new UnreachableError();
    }
}