/*

 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.nashorn.internal.runtime;

import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;

import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.beans.BeansLinker;

import jdk.dynalink.beans.StaticClass;

import jdk.dynalink.linker.GuardedInvocation;

import jdk.dynalink.linker.LinkRequest;

import jdk.dynalink.linker.support.Guards;

import jdk.nashorn.internal.lookup.MethodHandleFactory;

import jdk.nashorn.internal.lookup.MethodHandleFunctionality;

import jdk.nashorn.internal.objects.annotations.Attribute;

import jdk.nashorn.internal.objects.annotations.Function;

import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;

/**

 * An object that exposes Java packages and classes as its properties. Packages are exposed as objects that have further

 * sub-packages and classes as their properties. Normally, three instances of this class are exposed as built-in objects

 * in Nashorn: {@code "Packages"}, {@code "java"}, and {@code "javax"}. Typical usages are:

 * <pre>

 * var list = new java.util.ArrayList()

 * var sprocket = new Packages.com.acme.Sprocket()

 * </pre>

 * or you can store the type objects in a variable for later reuse:

 * <pre>

 * var ArrayList = java.util.ArrayList

 * var list = new ArrayList

 * </pre>

 * You can also use {@link jdk.nashorn.internal.objects.NativeJava#type(Object, Object)} to access Java classes. These two statements are mostly

 * equivalent:

 * <pre>

 * var listType1 = java.util.ArrayList

 * var listType2 = Java.type("java.util.ArrayList")

 * </pre>

 * The difference is that {@code Java.type()} will throw an error if the class does not exist, while the first

 * expression will return an empty object, as it must treat all non-existent classes as potentially being further

 * subpackages. As such, {@code Java.type()} has the potential to catch typos earlier. A further difference is that

 * {@code Java.type()} doesn't recognize {@code .} (dot) as the separator between outer class name and inner class name,

 * it only recognizes the dollar sign. These are equivalent:

 * <pre>

 * var ftype1 = java.awt.geom.Arc2D$Float

 * var ftype2 = java.awt.geom.Arc2D.Float

 * var ftype3 = Java.asType("java.awt.geom.Arc2D$Float")

 * var ftype4 = Java.asType("java.awt.geom.Arc2D").Float

 * </pre>

 */

public final class NativeJavaPackage extends ScriptObject {

    private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();

    private static final MethodHandle CLASS_NOT_FOUND = findOwnMH("classNotFound", Void.TYPE, NativeJavaPackage.class);

    private static final MethodHandle TYPE_GUARD = Guards.getClassGuard(NativeJavaPackage.class);

    /** Full name of package (includes path.) */

    private final String name;

    /**

     * Public constructor to be accessible from {@link jdk.nashorn.internal.objects.Global}

     * @param name  package name

     * @param proto proto

     */

    public NativeJavaPackage(final String name, final ScriptObject proto) {

        super(proto, null);

        // defense-in-path, check here for sensitive packages

        Context.checkPackageAccess(name);

        this.name = name;

    }

    @Override

    public String getClassName() {

        return "JavaPackage";

    }

    @Override

    public boolean equals(final Object other) {

        if (other instanceof NativeJavaPackage) {

            return name.equals(((NativeJavaPackage)other).name);

        }

        return false;

    }

    @Override

    public int hashCode() {

        return name == null ? 0 : name.hashCode();

    }

    /**

     * Get the full name of the package

     * @return the name

     */

    public String getName() {

        return name;

    }

    @Override

    public String safeToString() {

        return toString();

    }

    @Override

    public String toString() {

        return "[JavaPackage " + name + "]";

    }

    @Override

    public Object getDefaultValue(final Class<?> hint) {

        if (hint == String.class) {

            return toString();

        }

        return super.getDefaultValue(hint);

    }

    @Override

    protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        return createClassNotFoundInvocation(desc);

    }

    @Override

    protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        return createClassNotFoundInvocation(desc);

    }

    private static GuardedInvocation createClassNotFoundInvocation(final CallSiteDescriptor desc) {

        // If NativeJavaPackage is invoked either as a constructor or as a function, throw a ClassNotFoundException as

        // we can assume the user attempted to instantiate a non-existent class.

        final MethodType type = desc.getMethodType();

        return new GuardedInvocation(

                MH.dropArguments(CLASS_NOT_FOUND, 1, type.parameterList().subList(1, type.parameterCount())),

                type.parameterType(0) == NativeJavaPackage.class ? null : TYPE_GUARD);

    }

    @SuppressWarnings("unused")

    private static void classNotFound(final NativeJavaPackage pkg) throws ClassNotFoundException {

        throw new ClassNotFoundException(pkg.name);

    }

    /**

     * "No such property" call placeholder.

     *

     * This can never be called as we override {@link ScriptObject#noSuchProperty}. We do declare it here as it's a signal

     * to {@link WithObject} that it's worth trying doing a {@code noSuchProperty} on this object.

     *

     * @param self self reference

     * @param name property name

     * @return never returns

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object __noSuchProperty__(final Object self, final Object name) {

        throw new AssertionError("__noSuchProperty__ placeholder called");

    }

    /**

     * "No such method call" placeholder

     *

     * This can never be called as we override {@link ScriptObject#noSuchMethod}. We do declare it here as it's a signal

     * to {@link WithObject} that it's worth trying doing a noSuchProperty on this object.

     *

     * @param self self reference

     * @param args arguments to method

     * @return never returns

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object __noSuchMethod__(final Object self, final Object... args) {

        throw new AssertionError("__noSuchMethod__ placeholder called");

    }

    /**

     * Handle creation of new attribute.

     * @param desc the call site descriptor

     * @param request the link request

     * @return Link to be invoked at call site.

     */

    @Override

    public GuardedInvocation noSuchProperty(final CallSiteDescriptor desc, final LinkRequest request) {

        final String propertyName = NashornCallSiteDescriptor.getOperand(desc);

        createProperty(propertyName);

        return super.lookup(desc, request);

    }

    @Override

    protected Object invokeNoSuchProperty(final Object key, final boolean isScope, final int programPoint) {

        if (!(key instanceof String)) {

            return super.invokeNoSuchProperty(key, isScope, programPoint);

        }

        final Object retval = createProperty((String) key);

        if (isValid(programPoint)) {

            throw new UnwarrantedOptimismException(retval, programPoint);

        }

        return retval;

    }

    @Override

    public GuardedInvocation noSuchMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        return noSuchProperty(desc, request);

    }

    private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {

        return MH.findStatic(MethodHandles.lookup(), NativeJavaPackage.class, name, MH.type(rtype, types));

    }

    private Object createProperty(final String propertyName) {

        final String fullName     = name.isEmpty() ? propertyName : name + "." + propertyName;

        final Context context = Context.getContextTrusted();

        Class<?> javaClass = null;

        try {

            javaClass = context.findClass(fullName);

        } catch (final NoClassDefFoundError | ClassNotFoundException e) {

            //ignored

        }

        // Check for explicit constructor signature use

        // Example: new (java.awt["Color(int, int,int)"])(2, 3, 4);

        final int openBrace = propertyName.indexOf('(');

        final int closeBrace = propertyName.lastIndexOf(')');

        if (openBrace != -1 || closeBrace != -1) {

            final int lastChar = propertyName.length() - 1;

            if (openBrace == -1 || closeBrace != lastChar) {

                throw typeError("improper.constructor.signature", propertyName);

            }

            // get the class name and try to load it

            final String className = name + "." + propertyName.substring(0, openBrace);

            try {

                javaClass = context.findClass(className);

            } catch (final NoClassDefFoundError | ClassNotFoundException e) {

                throw typeError(e, "no.such.java.class", className);

            }

            // try to find a matching constructor

            final Object constructor = BeansLinker.getConstructorMethod(

                    javaClass, propertyName.substring(openBrace + 1, lastChar));

            if (constructor != null) {

                set(propertyName, constructor, 0);

                return constructor;

            }

            // we didn't find a matching constructor!

            throw typeError("no.such.java.constructor", propertyName);

        }

        final Object propertyValue;

        if (javaClass == null) {

            propertyValue = new NativeJavaPackage(fullName, getProto());

        } else {

            propertyValue = StaticClass.forClass(javaClass);

        }

        set(propertyName, propertyValue, 0);

        return propertyValue;

    }

}