package Torello.Java;

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

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

import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.Collectors;
import java.io.IOException;

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

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

        // This value is used repeatedly in this loop, so it is better left as a constant
        final int MATCH_STR_LEN = matchStr.length();

        // 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
            int[] posArr = StrIndexOf.all(fileAsStr, matchStr);

            if (posArr.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 (int i=0; i < posArr.length; i++)
            {
                // Loop-Variable that represents the current match, indexing the 'posArr' Array
                int pos = pos = posArr[i];
    
                // Overlapping matches need to be skipped
                if ((i > 0) && (pos < (posArr[i-1] + MATCH_STR_LEN))) continue;

                else PRMLB.accept(

                    prevSaverRecord = new PrintingRecMultiLine(
                        fileAsStr,
                        pos,                    // match Starting-Position
                        pos + MATCH_STR_LEN,    // match Ending-{osition
                        replaceStr,

                        // 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;

            // Remember, this single line of code does the actual replacement!
            String newFileAsStr = fileAsStr.replace(matchStr, replaceStr);

            try
                { FileRW.writeFile(newFileAsStr, 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());
    }
}