package Torello.Java;

import Torello.Java.Verbosity;
import Torello.Java.IOExceptionHandler;
import Torello.Java.FileNode;
import Torello.Java.FileRW;
import Torello.Java.StringParse;
import Torello.Java.Q;

import Torello.Java.Additional.AppendableSafe;
import Torello.Java.Additional.BiAppendable;

import java.util.regex.Pattern;
import java.util.regex.MatchResult;
import java.util.List;
import java.util.function.Function;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.Collectors;
import java.io.IOException;

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

    // Only Method
    static List<FileNode> match(
            final Iterable<FileNode>            files,
            final Pattern                       regEx,
            final Function<MatchResult, String> replaceFunction,
            final boolean                       askFirst,
            final IOExceptionHandler            ioeh,
            final Appendable                    outputSaver,
            final boolean                       useUNIXColors,
            final Verbosity                     verbosity
        )
        throws IOException
    {
        Helper.CHECK(askFirst, verbosity);

        // This Stream-Builder contains the list of FileNode's that are modified.
        Stream.Builder<FileNode> ret = Stream.builder();

        Appendable appendable = (outputSaver == null)

            // If no 'outputSaver' was provided, then just send text to Standard-Out
            ? System.out

            // This just allows for printing to **BOTH** System.out **AND** the 'outputSaver'
            : new BiAppendable
                (System.out, new AppendableSafe(outputSaver, AppendableSafe.USE_APPENDABLE_ERROR));

        // A very short "Consumer" that really just prints the file-name, nothing more.
        Consumer<String> fileNamePrinter = Helper.getFileNamePrinter
            (appendable, useUNIXColors, verbosity.level);


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // MAIN-LOOP: Iterate all the FileNode's
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        for (FileNode file : files)
        {
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Load the File, and then Find any / all Matches
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            String fileName     = file.getFullPathName();
            String fileAsStr    = null;

            // Print the file-name, if the verbosity level mandates that it be printed
            fileNamePrinter.accept(fileName);

            try
                { fileAsStr = FileRW.loadFileToString(fileName); }

            catch (IOException e)
            {
                if (ioeh != null)   ioeh.accept(file, e);
                else                throw e;

                // if ioeh ignores the exception rather than halting the program, then just continue
                // the loop on to the next match

                continue;
            }

            // Retrieve the starting String-index of each and every match in the file
            MatchResult[] matchResults = StringParse.getAllMatches(fileAsStr, regEx, true);

            // If there aren't any matches, then skip to the next file.
            if (matchResults.length == 0) continue;


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // For-Loop: Print the Matches to System.out
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            // "Printing Stream" saves PrintingRecMultiLine instances.
            Stream.Builder<PrintingRecMultiLine> PRMLB = Stream.builder();

            // Loop-Variable for retaining the previous PrintingRecMultiLine.  It has the File
            // Line-Number information for the previous match.  The Previous-Line Number info is
            // how Line-Number's are computed much more efficiently.

            PrintingRecMultiLine prevSaverRecord = null;            

            for (MatchResult mr : matchResults)             

                PRMLB.accept(
                    prevSaverRecord = new PrintingRecMultiLine(
                        fileAsStr,
                        mr.start(),                 // match Starting-Position
                        mr.end(),                   // match Ending-{osition
                        replaceFunction.apply(mr),

                        // NOTE: The "value" assigned to this reference is **NOT-UPDATED** until
                        //       after it has been passed to this method's parameter.

                        prevSaverRecord,
                        useUNIXColors
                    ));

            // All Printing-Records as an Array
            PrintingRecMultiLine[] recs = PRMLB.build().toArray(PrintingRecMultiLine[]::new);

            if (recs.length == 0) continue;

            // unless Verbosity.Silent was requested, print the matches.
            if (verbosity.level > 0)
                PrintingRecMultiLine.printAll(recs, appendable, useUNIXColors, verbosity);


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Query the User, Write the Replacement
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            if (askFirst) if (! Q.YN("Re-Write the Updated File to Disk?")) continue;

            StringBuilder           newFileText = new StringBuilder();
            PrintingRecMultiLine    prevPRML    = null;

            for (PrintingRecMultiLine prml : recs)
            {
                // Doing this on a separate line so it is readable, could insert into line below
                int prevEndIndex = (prevPRML == null) ? 0 : prevPRML.matchPosEnd;

                newFileText
                    .append(fileAsStr.substring(prevEndIndex, prml.matchPosStart))
                    .append((prevPRML = prml).replaceStr);
            }

            try
                { FileRW.writeFile(newFileText, fileName); }

            catch (IOException e)
            {
                if (ioeh != null)   ioeh.accept(file, e);
                else                throw e;

                // if ioeh ignores the exception rather than halting the program, then just continue
                // the loop on to the next match

                continue;
            }

            // In "Verbosity.Verbose" mode, tell the user how many changes were updated in the file
            if (verbosity.level == 3)
                appendable.append(I4 + "Updated " + recs.length + " Matches");

            // This is a file that was updated, so put it in the returned list of "updated files"
            ret.accept(file);
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Finished, so return the list of modified FileNode's
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        return ret.build().collect(Collectors.toList());
    }
}