package Torello.Java.Build;

import java.io.File;
import java.io.IOException;
import java.util.List;

import Torello.Java.StringParse;
import Torello.Java.FileNode;
import Torello.Java.RTC;
import Torello.Java.EXCC;
import Torello.Java.FileRW;

/**
 * Can be used by Classes the need to build Data-File(s) for the {@code 'data-files/'}
 * directory, or convert those Data-Files to Text for viewing and inspection.
 */
public abstract class DFBuilder
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Instance Abstract Methods
    // ********************************************************************************************
    // ********************************************************************************************


    /** Requests a list of Data-File Names that are constructed by this instance. */
    public abstract Iterable<String> dataFileNames();

    /**
     * Requests that this Data-File Builder run and generate all Data-Files that it can build.
     * 
     * @param dataFileRootDir The target directory location for writing the file(s)
     * 
     * <BR /><BR /><B STYLE='color: red;'>Relative Directory Path:</B> This parameter is necessary
     * becase an instance of {@code DFBuilder} might be invoked from just about anywhere.  Thus, it
     * is imperative that the actual root {@code '../data-files/'} directory be passed to this 
     * method, to avoid writing the Data-Files into the wrong place.
     * 
     * <BR /><BR /><I>This {@code String}-Parameter {@code 'dataFileRootDir'} must be a
     * {@code String} that is a Relative-Path, from the CWD / Current-Working-Directory from whence
     * the current Java-Instance was invoked,  to the {@code '../data-files/'} directory where the
     * Data-Files are to be written</I>.
     * 
     * @throws IOException If there are any problems while writing the data-file.
     */
    public abstract void buildAll(String dataFileRootDir) throws IOException;

    /**
     * Requests that this Data-File Builder generate all Data-Files as Text-Files, so that
     * they may be viewed and inspected.
     * 
     * <EMBED CLASS=external-html DATA-FILE-ID=DEF_IMPL_UOEX>
     * 
     * @param targetDir <EMBED CLASS=external-html DATA-FILE-ID=DFB_TARGET_DIR>
     * @throws IOException <EMBED CLASS=external-html DATA-FILE-ID=IOEX>
     * @throws UnsupportedOperationException    <EMBED CLASS=external-html DATA-FILE-ID=UOEX>
     *
     */
    public void buildAllToText(String targetDir) throws IOException
    { throw new UnsupportedOperationException(); }

    /**
     * Requests that this Data-File Builder convert the existing Data-Files themselves into 
     * Text-Files, so that they may be viewed and inspected.
     * 
     * <EMBED CLASS=external-html DATA-FILE-ID=DEF_IMPL_UOEX>
     * 
     * @param targetDir <EMBED CLASS=external-html DATA-FILE-ID=DFB_TARGET_DIR>
     * @throws IOException <EMBED CLASS=external-html DATA-FILE-ID=IOEX>
     * @throws UnsupportedOperationException    <EMBED CLASS=external-html DATA-FILE-ID=UOEX>
     */

    public void deCompileAllToText(String targetDir) throws IOException
    { throw new UnsupportedOperationException(); }


    // ********************************************************************************************
    // ********************************************************************************************
    // Utility for building all Data-Files in all Packages that have a "../data-files/" directory
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Runs / Executes the method {@link buildAll(String)} on all Class-File(s) found insdie the
     * {@code 'data-files/'} directory for a given package.  If the package provided to parameter
     * {@code 'pkg'} does not have a {@code 'data-files/'} directory, then this method exists 
     * gracefully
     * 
     * @param pkg Any one of the Configured Project Packages.  The relevant fields used by this 
     * method are {@link BuildPackage#classPathLocation} and {@link BuildPackage#pkgRootDirectory}.
     * These two fields are concatenated, and that directory is searched for any / all class files
     * that implement this {@code DFBuilder} interface.
     * 
     * @return The number of class-files implementing the {@code DFBuilder} interface.
     */
    @SuppressWarnings("unchecked")
    public static int buildAll(final BuildPackage pkg) throws IOException
    {
        String  dirName = pkg.classPathLocation + pkg.pkgRootDirectory;
        File    f       = new File(dirName);

        if ((! f.exists()) || (! f.isDirectory())) return 0;

        String[] fNameArr = FileNode
            .createRoot(dirName)
            .loadTree(-1, (File dir, String fName) -> fName.endsWith(".class"), null)
            .flattenJustFiles(RTC.FULLPATH_ARRAY());

        int counter = 0;

        TOP:
        for (String classFileName : fNameArr)
        {
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // FileRW.readClass
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            // Pulls the Class-Name out of the Class-FileName:
            //      1) Removes the ".class" extension
            //      2) Removes the leading "data-files/..." directory string stuff from File-Name

            final String className = StringParse.beforeExtension
                (StringParse.fromLastFileSeparatorPos(classFileName));

            // Runs the FileRW.readClass method & catches the exceptions it throws.
            final Class<?> c;

            try
                { c = FileRW.readClass(classFileName, className); }

            catch (Exception e)
                { continue; }


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Make sure class is a DFBuilder instance
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            Class<?> temp = c;

            while (true)

                if (temp == null)                   continue TOP;
                else if (temp == Object.class)      continue TOP;
                else if (temp == DFBuilder.class)   break;
                else                                temp = temp.getSuperclass();


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Instantiate and call instance buildAll()
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            final DFBuilder dfb;

            try
                { dfb = ((Class<DFBuilder>) c).getDeclaredConstructor().newInstance(); }

            catch (Exception e)
            {
                System.out.println(
                    "Unable to instantiate DFBuilder.\n" +
                    "Do you have a Zero-Argument Public Constructor?\n" +
                    EXCC.toString(e)
                );

                System.exit(1);
                return -1; // Shut-Up Compiler
            }
            
            counter++;
            dfb.buildAll(dirName);
        }

        return counter;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Command-Line Interface Helper Method (public-static-void-main, to be used by sub-classes)
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * This method is intended to be used by classes that inherit this abstract class.  Classes
     * that inherit {@code DFBuilder} may add a method into their implementation, as in the hilited
     * source-code below.  This provides a standard Java {@code 'Main'}-Method that may be invoked
     * as a <B STYLE='color: red;'>CLI: Command Line Interface</B>.
     * 
     * <DIV CLASS=EXAMPLE>{@code
     * // The class extending DFBuilder can use this method so that it can be invoked at the
     * // command line.  Passing '1' means that only the 'buildAll' was written by the extending
     * // Type.
     * 
     * public static void main(String[] argv) { new YourDataFileBuilder().cli(1, argv); }
     * }</DIV>
     * 
     * @param menuOptions The value passed to this parameter must be one of the values excplicitly
     * named in this set: <B>{@code 1, 2, 3, 4, 6}</B>.  Any value other than these 5 numbers will
     * force this method to throw an {@code IllegalArgumentException}.
     * 
     * <BR /><BR />This meaning of these is clearly explained, in the table below:
     * 
     * <BR /><BR /><TABLE CLASS=JDBriefTable>
     * <TR><TH>{@code 'menuOptions'}</TH><TH>Meaning</TH></TR>
     * 
     * <TR> <TD>'1'</TD>
     *      <TD>The only method implemented is the {@link #buildAll(String) buildAll} method.  The
     *          others, on invokation, will throw the {@code UnsupportedOperationException}
     *          </TD></TR>
     * 
     * <TR> <TD>'3'</TD>
     *      <TD>{@code 3 => 1 & 2}<BR />
     *          Methods {@link #buildAll(String) buildAll} and {@link #buildAllToText(String)
     *          buildAllToText} are implemented, and may be invoked.
     *
     *          <BR /><BR >Attempting to call {@link #deCompileAllToText(String)
     *          deCompileAllToText} would cause an {@code UnsupportedOperationException} to throw.
     *          </TD></TR>
     * 
     * <TR> <TD>'4'</TD>
     *      <TD>{@code 4 => 1 & 3}<BR />
     *          Methods {@link #buildAll(String) buildAll} and {@link #deCompileAllToText(String)
     *          deCompileAllToText} are implemented, and may be invoked.
     *
     *          <BR /><BR >Attempting to call {@link #buildAllToText(String) buildAllToText} would 
     *          cause an {@code UnsupportedOperationException} to throw.
     *          </TD></TR>
     *
     * <TR> <TD>'6'</TD>
     *      <TD>{@code 6 ==> 1, 2 & 3}<BR />
     *          All three methods exported by this class have been implemented, and may be invoked
     *          without worry that the {@code UnsupportedOperationException} will throw.
     *          </TD></TR>
     * 
     * </TABLE>
     * 
     * @param argv The Command-Line Parameter {@code String[]}-Array.  This should just be the 
     * {@code argv}-Array that was sent to the actual Java {@code 'Main'}-Method that his invoking
     * this helper.
     * 
     * @return {@code TRUE} if and only if the invoked builder method terminated successfully.
     */
    public final boolean cli(int menuOptions, String[] argv)
    {
        if ((menuOptions < 1) || (menuOptions > 6) || (menuOptions == 2) || (menuOptions == 5))

            throw new IllegalArgumentException(
                "Parameter 'menuOptions' must be a value in this set: [1, 3, 4, 6]\n" + 
                "These are the only valid values to pass here, but [" + menuOptions + "] was " +
                    "provided, instead."
            );

        if ((argv.length != 1) && (argv.length != 2))
        {
            printManPage(menuOptions);
            return false;
        }

        final boolean   twoOK   = (menuOptions == 3) || (menuOptions == 6);
        final boolean   threeOK = (menuOptions == 4) || (menuOptions == 6);
        final String    dirName = (argv.length == 2) ? argv[1] : "";

        try
        {
            switch (argv[0])
            {
                case "1":
                    buildAll(dirName);
                    break;

                case "2":
                    if (twoOK)  buildAllToText(dirName);
                    else        printManPage(menuOptions);
                    break;

                case "3":
                    if (threeOK)    deCompileAllToText(dirName);
                    else            printManPage(menuOptions);
                    break;
            }
        }

        catch (Exception e)
        {
            System.out.println(
                "This DFBuilder Instance has thrown an Exception while writing a File:\n" +
                EXCC.toString(e) + '\n'
            );

            return false;
        }

        return true;
    }

    private static void printManPage(int menuChoice)
    {
        System.out.println(MAN_PAGE_LINES[0]);

        if ((menuChoice == 3) || (menuChoice == 6))
            System.out.println(MAN_PAGE_LINES[1]);

        if ((menuChoice == 4) || (menuChoice == 6))
            System.out.println(MAN_PAGE_LINES[2]);

        System.out.println("\n\tOptional Directory-Name may also be passed\n");
    }

    private static final String[] MAN_PAGE_LINES = 
    {
        "Command Line Argument:\n\n" +
        "\t1: Build All Data-Files Produced by this class",

        "\t2: Generate Data-Files as Text-Files, for review and inspection",

        "\t3: Dump Data-File(s) Produced by this Class to Text-Filess"
    };
}