package Torello.JSON;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.Objects;

import javax.json.JsonObject;

/** 
 * Used for Read Json method that attempt to build a Java POJO, but fail due to an inability to
 * extract a valid constructor from the object.  When using a class' constructor as a builder,
 * the required constructor must be one which accepts only one parameter.  That parameter must be 
 * of type {@link javax.json.JsonObject}.
 */
public class InvalidClassException extends RuntimeException
{
    /** <EMBED CLASS='external-html' DATA-FILE-ID=SVUIDEX>  */
    public static final long serialVersionUID = 1;

    /** Constructs a {@code InvalidClassException} with no detail message. */
    public InvalidClassException()
    { super(); }

    /**
     * Constructs a {@code InvalidClassException} with the specified detail message.
     * @param message the detail message.
     */
    public InvalidClassException(String message)
    { super(message); }

    /**
     * Constructs a new {@code InvalidClassException} with the specified detail message
     * and cause.
     * 
     * <BR /><BR /><DIV CLASS=JDHint>
     * <B STYLE='color:red;'>Note:</B> The detail message associated with cause is not
     * automatically incorporated into this exception's detail message.
     * </DIV>
     * 
     * @param message The detail message (which is saved for later retrieval by the
     * {@code Throwable.getMessage()} method).
     * 
     * @param cause the cause (which is saved for later retrieval by the
     * {@code Throwable.getCause()} method).  (A null value is permitted, and indicates that the
     * cause is nonexistent or unknown.)
     */
    public InvalidClassException(String message, Throwable cause)
    { super(message, cause); }

    /**
     * Constructs a new {@code InvalidClassException} with the specified cause and a detail
     * message of {@code (cause==null ? null : cause.toString())} (which typically contains the
     * class and detail message of cause).  This constructor is useful for exceptions that are
     * little more than wrappers for other throwables.
     * 
     * @param cause The cause (which is saved for later retrieval by the
     * {@code Throwable.getCause()} method).  (A null value is permitted, and indicates that the
     * cause is nonexistent or unknown.)
     */
    public InvalidClassException(Throwable cause)
    { super(cause); }

    /**
     * Extracts a valid {@code java.lang.reflect.Constructor} instance for a constructor that
     * accepts one arguement of type {@code JsonObject}.
     *
     * <BR /><BR />Throws if such an instance of {@code Constructor} cannot be found.
     *
     * @throws NullPointerException throws if parameter {@code 'c'} is null
     * 
     * @throws InvalidClassException throws if any errors occur when extracting the instance of
     * {@code java.lang.reflect.Constructor}.  This method excepts &amp; attempts to extract a one
     * argument constructor whose sole arguement is of type {@link JsonObject}.
     */
    public static <T> Constructor<T> check(Class<T> c)
    {
        final Constructor<T> ctor;

        Objects.requireNonNull(c, "The Class<T> parameter 'c' has been passed null");

        try
        {
            // This just gets a "Constructor" using Reflection.  The main point is that the
            // Constructor must have exactly one parameter - and that parameter must have a
            // type "JsonObject"  (basic java.lang.reflect stuff)
            //
            //System.out.println("c.getName:():" + c.getName());

            ctor = c.getDeclaredConstructor(JsonObject.class);
        }

        catch (Exception e)
        {
            if (c.getEnclosingClass() != null)
            {
                int modifiers = c.getModifiers();

                if ((! Modifier.isStatic(modifiers)) ||  (! Modifier.isPublic(modifiers)))

                    throw new InvalidClassException(
                        "Unable to retrieve POJO Constructor for class: " +
                        "[" + c.getName() + "]\n" +
                        "Your class appears to be a Nested-Class, however it has not been " +
                        "declared public and static.  There is no way to retrieve a " +
                        "1-Argument JsonObject Constructor for Nested-Type's unless the " +
                        "type has been declared BOTH static AND public.\n" +
                        "See Exception.getCause() for details.",
                        e
                    );

                else throw new InvalidClassException(
                    "There was a problem retrieving a one-argument, public, constructor for the " +
                    "class you wish to instantiate.  See Exception.getCause() for details.",
                    e
                );
            }

            else throw new InvalidClassException(
                "Unable to retrieve POJO Constructor for class: [" + c.getName() + "]\n" +
                "Do you have a one-argument, public, constructor for this class?\n" +
                "Does it accept a JsonObject in its parameter list?\n" +
                "See Exception.getCause() for details.",
                e
            );
        }


        // If the user has requested a class that doesn't have that kind of constructor, then
        // there is no way to build the object.  Throw an exception.

        if (ctor == null) throw new InvalidClassException(
            "The class which was passed to parameter 'c' [" + c.getName() + "] does not " +
            "appear to have a constructor with precisely one parameter of type JsonObject.  " +
            "c.getDeclaredConstructor(JsonObject.class) has returned null."
        );

        return ctor;
    }
}