package Torello.Java.Build;

import static Torello.Java.C.*;

import Torello.Java.StorageWriter;
import Torello.Java.EXCC;
import Torello.Java.FileNode;
import Torello.Java.FileRW;
import Torello.Java.RTC;
import Torello.Java.C;

import Torello.Java.Additional.ConstantPool;
import Torello.Java.Additional.ByteArrClassLoader;
import Torello.Java.Additional.Ret3;

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

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

// This class has a single method (with one, small, static helper method) that just iterates 
// through a list of BuildPackage instances.  It looks for the root package directory, and then
// checks if the My/Package/Directory/ has a sub-directory names 'test-files/'.  Whenever it
// encounters a 'My/Package/Directory/test-files/', it scans that diretory (and all of its 
// sub-directories) to identify any Java '.class'-Files.
// 
// Each Java '.class'-File is the checked to see whether it implements the interface
// 'Torello.Java.Build.TestingClass'.  If it does, then its 'runTests(StorageWriter)' method is
// invoked, and the results are saved into the Log-File Directory.
// 
// This class *REALLY* isn't Rocket-Science.  It sometimes looks (to me) kind of difficult because
// of things like "ByteArrclassLoader", and of course the profuse use of the 'FileNode' and
// 'Stream' classes.  I wrote the 'ByteArrClassLoader' to circumvent having the place all '.class'
// files inside of a Directory-Tree Structure that is required to mimic the Package-Name itself.
// Though writing the API for 'Torello.Java.Additional.ConstantPool' was quite a bit of work, it
// can be a real life-saver in sitatuions exactly like the need to write a 'ByteArrClassLoader'
// 
// If you just accept that loading Class-Files from a directory where the "Package-Name" and the
// Directory-Tree are completely and totally un-correlated and disjoing is *THE ONLY REASON* for
// needed the ByteArrClassLoader / getDeclaredConstructor / newInstance stuff, then maybe this
// class will look as simple as it really is!
// 
// It scans for all '.class' files which are in a 'package/test-files/' directory - INCLUDING ANY
// AND ALL SUB-DIRECTORIES - and then loads them into memory (using the 'ConstantPool' and the
// specialized Class-Loader).  Then, it runs the 'runTests' on any of those classes which the
// user has written and implement the 'TestingClass' interface!
// 
// That's the whole thing in a nutshell.
// 
// Oh, and one more thing (i forgot), the "ConstantPool" class isn't actually used inside this 
// class - it is buried inside the 'ByteArrClassLoader' itself!

class RunTests
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Run Method
    // ********************************************************************************************
    // ********************************************************************************************


    @SuppressWarnings({"unchecked", "rawtypes"})
    static void run(
            final ReadOnlyList<BuildPackage>    packagesIN,
            final String                        logDirName
        )
        throws IOException
    {
        final ByteArrClassLoader            bacl        = new ByteArrClassLoader();
        final StorageWriter                 log         = new StorageWriter();
        final ReadOnlyList<BuildPackage>    packages    = mustHaveTestFilesDir(packagesIN);

        final PkgTextBar textBar =
            new PkgTextBar(packages, "Testing Package", BGREEN_BKGND, BCYAN);

        log.sysOut = false;

        for (BuildPackage bp : packages)
        {
            final String logSubDirName =
                logDirName + bp.fullName + File.separator;

            final File logDir = new File(logSubDirName);

            if (! logDir.exists()) logDir.mkdirs();

            final ReadOnlyList<Class> testClasses = FileNode
                .createRoot(bp.pkgRootDirectory + "test-files" + File.separator)
                .loadTree(-1, FileNode.CLASS_FILES, null)
                .flattenJustFiles(RTC.FULLPATH_STREAM())
                .map((String fileName) -> (Class) bacl.readJavaClassNOIOE(fileName))
                .filter((Class c) -> TestingClass.class.isAssignableFrom(c))
                .collect(ReadOnlyArrayList.streamCollector());

            textBar.print(bp);

            for (final Class c : testClasses)
            {
                final String cName = c.getCanonicalName();
                System.out.println(BRED + "    Testing Class:  " + RESET + BGREEN + cName + RESET);

                final TestingClass tc;

                try
                    { tc = (TestingClass) c.getDeclaredConstructor().newInstance(); }

                catch (Exception | Error e)
                {
                    System.out.println(
                        EXCC.toString(e) + '\n' +
                        e.getMessage() + "\n\n" +
                        "For TestingClass:\n    " + BYELLOW + cName + RESET + '\n' +
                        "Unable to invoke the Zero-Argument Constructor for that Class.\n" +
                        "Did you remember to declare a public, Zero-Argument Constructor?\n"
                    );

                    System.exit(0); /* shhh compiler !! */ throw null;
                }
    

                final boolean   testResults     = tc.runTests(log);
                final String    logFileName     = logSubDirName + cName + ".txt";
                final String    htmlFileName    = logSubDirName + cName + ".html";
                final String    testOutput      = log.getString();
                final String    htmlOutput      = C.toHTML(testOutput, true, true, cName);

                log.erase();

                System.out.println("    Writing File:   " + BYELLOW + logFileName + RESET);
                FileRW.writeFile(testOutput, logFileName);

                System.out.println("    Writing File:   " + BYELLOW + htmlFileName + RESET);
                FileRW.writeFile(htmlOutput, htmlFileName);

                if (! testResults)
                {
                    System.out.println(
                        testOutput + '\n' +
                        BRED + "*** FAILED ***" + RESET
                    );

                    System.exit(-1);
                }
            }
        }

        System.out.println();
    }


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


    // All this does is filter out any packages which do not have a '../test-files/' subd-directory
    // The only reason this is necessary at all is somewhat because I have the capacity to get a 
    // little over-zealous with the "Read-Only" thing.  Otherewise, this would be several lines
    // shorter...

    private static ReadOnlyList<BuildPackage> mustHaveTestFilesDir 
        (final ReadOnlyList<BuildPackage> allPackages)
    {
        ROArrayListBuilder<BuildPackage> roalb = new ROArrayListBuilder<>();

        for (BuildPackage bp : allPackages)
        {
            final File testFilesDir =
                new File(bp.pkgRootDirectory + "test-files" + File.separator);

            if ((! testFilesDir.exists()) || (! testFilesDir.isDirectory()))
                continue;

            roalb.add(bp);
        }

        return roalb.build();
    }
}