package Torello.JavaDoc;


// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// Standard-Java Imports
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

import java.util.concurrent.locks.*;

import java.io.IOException;
import java.util.Optional;
import java.util.List;
import java.util.function.Consumer;


// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// Java-HTML Imports
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

import Torello.Java.*;

import static Torello.Java.C.*;
import static Torello.JavaDoc.PF.*;

import Torello.Java.Additional.Ret2;
import Torello.Java.Additional.Ret3;

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


// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// The new Source-Code Parser: com.sun.source.*
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

import com.sun.source.tree.ClassTree;
import com.sun.source.tree.TypeParameterTree;
import com.sun.source.tree.Tree;


/**
 * <B CLASS=JDDescLabel>Reflection Class:</B>
 * 
 * <BR />Holds all information extracted from <CODE><B>'&#46;java'</CODE></B> Source-Files
 * regarding Nested-Types (Inner-Classes).
 * 
 * <EMBED CLASS='external-html' DATA-FILE-ID=JPB_GET_INST_2>
 * <EMBED CLASS='external-html' DATA-FILE-ID=JPB_NESTED>
 */
public class NestedType extends Declaration implements Cloneable
{
    /** <EMBED CLASS='external-html' DATA-FILE-ID=SVUID> */
    protected static final long serialVersionUID = 1;

    @Override
    String codeHiLiteString() { return null; }


    // ********************************************************************************************
    // ********************************************************************************************
    // Public Fields
    // ********************************************************************************************
    // ********************************************************************************************


    /** Identifies whether this is a nested/inner Class, Interface, Enum, Annotation etc... */
    public final CIET ciet;

    /**
     * The name of the package in which the enclosing-class of this nested-type is defined.  This
     * field will be null if the package was not found, or left blank as the 'default class'.
     */
    public final String packageName;

    /**
     * The {@code name}-field ({@link Declaration#name}) of this class uses the lone
     * Java-Identifier (Just One Word) which identifies this {@code NestedClass} within the scope
     * of the enclosing class.  However, {@code nameWithContainer} is a {@code String} that also
     * includes any / all enclosing-class names, each followed-by a {@code '.'}
     * 
     * <BR /><BR /><B STYLE='color: red;'>EXAMPLE:</B> For Java {@code java.util.Map.Entry<K, V>},
     * the {@code nameWithContainer} would be {@code "Map.Entry"}.
     * 
     * <BR /><BR />Generic Type-Parameter information is <B><I>not</I></B> included in this 
     * {@code String}, and neither is the Package-Name.
     */
    public final String nameWithContainer;

    /**
     * This field is identical to {@link #nameWithContainer}, but also has the Package-Name
     * prepended to it, if the Package-Name was present in the enclosing class' {@code '.java'}
     * file.
     * 
     * <BR /><BR /><B STYLE='color: red;'>EXAMPLE:</B> For Java {@code java.util.Map.Entry<K, V>},
     * the {@code fullyQualifiedName} would be {@code "java.util.Map.Entry"}.
     */
    public final String fullyQualifiedName;

    /** The number of fields that are defined in this inner-type */
    public final int numFields;

    /** The number of methods defined in this inner-type */
    public final int numMethods;

    /** <EMBED CLASS='external-html' DATA-FILE-ID=NT_GTPARAMS> */
    public final ReadOnlyList<String> genericTypeParameters;

    /**
     * <EMBED CLASS='external-html' DATA-FILE-ID=NT_IMPL_TYPES>
     * <EMBED CLASS='external-html' DATA-FILE-ID=JPB_JOW_TITLE>
     */
    public final ReadOnlyList<String> implementedTypesJOW;

    /** <EMBED CLASS='external-html' DATA-FILE-ID=NT_EXTEND_TYPES> */
    public final ReadOnlyList<String> extendedTypesJOW;


    // ********************************************************************************************
    // ********************************************************************************************
    // Native Parser Library Hook
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * <EMBED CLASS='external-html' DATA-FILE-ID=SSTB_HOOK_FIELD>
     * 
     * If a user decides to make use of the native Oracle {@code ClassTree} instance that was
     * used to build this {@code NestedType} instance, it may be retrieved from this
     * {@code transient} field.
     */
    public final transient ClassTree classTree;


    // ********************************************************************************************
    // ********************************************************************************************
    // Constructor - com.sun.source.tree 
    // ********************************************************************************************
    // ********************************************************************************************


    // Public but internal-use-only constructor for class NestedType
    public NestedType(final ClassTree ct, final TreeUtils util)
    {
        super(
            null,                           // ReflAnnotationData instance (not needed NestedType)
            util,                           // TreeUtils
            ct,                             // com.sun.source.Tree.ClassTree instance
            ct.getModifiers(),              // Annotations **AND** public, static, final
            ct.getSimpleName().toString(),  // Name of the class    - NEED TO DEBUG THIS !!!
            Entity.INNER_CLASS,
            null                            // BODY SHOULDN'T BE NULL, BUT IT IS FOR NOW!!!
        );


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Generic Type Parametes
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // List<? extends TypeParameterTree> genericTypeParams = ct.getTypeParameters();
        @SuppressWarnings("unchecked")
        List<TypeParameterTree> genericTypeParams =
            (List<TypeParameterTree>) ct.getTypeParameters();

        if ((genericTypeParams == null) || (genericTypeParams.size() > 0))
            this.genericTypeParameters = EMPTY_READONLY_LIST;

        else this.genericTypeParameters = new ReadOnlyArrayList<String>(
            genericTypeParams,
            (TypeParameterTree tpt) -> tpt.toString().trim(),
            genericTypeParams.size()
        );


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Implements Clause
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // List<? extends Tree> implementedTypes = ct.getImplementsClause();
        @SuppressWarnings("unchecked")
        List<Tree> implementedTypes = (List<Tree>) ct.getImplementsClause();

        if ((implementedTypes == null) || (implementedTypes.size() == 0))
            this.implementedTypesJOW = EMPTY_READONLY_LIST;

        else this.implementedTypesJOW = new ReadOnlyArrayList<String>(
            implementedTypes,
            (Tree t) -> StrSource.typeToJavaIdentifier(t.toString().trim()).trim(),
            implementedTypes.size()
        );


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Extends Clause
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // this.extendedTypesJOW = NTHelper.getExtendedTypes(ct);
        Tree t = ct.getExtendsClause();

        this.extendedTypesJOW = (t == null)
            ? EMPTY_READONLY_LIST
            : ReadOnlyList.of(t.toString());


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Other Stuff
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        // Reference Hook: This was built using the com.sun.source.tree.ClassTree class, so
        // there simply isn't a com.github.javaparser.ast.body.TypeDeclaration (so it is
        // set to null)

        this.classTree = ct;

        // This is the kind of this inner-class / nested-type.  This CIET is computed using the
        // internal-helper method because it is just a big switch-statement.  I suspect it is going
        // to be reused elsewhere, but I am not 100% on that yet.

        // this.ciet = NTHelper.getCIET(ct);
        switch (ct.getKind())
        {
            case CLASS:             this.ciet = CIET.CLASS;         break;
            case INTERFACE:         this.ciet = CIET.INTERFACE;     break;
            case ENUM:              this.ciet = CIET.ENUM;          break;
            case ANNOTATION_TYPE:   this.ciet =  CIET.ANNOTATION;   break;

            default: throw new UnreachableError();
        }

        /*
        if (this.ciet == null)
            Messager.assertFailJavaParser("Unknown Type Declaration: ", this.signature);
        */

        // This Helper Computes all three of these fields.
        Ret3<String, String, String> names = NTHelper.getInnerTypeNames(ct, util);

        // return new Ret3<>(packageName, nameWithContainer, fullyQualifiedName);
        this.packageName        = names.a;
        this.nameWithContainer  = names.b;
        this.fullyQualifiedName = names.c;

        // This Helper counts the number of methods and fields in a TypeDeclaration
        Ret2<Integer, Integer> counts = NTHelper.countMethodsFields(ct, this.ciet);

        // return new Ret<>(numMethods, numFields);
        this.numMethods = counts.a;
        this.numFields  = counts.b;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // toString()
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Generates a {@code String} of this {@code nested-type}, with most information included.
     * @return A printable {@code String} of this {@code nested-type}.
     * @see PF
     * @see #toString(int)
     */
    public String toString()
    {
        return
            "Name:            [" + name + "]\n" +
            "With Container:  [" + nameWithContainer + "]\n" +
            "Kind:            [" + ciet.toString() + "]\n" +
            "Signature:       [" +
                StrPrint.abbrevEndRDSF(signature, MAX_STR_LEN, true) + "]\n" +

            // "Type Parameters:".length() ==>  16  (17=16+1)
            printedTypeParameters(17) +

            "Modifiers:       [" +
                StrCSV.toCSV(modifiers, true, true, null) + "]\n" +

                // This will **NEVER** be null - unless 'this' instance was built from an HTML File,
                // rather than a source-code file.  Instances like that are only used temporarily, and
                // are garbage collected instantly.  Do this check anyway (just in case).
    
            "Location:        " + ((this.location == null)
                    ? "null" 
                    : ('[' + this.location.quickSummary() + ']'));
    }

    /**
     * <EMBED CLASS='external-html' DATA-FILE-ID=TO_STR_PF>
     * @param flags These are defined in the {@link PF Print-Flags} class
     * @return A printable {@code String} of this {@code NestedType}.
     * @see #toString()
     * @see PF
     */
    public String toString(int flags)
    {
        boolean color = (flags & UNIX_COLORS) > 0;
        String nameTitle = "Nested " + ciet.toString();

        // 7 ==> " Name: ".length()
        int LEN = nameTitle.length() + 7;

        return 
            printedName(nameTitle, LEN, color) +
            StringParse.rightSpacePad("Fully Qualified:", LEN) + '[' + fullyQualifiedName + "]\n" +
            StringParse.rightSpacePad("With Container:", LEN) + '[' + nameWithContainer + "]\n" +
            printedSignature(LEN, color) +
            printedTypeParameters(LEN) +
            printedModifiers(LEN) +
            printedExtendsImplements(LEN) +
            printedMethodField(LEN, color) + 
            printedLocation(LEN, color, (flags & BRIEF_LOCATION) > 0) +

            // The previous method does not add a '\n' end to the end of the returned string
            // This is optional, it adds a '\n' AT THE BEGINNING if it is included

            printedComments(LEN, color, (flags & JAVADOC_COMMENTS) > 0);
    }

    private String printedMethodField(int numSpaces, boolean color)
    {
        return
            StringParse.rightSpacePad("Num Methods:", numSpaces) +
                '[' + (color ? BGREEN : "") + numMethods + (color ? RESET : "") + "]\n" +
            StringParse.rightSpacePad("Num Fields:", numSpaces) +
                '[' + (color ? BGREEN : "") + numFields + (color ? RESET : "") + "]\n";
    }

    private String printedExtendsImplements(int LEN)
    {
        return
            (((this.extendedTypesJOW != null) && (this.extendedTypesJOW.size() > 0))
                ? (StringParse.rightSpacePad("Extends:", LEN) + '[' +
                    StrCSV.toCSV(extendedTypesJOW, true, false, null) + "]\n")
                : "") +
            (((this.implementedTypesJOW != null) && (this.implementedTypesJOW.size() > 0))
                ? (StringParse.rightSpacePad("Implements:", LEN) + '[' +
                    StrCSV.toCSV(implementedTypesJOW, true, false, null) + "]\n")
                : "");
    }

    private String printedTypeParameters(int numSpaces)
    {
        if ((this.genericTypeParameters == null) || (this.genericTypeParameters.size() == 0))
            return "";

        return
            StringParse.rightSpacePad("Type-Parameters:", numSpaces) +
            '[' + StrCSV.toCSV(genericTypeParameters, true, true, MAX_STR_LEN) + "]\n";
    }


    // *************************************************************************************
    // *************************************************************************************
    // Clone, CompareTo & Equals Stuff
    // *************************************************************************************
    // *************************************************************************************


    /**
     * Java's {@code interface Comparable<T>} requirements.  This does a very simple comparison
     * using the two nested-types's {@code 'name'} field.
     * 
     * @param nt Any other {@code Nested-Type} to be compared to {@code 'this'}
     * 
     * @return An integer that fulfills Java's
     * {@code interface Comparable<NestedType>, public boolean compareTo(NestedType nt)} method
     * requirements.
     */
    public int compareTo(NestedType nt)
    { return (this == nt) ? 0 : this.name.compareTo(nt.name); }

    /**
     * This <I>should be called an "atypical version" of </I> the usual {@code equals(Object
     * other)} method.  This version of equals merely compares the name of the field defined.  The
     * presumption here is that the definition of a 'field' only has meaning - <I>at all</I> -
     * inside the context of a {@code class, interface, } or {@code enumerated-type} where that
     * field is defined.  Since inside any {@code '.java'} source-code file, there may only be one
     * field with a given name, this method shall return {@code TRUE} whenever the field being
     * compared also has the same name.
     * 
     * @param other This may be any other field.  It is <I><B>strongly suggested</B></I> that
     * {@code 'other'} be a field defined in the same {@code '.java'} source-code file as
     * {@code 'this'} field.
     * 
     * @return This method returns {@code TRUE} when {@code 'this'} instance of {@code Field} has
     * the same {@code 'name'} as the name-field of input-parameter {@code 'other'}
     */
    public boolean equals(NestedType other)
    { return this.name.equals(other.name); }
}