package Torello.Java;

import Torello.Java.StringParse;
import Torello.Java.StrPrint;
import Torello.Java.StrIndexOf;
import Torello.Java.Verbosity;

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

import java.io.IOException;
import java.util.stream.Stream;

// NOTE: Using 'final' everywhere here just helps remember that these are not being iterated,
// changed or modified inside the For-Loops.  It (sort of) helps "readability" (at least for me
// anyway)

class PrintingRecMultiLine
{
    // Re-Use the Pointer, I guess
    private static final String I4 = Helper.I4;


    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
    // Fields
    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

    final int matchPosStart;            // Match Starting-Position
    final int matchPosEnd;              // Match Ending-Position Array-Index

    final int matchLineNumStart;        // Line-Number of First-Line of Match
    final int matchLineNumEnd;          // Line-Number of Last-Line of Match

    final int startLineFirstCharPos;    // String-index of First-Character of First-Line
    final int endLineLastCharPos;       // String-index of Last-Character of Last-Line

    // NOTE: Presently, the start and end Column-Numbers are computed but ignored.
    //       (These numbers are never printed, though that was the original plan).
    //       Printing these two integers makes the output look just too verbose.

    final int matchStartCol;            // Column-Number of First String-Index of Match
    final int matchEndCol;              // Column-Number of Last String-Index of Match

    final String[] matchLines;          // Lines of Text of the Match
    final String[] replaceLines;        // Lines of Text of the Replacement

    final int[] matchLineLengths;       // Length of each Line of Text of the Match
    final int[] replaceLineLengths;     // Length of each Line of Text of the Replacement

    final String replaceStr;            // Match Replacement String

    final int replaceEndLineNum;        // Line-Number of Last-Line of Replacement
    final int replaceEndCol;            // Column number of Last-Character of Replacement


    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
    // Constructor
    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

    PrintingRecMultiLine(
            final String                fileAsStr,
            final int                   matchPosStart,
            final int                   matchPosEnd,
            final String                replaceStr,
            final PrintingRecMultiLine  prevRec,
            final boolean               useUNIXColors
        )
    {
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Basic Stuff: String-Index of Match-Start  &&  String-Index of Match-End
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        this.matchPosStart  = matchPosStart;
        this.matchPosEnd    = matchPosEnd;
        this.replaceStr     = replaceStr;


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Line-Number containing the Match-Start  &&  Line-Number containing the Match-End
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        /*
        System.out.println(
            "fileAsStr.substring: [" + fileAsStr.substring(matchPosStart, matchPosEnd) + "]\n" +
            "replaceStr: " + replaceStr
        );
        */

        // Initialize the Starting Line Number of the Match (Use StrPrint method)
        this.matchLineNumStart = (prevRec == null)

            ? StrPrint.lineNumber(fileAsStr, matchPosStart)

            : StrPrint.lineNumberSince(
                    fileAsStr, matchPosStart,
                    prevRec.matchLineNumEnd, prevRec.matchPosEnd
                );

        // Initialize the Ending Line Number of the Match (also with StrPrint method)
        this.matchLineNumEnd = StrPrint.lineNumberSince
            (fileAsStr, matchPosEnd, this.matchLineNumStart, this.matchPosStart);           

        /*
        System.out.println(
            "this.matchLineNumStart: " + this.matchLineNumStart + '\n' +
            "this.matchLineNumEnd: " + this.matchLineNumEnd
        );
        */


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // First-Char of First-Line, Last-Char of Last-Line
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        //
        // These are **NOT** the same as matchPosStart & matchPosEnd

        // Loop-Variables, used below
        int i;
        final int FILE_LEN = fileAsStr.length();

        // Compute the String[]-Array index for First-Charater in the First-Line of the Match
        for (i=matchPosStart; (i >= 0) && (fileAsStr.charAt(i) != '\n'); i--);
        this.startLineFirstCharPos = i + 1;

        // Compute the String[]-Array index for the Last-Charater in the Last-Line of the Match
        for (i=matchPosEnd; (i < FILE_LEN) && (fileAsStr.charAt(i) != '\n'); i++);
        this.endLineLastCharPos = i;


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Match-Start String-Index Column  &&  Match-End String-Index Column
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        this.matchStartCol  = this.matchPosStart - this.startLineFirstCharPos;
        this.matchEndCol    = this.endLineLastCharPos - this.matchPosEnd;


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Lines of Text of the Match, itself
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        final String _BCYAN   = useUNIXColors ? BCYAN : "";
        final String _BGREEN  = useUNIXColors ? BGREEN : "";
        final String _RESET   = useUNIXColors ? RESET : "";
        final String preStr   = fileAsStr.substring(this.startLineFirstCharPos, matchPosStart);
        final String matchStr = fileAsStr.substring(matchPosStart, matchPosEnd);
        final String postStr  = fileAsStr.substring(matchPosEnd, this.endLineLastCharPos);

        // The list of newline characters inside the Match-String
        int[] posArr = StrIndexOf.all(matchStr, '\n');

        // Build a String[]-Array of the Lines that comprise the Match-String
        Stream.Builder<String> linesBuilder = Stream.builder();

        for (i=0; i < posArr.length; i++)

            linesBuilder.accept(
                ((i == 0) ? preStr : "") +
                _BGREEN +
                matchStr.substring(((i == 0) ? 0 : (posArr[i-1] + 1)), posArr[i]) +
                RESET
                // ((i == (posArr.length - 1)) ? (RESET + postStr) : "")
            );

        // An **ENDING-READ** that makes sure to insert the last-section after the last '\n'
        linesBuilder.accept(
            ((i == 0) ? preStr : "") +
            _BGREEN +
            matchStr.substring(((i == 0) ? 0 : (posArr[i-1] + 1)), matchStr.length()) +
            RESET + postStr
        );

        this.matchLines = linesBuilder.build().toArray(String[]::new);


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Lines of Text of the Replaceent
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // The list of newlne characters inside the Replacement-String
        posArr = StrIndexOf.all(replaceStr, '\n');

        // Build a String[]-Array of the Lines that comprise the Replacement-String
        linesBuilder = Stream.builder();

        for (i=0; i < posArr.length; i++)

            linesBuilder.accept(
                ((i == 0) ? preStr : "") +
                _BCYAN +
                replaceStr.substring(((i == 0) ? 0 : (posArr[i-1] + 1)), posArr[i]) +
                RESET
            );

        // An **ENDING-READ** that makes sure to insert the last-section after the last '\n'
        linesBuilder.accept(
            ((i == 0) ? preStr : "") +
            _BCYAN +
            replaceStr.substring(((i == 0) ? 0 : (posArr[i-1] + 1)), replaceStr.length()) +
            RESET + postStr
        );

        this.replaceLines = linesBuilder.build().toArray(String[]::new);


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Match Line-Lengths Array
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // There is an additional '+1' because of the '\n' **ITSELF**.  If you include the '\n'
        // in the Line-Length Computation, the length of the line will be identical to what the
        // Text-Editor says about the Line-Length.
        //
        // The rule of "Line-Length Max 100" (no more than 100 characters in a line), is
        // consistent with what the Text-Editor says about the Line-Length.  Again, the Text
        // Editor would say that the Line-Length includes the '\n'

        final int OTHER = 1 - _BGREEN.length() - _RESET.length();

        this.matchLineLengths = new int[this.matchLines.length];

        for (i=0; i < this.matchLines.length; i++)
            this.matchLineLengths[i] = this.matchLines[i].length() + OTHER;


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Replacement Line-Lengths Array
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        this.replaceLineLengths = new int[this.replaceLines.length];

        for (i=0; i < this.replaceLines.length; i++)
            this.replaceLineLengths[i] = this.replaceLines[i].length() + OTHER;


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Replacement-String Character-Stuff
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // final int replaceEndLineNum; // Line-Number of Last-Line of Replacement
        this.replaceEndLineNum = this.matchLineNumStart + this.replaceLines.length;

        // final int replaceEndCol; // Column number of Last-Character of Replacement
        this.replaceEndCol = this.replaceLines[this.replaceLines.length - 1].length();
    }


    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
    // Print All
    // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

    static void printAll(
            final PrintingRecMultiLine[]    recs,
            final Appendable                appendable,
            final boolean                   useUNIXColors,
            final Verbosity                 verbosity
        )
        // This method cannot actually throw IOException.
        throws IOException
    {
        // '.....' is printed when the user requests Verbosity.Quiet mode.  Therefore in this
        // particular case, it is necessary to print a newline character.

        if (verbosity == Verbosity.Quiet) appendable.append('\n');

        int MAX_LINE_LEN = 0;
        int MAX_LINE_NUM = 0;
        int MAX_COL      = 0;

        for (PrintingRecMultiLine r : recs)
        {
            for (int i : r.matchLineLengths)    if (i > MAX_LINE_LEN) MAX_LINE_LEN = i;
            for (int i : r.replaceLineLengths)  if (i > MAX_LINE_LEN) MAX_LINE_LEN = i;

            if (r.matchLineNumEnd   > MAX_LINE_NUM) MAX_LINE_NUM = r.matchLineNumEnd;
            if (r.replaceEndLineNum > MAX_LINE_NUM) MAX_LINE_NUM = r.replaceEndLineNum;

            // System.out.println("r.matchLineNumEnd: " + r.matchLineNumEnd);
            // System.out.println("r.replaceEndLineNum: " + r.replaceEndLineNum);

            if (r.matchEndCol   > MAX_COL) MAX_COL = r.matchEndCol;
            if (r.replaceEndCol > MAX_COL) MAX_COL = r.replaceEndCol;
        }

        final int LINE_LEN_CHARS    = 1 + ((int) Math.floor(Math.log10(MAX_LINE_LEN)));
        final int LINE_NUM_CHARS    = 1 + ((int) Math.floor(Math.log10(MAX_LINE_NUM)));
        final int COL_CHARS         = 1 + ((int) Math.floor(Math.log10(MAX_COL)));

        StringBuilder sb = new StringBuilder();
        int matchNum = 1;

        for (PrintingRecMultiLine r : recs)
        {
            sb.append("Original Text, Match #" + matchNum + ":\n");

            int lineNum = r.matchLineNumStart;

            for (int i=0; i < r.matchLines.length; i++)
            {
                String lineNumStr = "" + (lineNum++);
                lineNumStr += StringParse.nChars(' ', LINE_NUM_CHARS - lineNumStr.length());
        
                String lineLenStr = "" + r.matchLineLengths[i];
                lineLenStr += StringParse.nChars(' ', LINE_LEN_CHARS - lineLenStr.length());

                if (useUNIXColors)
                {
                    lineNumStr = BYELLOW + lineNumStr + RESET;
                    lineLenStr = BYELLOW + lineLenStr + RESET;
                }
                
                sb.append(
                    I4 +
                    "Line #: " + lineNumStr + ' ' +
                    "Len: " + lineLenStr + ' ' +
                    r.matchLines[i] + '\n'
                );
            }

            sb.append("Updated Text, Match #" + matchNum + ":\n");

            lineNum = r.matchLineNumStart;

            for (int i=0; i < r.replaceLines.length; i++)
            {
                String lineNumStr = "" + (lineNum++);
                lineNumStr += StringParse.nChars(' ', LINE_NUM_CHARS - lineNumStr.length());
        
                String lineLenStr = "" + r.replaceLineLengths[i];
                lineLenStr += StringParse.nChars(' ', LINE_LEN_CHARS - lineLenStr.length());

                if (useUNIXColors)
                {
                    lineNumStr = BYELLOW + lineNumStr + RESET;
                    lineLenStr = BYELLOW + lineLenStr + RESET;
                }

                sb.append(
                    I4 +
                    "Line #: " + lineNumStr + ' ' +
                    "Len: " + lineLenStr + ' ' +
                    r.replaceLines[i] + '\n'
                );
            }

            sb.append('\n');
            matchNum++;
        }

        appendable.append(sb.toString());
    }
}