/*

 * Copyright (c) 2015, 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.

 *

 * 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 org.graalvm.compiler.nodes.graphbuilderconf;

import static java.lang.String.format;

import static org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins.LateClassPlugins.CLOSED_LATE_CLASS_PLUGIN;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import org.graalvm.compiler.api.replacements.MethodSubstitution;

import org.graalvm.compiler.api.replacements.MethodSubstitutionRegistry;

import org.graalvm.compiler.bytecode.BytecodeProvider;

import org.graalvm.compiler.debug.Assertions;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.graph.Node;

import org.graalvm.compiler.graph.iterators.NodeIterable;

import org.graalvm.compiler.nodes.ValueNode;

import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin.Receiver;

import org.graalvm.util.EconomicMap;

import org.graalvm.util.Equivalence;

import org.graalvm.util.MapCursor;

import org.graalvm.util.Pair;

import org.graalvm.util.UnmodifiableEconomicMap;

import org.graalvm.util.UnmodifiableMapCursor;

import jdk.vm.ci.meta.MetaUtil;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.ResolvedJavaType;

import jdk.vm.ci.meta.Signature;

/**

 * Manages a set of {@link InvocationPlugin}s.

 *

 * Most plugins are registered during initialization (i.e., before

 * {@link #lookupInvocation(ResolvedJavaMethod)} or {@link #getBindings} is called). These

 * registrations can be made with {@link Registration},

 * {@link #register(InvocationPlugin, String, String, Type...)},

 * {@link #register(InvocationPlugin, Type, String, Type...)} or

 * {@link #registerOptional(InvocationPlugin, Type, String, Type...)}. Initialization is not

 * thread-safe and so must only be performed by a single thread.

 *

 * Plugins that are not guaranteed to be made during initialization must use

 * {@link LateRegistration}.

 */

public class InvocationPlugins {

    public static class InvocationPluginReceiver implements InvocationPlugin.Receiver {

        private final GraphBuilderContext parser;

        private ValueNode[] args;

        private ValueNode value;

        public InvocationPluginReceiver(GraphBuilderContext parser) {

            this.parser = parser;

        }

        @Override

        public ValueNode get(boolean performNullCheck) {

            assert args != null : "Cannot get the receiver of a static method";

            if (!performNullCheck) {

                return args[0];

            }

            if (value == null) {

                value = parser.nullCheckedValue(args[0]);

                if (value != args[0]) {

                    args[0] = value;

                }

            }

            return value;

        }

        @Override

        public boolean isConstant() {

            return args[0].isConstant();

        }

        public InvocationPluginReceiver init(ResolvedJavaMethod targetMethod, ValueNode[] newArgs) {

            if (!targetMethod.isStatic()) {

                this.args = newArgs;

                this.value = null;

                return this;

            }

            return null;

        }

    }

    /**

     * A symbol that is lazily {@linkplain OptionalLazySymbol#resolve() resolved} to a {@link Type}.

     */

    static class OptionalLazySymbol implements Type {

        private static final Class<?> MASK_NULL = OptionalLazySymbol.class;

        private final String name;

        private Class<?> resolved;

        OptionalLazySymbol(String name) {

            this.name = name;

        }

        @Override

        public String getTypeName() {

            return name;

        }

        /**

         * Gets the resolved {@link Class} corresponding to this symbol or {@code null} if

         * resolution fails.

         */

        public Class<?> resolve() {

            if (resolved == null) {

                Class<?> resolvedOrNull = resolveClass(name, true);

                resolved = resolvedOrNull == null ? MASK_NULL : resolvedOrNull;

            }

            return resolved == MASK_NULL ? null : resolved;

        }

        @Override

        public String toString() {

            return name;

        }

    }

    /**

     * Utility for {@linkplain InvocationPlugins#register(InvocationPlugin, Class, String, Class...)

     * registration} of invocation plugins.

     */

    public static class Registration implements MethodSubstitutionRegistry {

        private final InvocationPlugins plugins;

        private final Type declaringType;

        private final BytecodeProvider methodSubstitutionBytecodeProvider;

        private boolean allowOverwrite;

        @Override

        public Class<?> getReceiverType() {

            return Receiver.class;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         */

        public Registration(InvocationPlugins plugins, Type declaringType) {

            this.plugins = plugins;

            this.declaringType = declaringType;

            this.methodSubstitutionBytecodeProvider = null;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         * @param methodSubstitutionBytecodeProvider provider used to get the bytecodes to parse for

         *            method substitutions

         */

        public Registration(InvocationPlugins plugins, Type declaringType, BytecodeProvider methodSubstitutionBytecodeProvider) {

            this.plugins = plugins;

            this.declaringType = declaringType;

            this.methodSubstitutionBytecodeProvider = methodSubstitutionBytecodeProvider;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringClassName the name of the class class declaring the methods for which

         *            plugins will be registered via this object

         * @param methodSubstitutionBytecodeProvider provider used to get the bytecodes to parse for

         *            method substitutions

         */

        public Registration(InvocationPlugins plugins, String declaringClassName, BytecodeProvider methodSubstitutionBytecodeProvider) {

            this.plugins = plugins;

            this.declaringType = new OptionalLazySymbol(declaringClassName);

            this.methodSubstitutionBytecodeProvider = methodSubstitutionBytecodeProvider;

        }

        /**

         * Configures this registration to allow or disallow overwriting of invocation plugins.

         */

        public Registration setAllowOverwrite(boolean allowOverwrite) {

            this.allowOverwrite = allowOverwrite;

            return this;

        }

        /**

         * Registers a plugin for a method with no arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register0(String name, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name);

        }

        /**

         * Registers a plugin for a method with 1 argument.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register1(String name, Type arg, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg);

        }

        /**

         * Registers a plugin for a method with 2 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register2(String name, Type arg1, Type arg2, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2);

        }

        /**

         * Registers a plugin for a method with 3 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register3(String name, Type arg1, Type arg2, Type arg3, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3);

        }

        /**

         * Registers a plugin for a method with 4 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register4(String name, Type arg1, Type arg2, Type arg3, Type arg4, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4);

        }

        /**

         * Registers a plugin for a method with 5 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register5(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5);

        }

        /**

         * Registers a plugin for a method with 6 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register6(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6);

        }

        /**

         * Registers a plugin for a method with 7 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register7(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, Type arg7, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

        }

        /**

         * Registers a plugin for an optional method with no arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional0(String name, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name);

        }

        /**

         * Registers a plugin for an optional method with 1 argument.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional1(String name, Type arg, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg);

        }

        /**

         * Registers a plugin for an optional method with 2 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional2(String name, Type arg1, Type arg2, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg1, arg2);

        }

        /**

         * Registers a plugin for an optional method with 3 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional3(String name, Type arg1, Type arg2, Type arg3, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg1, arg2, arg3);

        }

        /**

         * Registers a plugin for an optional method with 4 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional4(String name, Type arg1, Type arg2, Type arg3, Type arg4, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4);

        }

        /**

         * Registers a plugin that implements a method based on the bytecode of a substitute method.

         *

         * @param substituteDeclaringClass the class declaring the substitute method

         * @param name the name of both the original and substitute method

         * @param argumentTypes the argument types of the method. Element 0 of this array must be

         *            the {@link Class} value for {@link InvocationPlugin.Receiver} iff the method

         *            is non-static. Upon returning, element 0 will have been rewritten to

         *            {@code declaringClass}

         */

        @Override

        public void registerMethodSubstitution(Class<?> substituteDeclaringClass, String name, Type... argumentTypes) {

            registerMethodSubstitution(substituteDeclaringClass, name, name, argumentTypes);

        }

        /**

         * Registers a plugin that implements a method based on the bytecode of a substitute method.

         *

         * @param substituteDeclaringClass the class declaring the substitute method

         * @param name the name of both the original method

         * @param substituteName the name of the substitute method

         * @param argumentTypes the argument types of the method. Element 0 of this array must be

         *            the {@link Class} value for {@link InvocationPlugin.Receiver} iff the method

         *            is non-static. Upon returning, element 0 will have been rewritten to

         *            {@code declaringClass}

         */

        @Override

        public void registerMethodSubstitution(Class<?> substituteDeclaringClass, String name, String substituteName, Type... argumentTypes) {

            MethodSubstitutionPlugin plugin = createMethodSubstitution(substituteDeclaringClass, substituteName, argumentTypes);

            plugins.register(plugin, false, allowOverwrite, declaringType, name, argumentTypes);

        }

        public MethodSubstitutionPlugin createMethodSubstitution(Class<?> substituteDeclaringClass, String substituteName, Type... argumentTypes) {

            assert methodSubstitutionBytecodeProvider != null : "Registration used for method substitutions requires a non-null methodSubstitutionBytecodeProvider";

            MethodSubstitutionPlugin plugin = new MethodSubstitutionPlugin(methodSubstitutionBytecodeProvider, substituteDeclaringClass, substituteName, argumentTypes);

            return plugin;

        }

    }

    /**

     * Utility for registering plugins after Graal may have been initialized. Registrations made via

     * this class are not finalized until {@link #close} is called.

     */

    public static class LateRegistration implements AutoCloseable {

        private InvocationPlugins plugins;

        private final List<Binding> bindings = new ArrayList<>();

        private final Type declaringType;

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         */

        public LateRegistration(InvocationPlugins plugins, Type declaringType) {

            this.plugins = plugins;

            this.declaringType = declaringType;

        }

        /**

         * Registers an invocation plugin for a given method. There must be no plugin currently

         * registered for {@code method}.

         *

         * @param argumentTypes the argument types of the method. Element 0 of this array must be

         *            the {@link Class} value for {@link InvocationPlugin.Receiver} iff the method

         *            is non-static. Upon returning, element 0 will have been rewritten to

         *            {@code declaringClass}

         */

        public void register(InvocationPlugin plugin, String name, Type... argumentTypes) {

            boolean isStatic = argumentTypes.length == 0 || argumentTypes[0] != InvocationPlugin.Receiver.class;

            if (!isStatic) {

                argumentTypes[0] = declaringType;

            }

            assert isStatic || argumentTypes[0] == declaringType;

            Binding binding = new Binding(plugin, isStatic, name, argumentTypes);

            bindings.add(binding);

            assert Checks.check(this.plugins, declaringType, binding);

            assert Checks.checkResolvable(false, declaringType, binding);

        }

        @Override

        public void close() {

            assert plugins != null : String.format("Late registrations of invocation plugins for %s is already closed", declaringType);

            plugins.registerLate(declaringType, bindings);

            plugins = null;

        }

    }

    /**

     * Associates an {@link InvocationPlugin} with the details of a method it substitutes.

     */

    public static class Binding {

        /**

         * The plugin this binding is for.

         */

        public final InvocationPlugin plugin;

        /**

         * Specifies if the associated method is static.

         */

        public final boolean isStatic;

        /**

         * The name of the associated method.

         */

        public final String name;

        /**

         * A partial

         * <a href="http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.3">method

         * descriptor</a> for the associated method. The descriptor includes enclosing {@code '('}

         * and {@code ')'} characters but omits the return type suffix.

         */

        public final String argumentsDescriptor;

        /**

         * Link in a list of bindings.

         */

        private Binding next;

        Binding(InvocationPlugin data, boolean isStatic, String name, Type... argumentTypes) {

            this.plugin = data;

            this.isStatic = isStatic;

            this.name = name;

            StringBuilder buf = new StringBuilder();

            buf.append('(');

            for (int i = isStatic ? 0 : 1; i < argumentTypes.length; i++) {

                buf.append(MetaUtil.toInternalName(argumentTypes[i].getTypeName()));

            }

            buf.append(')');

            this.argumentsDescriptor = buf.toString();

            assert !name.equals("<init>") || !isStatic : this;

        }

        Binding(ResolvedJavaMethod resolved, InvocationPlugin data) {

            this.plugin = data;

            this.isStatic = resolved.isStatic();

            this.name = resolved.getName();

            Signature sig = resolved.getSignature();

            String desc = sig.toMethodDescriptor();

            assert desc.indexOf(')') != -1 : desc;

            this.argumentsDescriptor = desc.substring(0, desc.indexOf(')') + 1);

            assert !name.equals("<init>") || !isStatic : this;

        }

        @Override

        public String toString() {

            return name + argumentsDescriptor;

        }

    }

    /**

     * Plugin registrations for already resolved methods. If non-null, then {@link #registrations}

     * is null and no further registrations can be made.

     */

    private final UnmodifiableEconomicMap<ResolvedJavaMethod, InvocationPlugin> resolvedRegistrations;

    /**

     * Map from class names in {@linkplain MetaUtil#toInternalName(String) internal} form to the

     * invocation plugin bindings for the class. Tf non-null, then {@link #resolvedRegistrations}