package Torello.JDUInternal.Annotations;

import Torello.Java.Additional.EffectivelyFinal;
import Torello.Java.StringParse;

import java.io.File;
import java.util.List;
import java.net.URI;

import javax.annotation.processing.*;
import javax.lang.model.*;
import javax.lang.model.element.*;

import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;

public class CSSLinksProcessor
{
    // This is used by the Error-Message Printer
    private static final String CSSLINKSNAME = Torello.JavaDoc.CSSLinks.class.getSimpleName();

    // This implements the processing for the Annotation @JDHeaderBackgroundImg.
    // It does validity checks on the parameter input.

    private static final String FS = File.separator;

    private CSSLinksProcessor() { }

    static boolean process(
            Element                                 ciet, 
            AnnotationMirror                        am,
            Filer                                   filer,
            javax.annotation.processing.Messager    messager
        )
    {
        /*
        try
        {
            // This will have the Complete-Name of the Annotated CIET/Type
            //
            // NOTE: Currently, I have no idea how to tell which part is a "Package-Name", and
            //       which part is a "Container-Class"
            // Is Torello.Java.Additional.ReadJSON.XL a class that is inside 
            // sub-package ReadJSON or container-class ReadJSON
            //
            // This has to stop for now, this will be easier to work with once I have finished the
            // new Build classes

            String typeName = ciet.asType().toString();

            // THEORETICALLY, This should be a file inside the same directory as the .java file
            JavaFileObject sourceFile = filer.createSourceFile(typeName + "$Dummy");

            // THEREFORE, NO (AGAIN, THEORETICALLY), THIS HOLDS THE FILE-NAME NO MATTER WHERE THIS
            // FILE IS LOCATED INSIDE THE CLASS-PATH.
            String filePath = sourceFile.toUri().getPath();

            // NO IDEA WHAT THIS IS DOING
            sourceFile.delete();

            messager.printMessage(
                Diagnostic.Kind.NOTE,    
                JDUAnnotationProcessorDispatch.LOCATION(ciet, CSSLINKSNAME) +
                "    Path: " + filePath
            );
        }

        catch (Exception e)
        {

        }
        */

        EffectivelyFinal<Boolean> errors = new EffectivelyFinal<>(false);

        am.getElementValues().forEach((ExecutableElement ee, AnnotationValue av) ->
        {
            // This is the "thing-y" inside the Annotation.  It is called a "Member" by the
            // Annotation-Processor.  It is called a "Required-Element" or "Optional-Element" in a
            // Java-Doc Web-Page.  Understanding the 'terminology' in Annotations and Annotation
            // Processor's is half of the work in using it.  In the JD Upgrader Package (this 
            // Package), these are "Entity" - Entity.ANNOTATION_ELEM
            //
            // In **THIS** Annotation (CSSLinks), there is only one Element / Member / Entity,
            // and its name is "FileName"

            String memberName = ee.toString();

            // The value assigned to this Member.  In the @CSSLinks, the "Member" or "Element"
            // (whichever of the many terms is more appealing) that's defined - is listed (inside
            // the Annotation-Definition '.java' file) as a **String-Array**.  Here, in the
            // Annotation-Processor, its value will be returned as an instances of:
            //
            // com.sun...List - a class which implements the "java.util.List" class.
            // But is not actually included by the JDK!

            Object val = av.getValue();


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Java Assertion.  This Really **SHOULD** Hold, but just in case....
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            if (! java.util.List.class.isAssignableFrom(val.getClass()))

                // Don't use the Messager, this is a "Java-Error" (or else I'm just not quite
                // understanding Annotations-Processors yet)

                throw new InternalError(
                    memberName + " Annotation-Element-Value Type is not a List, " +
                    '[' + val.getClass().getName() + ']'
                );

            List<?> list = (List) val;


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Dispatch to the handler for "FileNames"
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

            switch (memberName)
            {
                case "FileNames()" :
                    errors.f |= checkCSSFile(ciet, list, messager);  break;

                default: 

                    // If the 'javac' (Java-Compiler) Annotation-Processing Whole-Mechanism Thingy
                    // is working, the only two Annotation-Elements that could possibly be sent to
                    // this loop are the two listed above...  These two "Elements" or "Members"
                    // "Entites" (I'll say this again) are the ones defined inside the '.java'
                    // File having name "JDHeaderBackgroundImg.java".  The Java-Doc Page for them
                    // explains (very well) the two Array-Parameter Elements
                    //
                    // This should be UNREACHABLE-CODE.  The Java-Compiler, itself, should do the
                    // complaining that the user has provided an Annotation-Member that is not
                    // listed inside the definition for that Annotation.
                    //
                    // Don't use the Messager, this simply cannot happen unless I'm just not 
                    // understanding all of the nuances of this stuff-ola.
            
                    throw new InternalError(
                        "\tThere was an annotation parameter whose name wasn't recognized: " +
                        ee.toString() + "\n" +
                        "\tThe only parameter that may be passed to @CSSFiles is 'FileNames\n'"
                    );
            }
        });

        return errors.f;
    }

    private static final String curDir()
    { return "THIS PART ISN'T WORKING AT THE MOMENT"; }

    // Check each of the User-Provided "<DIV> CLASS's".  There is a Predicate-Checker
    // inside the NodeSearch Package for CSS-CLASS Strings

    private static boolean checkCSSFile
        (Element ciet, List<?> list, javax.annotation.processing.Messager messager)
    {
        String fileName;
        boolean errors = false;

        for (Object fileNameObj : list)

            // In Java 11, this returns a quoted-string, and in Java 17, there were no quotes
            if ((fileName = StringParse.ifQuotesStripQuotes(fileNameObj.toString())).length() > 0)
            {
                String fullPathName = null;
                boolean relativeOrAbsolute;
                File file;


                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
                // Identify the actual Full-Path Name of the File
                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
                //
                // Get the Full-Path Name for this File - regardless of whether the File-String
                // provided by the user is a relative File-Name, or an absolute File-Name

                if (fileName.contains(File.separator))
                {
                    relativeOrAbsolute  = false;
                    fullPathName        = fileName;
                }

                else
                {
                    relativeOrAbsolute = true;

                    fullPathName = curDir() + FS + "upgrade-files" + FS + "stylesheets" + FS + 
                        fileName;
                }

                // In it's current incarnation, there is simply no way to get the relative
                // directory where a Source-File is located.  In all actuallity, it isn't going to
                // matter much anyway, since finding the /upgrade-files/stylesheets just isn't
                // going to work at the present moment.

                if (relativeOrAbsolute) continue;


                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
                // Check that the file actually exists on the File-System, and if not, flag error
                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

                try
                {
                    file = new File(fullPathName);

                    if (! file.exists())
                    {
                        messager.printMessage(
                            Diagnostic.Kind.ERROR,    
                            JDUAnnotationProcessorDispatch.LOCATION(ciet, CSSLINKSNAME) +
                            "    [" + fileName + "]\n    File not found" +
                            (relativeOrAbsolute
                                ? " in the upgrade-files/stylesheets/ directory"
                                : ""
                            )
                        );

                        errors = true;
                        continue;
                    }
                }

                catch (Exception e)
                {
                    messager.printMessage(
                        Diagnostic.Kind.ERROR,
                        JDUAnnotationProcessorDispatch.LOCATION(ciet, CSSLINKSNAME) +
                        "Exception thrown attempting to open / locate File:\n[" + fileName + "]\n" +
                        "    e.getClass():   " + e.getClass().getName() + 'n' +
                        "    e.getMessage(): " + e.getMessage() + '\n'
                    );

                    errors = true;
                    continue;
                }


                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
                // Make sure that the specified File is not a Directory, otherwise Flag and Error
                // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

                try
                {
                    if (file.isDirectory())
                    {
                        messager.printMessage(
                            Diagnostic.Kind.ERROR,
                            JDUAnnotationProcessorDispatch.LOCATION(ciet, CSSLINKSNAME) +
                            "[" + fileName + "] seems to specify a Directory, rather than a File."
                        );

                        errors = true;
                        continue;
                    }
                }

                catch (Exception e)
                {
                    messager.printMessage(
                        Diagnostic.Kind.ERROR,
                        JDUAnnotationProcessorDispatch.LOCATION(ciet, CSSLINKSNAME) +
                        "Exception thrown attempting to open / locate File:\n[" + fileName + "]\n" +
                        "    e.getClass():   " + e.getClass().getName() + 'n' +
                        "    e.getMessage(): " + e.getMessage() + '\n'
                    );

                    errors = true;
                    continue;
                }
            }

        return errors;
    }

}