package Torello.Java.Build;

import Torello.Java.Q;
import Torello.Java.FileRW;
import Torello.Java.StrCmpr;
import Torello.Java.StringParse;
import Torello.Java.FileNode;
import Torello.Java.RTC;

import static Torello.Java.C.BYELLOW;
import static Torello.Java.C.BCYAN;
import static Torello.Java.C.BGREEN;
import static Torello.Java.C.BRED;
import static Torello.Java.C.RESET;

import java.util.regex.Pattern;
import java.util.regex.Matcher;

import java.util.Vector;

import java.io.File;
import java.io.IOException;
import java.io.FileNotFoundException;

class JavaDocLineLengths
{
    // Regular Expression for breaking up long lines of JavaDoc Comments
    private static /* final */ Pattern LONG_JD_COMMENT = Pattern.compile
        ("^(     \\* [^\\n]{0,92})\\s([^\\n]+)\n");

    // Regular Expression for breaking up long lines of JavaDoc Comments
    private static final Pattern LONG_JD_COMMENT_INNERCLASS = Pattern.compile
        ("^(         \\* [^\\n]{0,88})\\s([^\\n]+)\n");

    // Regular Expression for matching lines that have JavaDoc Upgrade HiLite Dividers
    private static final Pattern OPENING_HILITE_DIV = Pattern.compile(
        "<DIV\\s+CLASS=['\\\"](EXAMPLE|SNIP|LOC|SHELL|HTML|REGEX|SHELLBLOCK|COMPLETE)" +
        "(-SCROLL)?['\\\"]\\w*>\\w*\\{",
        Pattern.CASE_INSENSITIVE);

    // Regular Expression for matching lines that have 'closing' HiLite Divider Elements.
    private static final Pattern CLOSING_HILITE_DIV = Pattern.compile
        ("\\}\\w*<\\/DIV>", Pattern.CASE_INSENSITIVE);

    // Long lines that don't require being queried by the user, because they only have text
    private static final Pattern SAFE_ENDING = Pattern.compile
        ("^.*?[\\w\\d\\s,\\-\\.]{20}$");

    // The first 7 characters of a line of text in JavaDoc Comments portions of source files.
    private static /* final */ String COMMENT_LINE_BEGINNING = "     * ";

    static void prepareForInnerClass()
    {
        LONG_JD_COMMENT = LONG_JD_COMMENT_INNERCLASS;

        COMMENT_LINE_BEGINNING =
            "    " + JavaDocLineLengths.COMMENT_LINE_BEGINNING;
    }

    private static final String[] PREV_LINE_MUST_BE_STRS =
    {
        "* @",
        "* <EMBED ",
        "* <BR /><BR />",

        "* <DIV ",
        "* <BR /><DIV ",

        "* <UL ",
        "* <BR /><UL ",

        "* <OL ",
        "* <BR /><OL ",

        "* <TABLE ",
        "* <BR /><TABLE "
    };

    private static final String[] CANNOT_PREPEND_TO_LINE_STRS =
        new String[11 + PREV_LINE_MUST_BE_STRS.length];

    static
    {
        System.arraycopy(
            PREV_LINE_MUST_BE_STRS, 0, CANNOT_PREPEND_TO_LINE_STRS,
            11, PREV_LINE_MUST_BE_STRS.length
        );

        CANNOT_PREPEND_TO_LINE_STRS[0]  = "* </UL>";
        CANNOT_PREPEND_TO_LINE_STRS[1]  = "* </OL>";
        CANNOT_PREPEND_TO_LINE_STRS[2]  = "* </TABLE>";
        CANNOT_PREPEND_TO_LINE_STRS[3]  = "* <LI>";
        CANNOT_PREPEND_TO_LINE_STRS[4]  = "* </LI>";
        CANNOT_PREPEND_TO_LINE_STRS[5]  = "* <TD>";
        CANNOT_PREPEND_TO_LINE_STRS[6]  = "* </TD>";
        CANNOT_PREPEND_TO_LINE_STRS[7]  = "* <TR>";
        CANNOT_PREPEND_TO_LINE_STRS[8]  = "* </TR>";
        CANNOT_PREPEND_TO_LINE_STRS[9]  = "* <TH>";
        CANNOT_PREPEND_TO_LINE_STRS[10] = "* </TH>";
    }

    // Performs a 'LINT' on the input Java Source Code File.
    //  
    // @param inFileOrDir This is any file or directory.  If this is a directory, the entire
    // directory will be scanned for {@code '.java'} source-files.  If this is a file, then it
    // will be the only file that is linted.
    // 
    // @throws FileNotFoundException If this file or directory is not found.

    static void lint(String inFileOrDir) throws IOException
    {
        File            f = new File(inFileOrDir);
        Vector<String>  files;

        if (! f.exists()) throw new FileNotFoundException
            ("A file or directory named [" + inFileOrDir + "], was not found.");

        boolean lintingDirectory = true;

        if (f.isDirectory()) files = FileNode
            .createRoot(inFileOrDir)
            .loadTree(1, (File file, String name) -> name.endsWith(".java"), null)
            .flattenJustFiles(RTC.FULLPATH_VECTOR());
        else 
        {
            files = new Vector<>();
            files.add(inFileOrDir);
            lintingDirectory = false;
        }

        for (int fNum=0; fNum < files.size(); fNum++)
        {
            String file = files.elementAt(fNum);

            System.out.println(
                "Linting File [" + BCYAN + (fNum+1) + " of " + files.size() + RESET + "]\n" +
                "Visiting File: " + BYELLOW + file + RESET + "\n"
            );

            Vector<String>  javaFile        = FileRW.loadFileToVector(file, true);
            boolean         insideHiLiteDIV = false;
            int             linesAdded      = 0;

            for (int i=1; i < (javaFile.size()-1); i++)
            {
                String  line                    = javaFile.elementAt(i);
                String  prevLine                = javaFile.elementAt(i-1);
                String  nextLine                = javaFile.elementAt(i+1);

                String  lineTrimmed             = line.trim();
                String  prevLineTrimmed         = prevLine.trim();
                String  nextLineTrimmed         = nextLine.trim();

                boolean lineIsComment           = line.startsWith(COMMENT_LINE_BEGINNING);
                boolean nextLineIsComment       = nextLine.startsWith(COMMENT_LINE_BEGINNING);
                boolean prevLineWasComment      = prevLine.startsWith(COMMENT_LINE_BEGINNING);

                boolean lineIsTooLong           = line.length() > 100;
                boolean prevLineWasBlankComment = prevLineTrimmed.equals("*");
                boolean nextLineIsEndingComment = nextLineTrimmed.equals("*/");
                boolean nthSeeTagInARow         = lineTrimmed.startsWith("* @see") && 
                                                    prevLineTrimmed.startsWith("* @see");

                boolean hasOpeningHiLiteDIV     = lineIsComment && 
                                                    OPENING_HILITE_DIV.matcher(lineTrimmed).find();

                boolean hasClosingHiLiteDIV     = lineIsComment && 
                                                    CLOSING_HILITE_DIV.matcher(lineTrimmed).find();

                boolean mustBePreceededByBlankCommentLine =
                    lineIsComment &&
                    StrCmpr.startsWithXOR_CI(lineTrimmed, PREV_LINE_MUST_BE_STRS);

                boolean appendToStartOfNextLineIsOK =
                    nextLineIsComment &&
                    (! StrCmpr.startsWithXOR_CI(nextLineTrimmed, CANNOT_PREPEND_TO_LINE_STRS)) &&
                    (! nextLineIsEndingComment);

                // ************************************************************
                // MAIN LOOP PART
                // ************************************************************

                if (hasOpeningHiLiteDIV)
                    insideHiLiteDIV = true;
                else
                {
                    if (hasClosingHiLiteDIV)
                    { insideHiLiteDIV = false; System.out.print(line); continue; }

                    if (insideHiLiteDIV)
                    { System.out.print(line); continue; }
                } // tricky...

                if (    mustBePreceededByBlankCommentLine
                    &&  (! prevLineWasBlankComment)
                    &&  (! nthSeeTagInARow)
                    )
                {
                    linesAdded++;
                    javaFile.add(i, COMMENT_LINE_BEGINNING + '\n');
                    System.out.print(BGREEN + COMMENT_LINE_BEGINNING + RESET + '\n');
                }
                else if (lineIsComment && lineIsTooLong)
                {
                    System.out.print(BRED + line + RESET);
                    Matcher m = LONG_JD_COMMENT.matcher(line);

                    if (! m.find()) throw new IllegalStateException("MESSED UP, WTF?");

                    String shortenedLine    = StringParse.trimRight(m.group(1));
                    String restOfThisLine   = line.substring(m.end(1)).trim();

                    System.out.print(shortenedLine + '\n');
                    javaFile.setElementAt(shortenedLine + '\n', i);

                    if (! SAFE_ENDING.matcher(shortenedLine).find())

                        while (! Q.YN(
                            "Break OK?  (Currently on Line #" + i + " of " +
                            javaFile.size() + ")"
                        ))
                        {
                            int pos = shortenedLine.lastIndexOf(' ');
                            if (pos == -1) System.exit(0);

                            restOfThisLine = shortenedLine.substring(pos + 1).trim() +
                                ' ' + restOfThisLine;
        
                            shortenedLine = StringParse.trimRight(shortenedLine.substring(0, pos));

                            System.out.print(BRED + shortenedLine + RESET + '\n');
                            javaFile.setElementAt(shortenedLine + '\n', i);
                        }

                    if (restOfThisLine.length() == 0) continue;

                    if (appendToStartOfNextLineIsOK)
                    {
                        nextLine = COMMENT_LINE_BEGINNING + restOfThisLine + ' ' + 
                            nextLine.substring(COMMENT_LINE_BEGINNING.length());

                        javaFile.setElementAt(nextLine, i+1);
                    }
                    else
                    {
                        linesAdded++;
                        javaFile.add(i+1, COMMENT_LINE_BEGINNING + restOfThisLine + '\n');
                    }
                }
                else System.out.print(line);
            }

            System.out.println(
                "Finished File:\t" + BYELLOW + file + RESET + '\n' +
                "Added [" + BCYAN + StringParse.zeroPad(linesAdded) + RESET + "] new lines " +
                "to  the file."
            );

            for (int count=5; count > 0; count--) 
                Q.YN(
                    "Press Y/N " + BCYAN + StringParse.zeroPad(count) + RESET +
                    " more times..."
                );

            String question = lintingDirectory
                ? "Save and continue to next file?"
                : "Save file?";

            if (! Q.YN(BGREEN + question + RESET)) System.exit(0);
            FileRW.writeFile_NO_NEWLINE(javaFile, file);
            System.out.println("Wrote File:\t" + BYELLOW + file + RESET);
        }
    }  
}