package Torello.BuildJAR.Generators.CodeGen;

import Torello.Java.StringParse;
import Torello.Java.FileRW;

import java.io.IOException;

public class TokIndexOfCodeGen
{
    private static final String[] methods =
    { "all", "first", "last", "nth", "nthFromEnd", "left", "nthLeft" };

    private static final boolean[] BOOLS = { true, false };

    private static final String I4   = "    ";
    private static final String I8   = I4 + I4;
    private static final String I12  = I8 + I4;
    private static final String I16  = I12 + I4;

    public static void main(String[] argv) throws IOException
    { 
        StringBuffer sb = new StringBuffer();

        sb.append(
            "package Torello.Java;\n\n" +
            "import java.util.Vector;\n" +
            "import java.util.function.Predicate;\n" +
            "import java.util.stream.IntStream;\n\n" +
            "/**\n" +
            " * The purpose of this class is to help find the location of " +
                "{@code Token-Matches} inside\n" +
            " * of an input source-{@code String}.\n" +
            " * \n" +
            " * <EMBED CLASS='external-html' DATA-FILE-ID=STR_TOKINDEX_OF>\n" +
            " */\n" +
            "@Torello.JavaDoc.StaticFunctional\n" +
            "@Torello.JavaDoc.JDHeaderBackgroundImg\n" +
            "public class StrTokIndexOf\n" +
            "{\n" +
            "    private StrTokIndexOf() { }\n\n"
        );

        for (String method : methods)
            for (boolean caseInsensitive : BOOLS)
                for (boolean subRange : BOOLS)
                    for (boolean charOrString : BOOLS)
                        for (boolean hasPred : BOOLS)


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // The LOOP-BODY is Un-Indented, Just to keep it readable.
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            if (subRange && (method.equals("left") || method.equals("nthLeft")))
                continue;
            else sb
                .append(javaDoc(method, caseInsensitive, subRange, charOrString, hasPred))
                .append(signature(method, caseInsensitive, subRange, charOrString, hasPred))
                .append(body(method, caseInsensitive, subRange, charOrString, hasPred));


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // END OF LOOP BODY
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        sb.append("}");

        FileRW.writeFile(sb.toString(), "StrTokIndexOf.java");
    }


    private static String javaDoc(
            String method, boolean caseInsensitive, boolean subRange, boolean charOrString,
            boolean hasPred
        )
    {
        String ret = I4 + "/**\n";

        String cOrS = charOrString  
            ? "{@code char}-parameter\n" + I4 + " * {@code 'c'} "
            : "{@code String}-param\n" + I4 + " * {@code 'token'} ";

        String retInt = 
            "in {@code 'srcStr'}, and return the integer index-location into \n" +
            I4 + " * {@code 'srcStr'} where the match occured.\n";

        String retArr = 
            "in {@code 'srcStr'}, and return an integer-array of index-locations into\n" +
            I4 + " * {@code 'srcStr'} indicating where matches have occured.\n";

        switch (method)
        {
            case "first": ret +=
                I4 + " * Search for the <B STYLE='color: red'>first</B> {@code token}-match of " +
                cOrS + retInt;

                break;

            case "last": ret +=
                I4 + " * Search for the <B STYLE='color: red'>last</B> {@code token}-match of " +
                cOrS + retInt;

                break;

            case "all": ret +=
                I4 + " * Search for <B STYLE='color: red'>all</B> {@code token}-matches of" +
                cOrS + retArr;

                break;

            case "nth": ret +=
                I4 + " * Search for the <B STYLE='color: red'>nth</B> {@code token}-match of " +
                cOrS + retInt;

                break;

            case "nthFromEnd": ret +=
                I4 + " * Search for the <B STYLE='color: red'>nth</B> {@code token}-match of " +
                cOrS + "but <I>start the search with the last character of the String, " +
                    "and work\n" +
                I4 + " * <B STYLE='color: red;'>left</B></I>.  Return the integer index-" +
                    "location into\n" +
                I4 + " * {@code 'srcStr'} where the match occured.\n";

                break;

            case "left": ret +=
                I4 + " * Search for the <B STYLE='color: red'>first</B> {@code token}-match of " +
                cOrS + "<I>searching <B STYLE='color: red;'>left</B> beginning at " +
                    "{@code 'srcStr'}\n" +
                I4 + " * position {@code 'fromIndex'}</I>.  Return the integer " +
                    "index-location into\n" +
                I4 + " * {@code 'srcStr'} where the match occured.\n";

                break;

            case "nthLeft": ret +=
                I4 + " * Search for the <B STYLE='color: red'>nth</B> {@code token}-match of " +
                cOrS + " in {@code 'srcStr'}, but <I>begin the search at index-position " +
                    "{@code 'fromIndex'}\n" +
                I4 + " * and work <B STYLE='color: red;'>left</B></I>.  Return the integer " +
                    "index-location into\n" +
                I4 + " * {@code 'srcStr'} where the match occured.\n";

                break;

            default: throw new Torello.Java.UnreachableError();
        }

        if (caseInsensitive) ret +=
            I4 + " * \n" +
            I4 + " * <BR /><BR />The comparisons performed " +
                "<B STYLE='color: red'>** are not **</B> case-sensitive\n";

        else ret +=
            I4 + " * \n" +
            I4 + " * <BR /><BR />The comparisons performed " +
                "<B STYLE='color: red'>** are **</B> case-sensitive\n";

        if (subRange) ret +=
            I4 + " * \n" +
            I4 + " * <EMBED CLASS='external-html' DATA-FILE-ID=STR_SUBSECT>\n";

        ret +=
            I4 + " * \n" +
            I4 + " * @param srcStr This may be any {@code java.lang.String}.  Its contents will " +
                "be searched for\n" +
            I4 + " * the specified {@code token}-matches, and an ";

        ret += method.equals("all")
            ? "integer-array of {@code String}-index pointers\n" + I4 + " * will be returned.\n"
            : "an index-pointer (an integer) will be returned.\n";

        if (subRange) ret +=
            I4 + " * \n" +
            I4 + " * @param sPos <EMBED CLASS='external-html' DATA-FILE-ID=SPOSSTR>\n" +
            I4 + " * @param ePos <EMBED CLASS='external-html' DATA-FILE-ID=EPOSSTR>\n";

        if (method.equals("left") || method.equals("nthLeft")) ret +=
            I4 + " * \n" +
            I4 + " * @param fromIndex This is the right-most index-position in {@code 'srcStr'} " +
                "(*INCLUSIVE*)\n" +
            I4 + " * from where the search shall start.\n";

        if (method.startsWith("nth")) ret +=
            I4 + " * \n" +
            I4 + " * @param n This is the number of matches to skip when searching for " +
            cOrS + " before returning an answer.\n";

        ret += I4 + " * \n";

        if (charOrString) ret +=
            I4 + " * @param c This is the character that will be 'searched-for' in " +
                "input-parameter\n" +
            I4 + " * {@code String 'srcStr'}.\n";

        else ret +=
            I4 + " * @param token This is the sub-string that will be 'searched-for' in " +
                "input-parameter\n" +
            I4 + " * {@code String 'srcStr'}.\n";


        if (hasPred)
        {
            ret += I4 + " * \n";

            if (charOrString) ret +=
                I4 + " * @param extraDelimiterTest <EMBED CLASS='external-html' " +
                    "DATA-FILE-ID=STIO_XTRADELIM_CHAR>\n";

            else ret +=
                I4 + " * @param extraDelimiterTest <EMBED CLASS='external-html' " +
                "DATA-FILE-ID=STIO_XTRADELIM_STR>\n";
        }


        ret += I4 + " * \n";

        switch (method)
        {
            case "first": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the " +
                    "<B STYLE='color: red;'>first</B>\n" +
                I4 + " * identified <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}\n";

                break;

            case "last": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the " +
                    "<B STYLE='color: red;'>last</B>\n" +
                I4 + " * identified <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}\n";

                break;

            case "all": ret +=
                I4 + " * @return An integer-pointer array of <B STYLE='color: red;'>all</B>\n" +
                I4 + " * {@code java.lang.String}-indices where matches were found.\n";

                break;

            case "nth": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the " +
                    "<B STYLE='color: red;'>nth</B> identified\n" +
                I4 + " * <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}\n";

                break;

            case "nthFromEnd": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the " +
                    "<B STYLE='color: red;'>nth</B> identified\n" +
                I4 + " * <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}, <I>counting\n" +
                I4 + " * <B STYLE='color: red;'>left</B> from the end of " +
                    "{@code 'srcStr'}</I>\n";

                break;

            case "left": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the " +
                    "<B STYLE='color: red;'>nth</B> identified\n" +
                I4 + " * <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}, <I>performing the search in the\n" +
                I4 + " * <B STYLE='color: red;'>left</B> direction, beginning at " +
                    "{@code String}-index\n" +
                I4 + " * {@code 'fromIndex'}</I>\n";

                break;

            case "nthLeft": ret +=
                I4 + " * @return The {@code 'srcStr' String}-index of the nth identified\n" +
                I4 + " * <B>{@code TOKEN-" + (charOrString ? "Character" : "String") +
                    "}</B> match in {@code 'srcStr'}, <I>performing the search in the\n" +
                I4 + " * <B STYLE='color: red;'>left</B> direction, beginning at " +
                    "{@code String}-index\n" +
                I4 + " * {@code 'fromIndex'}</I>\n";

                break;

            default: throw new Torello.Java.UnreachableError();
        }

        ret +=
            I4 + " * \n" +
            I4 + " * <EMBED CLASS='external-html' DATA-FILE-ID=" +
                (charOrString ? "STIO_CHAR_RET" : "STIO_STR_RET") + ">\n";

        if (hasPred)
            ret += I4 + " * <EMBED CLASS='external-html' DATA-FILE-ID=STIO_XTRADELIM_RET>\n";

        if (subRange) ret +=
            I4 + " * \n" +
            I4 + " * @throws StringIndexOutOfBoundsException\n" +
            I4 + " * <EMBED CLASS='external-html' DATA-FILE-ID=SIOOB_EX>\n";

        if (method.equals("nth") || method.equals("nthFromEnd") || method.equals("nthLeft")) ret +=
            I4 + " * \n" +
            I4 + " * @throws NException If the value of {@code 'n'} is negative, or greater than\n" +
            I4 + " * {@code srcStr.length()}, this exception shall throw.\n";

        ret += I4 + " */\n";
        return ret;
    }


    private static String signature(
            String method, boolean caseInsensitive, boolean subRange, boolean charOrString,
            boolean hasPred
        )
    {
        String ret = 
            I4 + "public static " +
            (method.equals("all") ? "int[] " : "int ") +
            method +
            (caseInsensitive ? "_CI" : "") +
            "(String srcStr, " +
            (subRange ? "int sPos, int ePos, " : "");

        switch (method)
        {
            case "first":                                           break;
            case "last":                                            break;
            case "all":                                             break;
            case "nth":         ret += "int n, ";                   break;
            case "nthFromEnd":  ret += "int n, ";                   break;
            case "left":        ret += "int fromIndex, ";           break;
            case "nthLeft":     ret += "int fromIndex, int n, ";    break;

            default: throw new Torello.Java.UnreachableError();
        }

        if (charOrString)   ret += "char c";
        else                ret += "String token";

        if (hasPred)        ret += ", Predicate<Character> extraDelimiterTest)\n";
        else                ret += ")\n";

        if (ret.length() > 95) ret = ret.replace("(", "\n" + I8 + "(");

        java.util.function.Predicate<Character> p = c -> ".;,!()".contains(c.toString());

        return ret;
    }


    private static String body(
            String method, boolean caseInsensitive, boolean subRange, boolean charOrString,
            boolean hasPred
        )
    {
        String ret = I4 + "{\n";

        if (method.equals("nth") || method.equals("nthFromEnd") | method.equals("nthLeft"))
            ret += I8 + "NException.check(n, srcStr);\n\n";


        int varTypeSpacing;

        if (method.equals("all"))   varTypeSpacing = "IntStream.Builder   ".length();
        else if (! charOrString)    varTypeSpacing = "int ".length();
        else                        varTypeSpacing = "LV ".length();


        int varNameSpacing;

        if (! charOrString) varNameSpacing = "tokenLen   ".length();
        else                varNameSpacing = "l ".length(); // Same / can use "b ".length();

        if (method.equals("left") || method.equals("nthLeft")) ret +=
            I8 + StringParse.rightSpacePad("LV ", varTypeSpacing) +
                StringParse.rightSpacePad("l", varNameSpacing) + "= new LV(srcStr, 0, fromIndex";

        else if (subRange) ret +=
            I8 + StringParse.rightSpacePad("LV", varTypeSpacing) +
                StringParse.rightSpacePad("l", varNameSpacing) + "= new LV(srcStr, sPos, ePos";

        else ret +=
            I8 + StringParse.rightSpacePad("LV", varTypeSpacing) +
                StringParse.rightSpacePad("l", varNameSpacing) + "= new LV(srcStr, 0, -1";

        ret += charOrString
            ? ");\n"
            : ", token.length());\n";

        if (method.equals("all")) ret +=
            I8 + StringParse.rightSpacePad("IntStream.Builder", varTypeSpacing) +
                StringParse.rightSpacePad("b", varNameSpacing) + "= IntStream.builder();\n";

        if (! charOrString) ret +=
            I8 + StringParse.rightSpacePad("int", varTypeSpacing) +
                StringParse.rightSpacePad("tokenLen", varNameSpacing) + "= token.length();\n";

        if (charOrString && caseInsensitive) ret +=
            '\n' + I8 + "c = Character.toLowerCase(c);\n";



        // THESE TWO METHODS ARE **EXCLUSIVE** TOWARDS 'l.end'
        if (method.equals("last") || method.equals("nthFromEnd"))
            ret += '\n' + I8 + "for (int i=(l.end-1); i >= l.start; i--)\n\n";

        // THESE TWO METHODS ARE **INCLUSIVE** TOWARDS 'l.end'
        else if (method.equals("left") || method.equals("nthLeft"))
            ret += '\n' + I8 + "for (int i=l.end; i >= 0; i--)\n\n";

        // OTHER METHODS ARE ALL "Same old same old"
        else
            ret += '\n' + I8 + "for (int i=l.start; i < l.end; i++)\n\n";

        /*
        if (method.equals("last") || method.equals("left") || method.equals("nthLeft")
            || method.equals("nthFromEnd")
        )
            ret += '\n' + I8 + "for (int i=(l.end-1); i >= l.start; i--)\n\n";
        else
            ret += '\n' + I8 + "for (int i=l.start; i < l.end; i++)\n\n";
        */


        if (charOrString) ret +=

            I12 + "if (    (c == " + (caseInsensitive ? "Character.toLowerCase(" : "") +
                "srcStr.charAt(i))" + (caseInsensitive ? ")\n" : "\n") +
            I12 + "    &&  (    (i==0)\n" +
            I12 + "        ||   Character.isWhitespace(srcStr.charAt(i-1))" +

            (hasPred 
                ?  ('\n' +  I12 + "        ||   extraDelimiterTest.test(srcStr.charAt(i-1)))\n")
                :  ")\n") +

            I12 + "    &&  (    ((i+1) == srcStr.length())\n" +
            I12 + "        ||   Character.isWhitespace(srcStr.charAt(i+1))" +

            (hasPred 
                ?  ('\n' +  I12 + "        ||   extraDelimiterTest.test(srcStr.charAt(i+1)))\n")
                :  ")\n") +

            I12 + ")\n";


        else ret +=

            I12 + "if (    srcStr.regionMatches(" + (caseInsensitive ? "true, " : "") +
                "i, token, 0, tokenLen)\n" +
            I12 + "    &&  (    (i==0)\n" +
            I12 + "        ||   Character.isWhitespace(srcStr.charAt(i-1))" +

            (hasPred 
                ?  ('\n' +
                    I12 + "        ||   extraDelimiterTest.test(srcStr.charAt(i-1)))\n")
                :  ")\n") +

            I12 + "    &&  (    ((i + tokenLen) == srcStr.length())\n" +
            I12 + "        ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))" +

            (hasPred 
                ?  ('\n' +
                    I12 + "        ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))\n")
                :  ")\n") +

            I12 + ")\n";


        boolean nthMethod = method.equals("nth") || method.equals("nthLeft") ||
            method.equals("nthFromEnd");

        if (method.equals("all")) ret +=
            I16 + (nthMethod ? "if (--n == 0) " : "") + "b.accept(i);\n";

        else ret +=
            I16 + (nthMethod ? "if (--n == 0) " : "") + "return i;\n";


        if (method.equals("all")) ret +=
            '\n' +
            I8 + "return b.build().toArray();\n";

        else ret +=
            '\n' +
            I8 + "return -1;\n";
    

        return ret + I4 + "}\n\n";
    }
}