package Torello.Java.Build;

import Torello.Java.*;

import Torello.Java.Additional.BiAppendable;
import Torello.Java.Additional.Counter;

import Torello.Java.ReadOnly.ReadOnlyList;
import Torello.Java.ReadOnly.ReadOnlyArrayList;
import Torello.Java.ReadOnly.ROArrayListBuilder;

import java.io.FilenameFilter;
import java.io.File;
import java.io.IOException;

import java.util.stream.Stream;
import java.util.function.Predicate;

import static Torello.Java.C.*;

/**
 * This is the first Build-Stage, and it runs the Java-Compiler - using {@code 'java'} and
 * {@link Shell Torello.Java.Shell}.  This class also relies heavily on the Java-HTML Tools
 * {@link FileNode} and {@link FileRW}.
 * 
 * <EMBED CLASS='external-html' DATA-FILE-ID=S01_JAVA_COMPILER>
 */
@Torello.JavaDoc.StaticFunctional
public class S01_JavaCompiler
{
    // Completely irrelevant, and the 'private' modifier keeps it off of JavaDoc
    private S01_JavaCompiler() { }


    // ********************************************************************************************
    // ********************************************************************************************
    // buildCommand Helper Method
    // ********************************************************************************************
    // ********************************************************************************************


    private static ReadOnlyList<String> buildCommand
        (Builder builder, ReadOnlyList<String> filesToCompile)
    { 
        final ROArrayListBuilder<String> roab = new ROArrayListBuilder<>();

        if (builder.JAVA_RELEASE_NUM_SWITCH > 0)
            roab.add("--release");
                roab.add("" + builder.JAVA_RELEASE_NUM_SWITCH);

        roab.add("-encoding");
            roab.add("UTF-8");

        roab.add("-processor");
            roab.add("Torello.JDUInternal.Annotations.JDUAnnotationProcessorDispatch");

        roab.add("-classpath");
            roab.add(builder.CLASS_PATH_STR);

        if (builder.USE_XLINT_SWITCH) roab.add("-Xlint:all,-processing");

        if (builder.USE_XDIAGS_SWITCH) roab.add("-Xdiags:verbose");

        if ((builder.extraSwitchesJAVAC != null) && (builder.extraSwitchesJAVAC.size() > 0))
            for (String switchStr : builder.extraSwitchesJAVAC)
                roab.add(switchStr);

        for (String fileName : filesToCompile) roab.add(fileName);

        return roab.build();
    };


    // ********************************************************************************************
    // ********************************************************************************************
    // Print the 'javac' Command
    // ********************************************************************************************
    // ********************************************************************************************


    static void printCommandText(
            Builder                 builder,
            ReadOnlyList<String>    javacCommand,
            Appendable              logAndScreen,
            Appendable              logOnly,
            ReadOnlyList<String>    filesToCompile
        )
        throws IOException
    {
        // 'javac' Command-Path
        logAndScreen.append(
            BCYAN + "Running Java Compiler: Command Switches\n" + RESET +
            BGREEN + "INVOKING: " + RESET +
            BYELLOW + builder.JAVAC_BIN + RESET + "\n\n"
        );

        // All of the Command-Line Arguments which *ARE NOT* '.java' files SHOULD BE PRINTED to
        // 'javac'.  If a few of the '.java' Files are also printed, it isn't that big of a deal...
        //
        // The "--release" switch may or may not have been used.

        final int NUM_TWO_ARGUMENT_JAVAC_ARGS =
            4 - ((builder.JAVA_RELEASE_NUM_SWITCH <= 0) ? 1 : 0);

        final int NUM_ONE_ARGUMENT_JAVAC_ARGS =
            (builder.USE_XLINT_SWITCH ? 1 : 0) + (builder.USE_XDIAGS_SWITCH ? 1 : 0);

        // First the two-argument command line arguments are printed
        for (int i=0; i < NUM_TWO_ARGUMENT_JAVAC_ARGS; i++) logAndScreen.append
            ("    " + javacCommand.get(2 * i) + "  " + javacCommand.get(2 * i + 1) + '\n');

        // Make sure to skip over the arguments that have already been pritned
        final int SPOS = 2 * NUM_TWO_ARGUMENT_JAVAC_ARGS;

        // Print the single-argument command-line arguments
        for (int i=SPOS; i < (SPOS + NUM_ONE_ARGUMENT_JAVAC_ARGS); i++)
            logAndScreen.append("    " + javacCommand.get(i) + '\n');

        // Java-HTML doens't use this yet (as of January 2024), but if "extra" / User-Added `javac`
        // Command-Line Arguments have been configured into the "Builder" instance, then (at this
        // point in the code), those switch-arguments will have already been added/inserted into
        // the Command.  Make sure to print them out, as below:

        if ((builder.extraSwitchesJAVAC != null) && (builder.extraSwitchesJAVAC.size() > 0))
            for (String switchStr : builder.extraSwitchesJAVAC)
                logAndScreen.append(switchStr + '\n');

        // The last thing to print is this stuff...
        /* Screen Only */ System.out.println(
            "\n    [Source-Files List Omitted, Total Number of Files to Compile: " +
            BRED + filesToCompile.size() + RESET + "]\n"
        );

        for (String fileName : filesToCompile) logOnly.append("    " + fileName + '\n');
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Compile
    // ********************************************************************************************
    // ********************************************************************************************


    private static final String FS = File.separator;

    public static void compile(Builder builder) throws IOException
    {
        // Initialize the logs, and get ready to start-up
        Printing.startStep(1);

        StringBuilder   logOnly         = new StringBuilder();
        Appendable      logAndScreen    = new BiAppendable(logOnly, System.out);

        logOnly.append("\nPackages Included in this Builder:\n\n");
        for (BuildPackage bp : builder.packageList) logOnly.append(bp.fullName + '\n');

        // List all Packages to be Compiled
        ReadOnlyList<BuildPackage> packagesToCompile = Packages.packagesToCompile(builder);

        logOnly.append("\nPackages Considered for Compilation:\n\n");
        for (BuildPackage bp : builder.packageList) logOnly.append(bp.fullName + '\n');

        // Convert the List of Packages to a list of files
        ReadOnlyList<String> filesToCompile = Files.filesToCompile
            (packagesToCompile, logAndScreen);

        // Build the javadoc Command, Print the Command-Line Arguments to Screen
        ReadOnlyList<String> javacCommand = buildCommand(builder, filesToCompile);

        // Print this to the log and to terminal
        printCommandText(builder, javacCommand, logAndScreen, logOnly, filesToCompile);

        // Execute 'javac'
        OSResponse osr = new Shell(logOnly)
            .COMMAND(builder.JAVAC_BIN, javacCommand.toArray(new String[0]));

        // If there were errors, print them out and exit
        //
        // NOTE: This absolutely sucks, but in Java-17, the "Error Output" isn't actually published
        //       to the OS Standard-Error!  It all appears to be going to Standard-Out.

        if (osr.errorOutput.length() > 0)
        {
            System.err.println
                (BRED + "\nTEXT PRINTED TO STANDARD ERROR:\n" + RESET + osr.errorOutput);

            Util.ERROR_EXIT("javac"); // Calls System.exit
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Move '../package-source/' CLASS-FILES to their parent/proper location
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        int max = 0;

        for (BuildPackage pkg : packagesToCompile)
            if (pkg.hasPackageSourceDir && (pkg.pkgRootDirectory.length() > max))
                max = pkg.pkgRootDirectory.length();

        // max += "package-source/".length();
        max += 15;

        boolean printed = false;

        for (final BuildPackage pkg : packagesToCompile) if (pkg.hasPackageSourceDir)
        {
            if (! printed)
            {
                logAndScreen.append(BCYAN + "\nRelocating Class Files:\n\n" + RESET);
                printed = true;
            }

            final String dir = pkg.pkgRootDirectory;

            int numClassFiles = movePackageSourceClassFiles(dir, logOnly);

            logAndScreen.append(
                "    Moved " + BRED + StringParse.zeroPad(numClassFiles) + RESET +
                " *.class File(s) From: " +
                BYELLOW + StringParse.rightSpacePad(dir + "package-source" + FS, max) + RESET +
                " To: " + BYELLOW + dir + RESET + '\n'
            );
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Write the log data to the log files
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // OLD CODE: IS_FULL_COMPILE = (builder.cli.userSpecifiedPackages == null)
        if (builder.cli.userSpecifiedPackages == null)
            builder.logs.write_S01_LOGS(logOnly.toString(), osr.standardOutput, osr.errorOutput);
    }

    private static int movePackageSourceClassFiles(final String dir, Appendable a)
    {
        Counter c = new Counter();

        FileNode
            .createRoot(dir + "package-source" + FS)
            .loadTree(-1, FileNode.CLASS_FILES, null)
            .flattenJustFiles(RTC.FULLPATH_VECTOR())
            .forEach((String srcFileName) ->
            {
                c.addOne();

                try
                {
                    FileRW.moveFile(srcFileName, dir, false);
                    a.append("Moved " + srcFileName + " to " + dir + '\n');
                }

                catch (IOException ioe)
                { 
                    System.err.println(
                        EXCC.toString(ioe) + '\n' +
                        "Fatal Error, Exiting Build\n"
                    );

                    System.exit(1);
                }
            });

        return c.get();
    }
}