/*

 * 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 java.lang.reflect.Executable;

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.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.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 jdk.vm.ci.meta.MetaAccessProvider;

import jdk.vm.ci.meta.MetaUtil;

import jdk.vm.ci.meta.ResolvedJavaMethod;

/**

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

 */

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 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) {

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

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

        }

    }

    /**

     * Key for a {@linkplain ClassPlugins#entries resolved} plugin registration. Due to the

     * possibility of class redefinition, we cannot directly use {@link ResolvedJavaMethod}s as

     * keys. A {@link ResolvedJavaMethod} implementation might implement {@code equals()} and

     * {@code hashCode()} based on internal representation subject to change by class redefinition.

     */

    static final class ResolvedJavaMethodKey {

        private final ResolvedJavaMethod method;

        ResolvedJavaMethodKey(ResolvedJavaMethod method) {

            this.method = method;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof ResolvedJavaMethodKey) {

                ResolvedJavaMethodKey that = (ResolvedJavaMethodKey) obj;

                if (this.method.isStatic() == that.method.isStatic()) {

                    if (this.method.getDeclaringClass().equals(that.method.getDeclaringClass())) {

                        if (this.method.getName().equals(that.method.getName())) {

                            if (this.method.getSignature().equals(that.method.getSignature())) {

                                return true;

                            }

                        }

                    }

                }

            }

            return false;

        }

        @Override

        public int hashCode() {

            return this.method.getName().hashCode();

        }

        @Override

        public String toString() {

            return "ResolvedJavaMethodKey<" + method + ">";

        }

    }

    /**

     * Key for {@linkplain ClassPlugins#registrations registering} an {@link InvocationPlugin} for a

     * specific method.

     */

    static class MethodKey {

        final boolean isStatic;

        /**

         * This method is optional. This is used for new API methods not present in previous JDK

         * versions.

         */

        final boolean isOptional;

        final String name;

        final Type[] argumentTypes;

        final InvocationPlugin value;

        /**

         * Used to lazily initialize {@link #resolved}.

         */

        private final MetaAccessProvider metaAccess;

        private volatile ResolvedJavaMethod resolved;

        MethodKey(MetaAccessProvider metaAccess, InvocationPlugin data, boolean isStatic, boolean isOptional, String name, Type... argumentTypes) {

            this.metaAccess = metaAccess;

            this.value = data;

            this.isStatic = isStatic;

            this.isOptional = isOptional;

            this.name = name;

            this.argumentTypes = argumentTypes;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof MethodKey) {

                MethodKey that = (MethodKey) obj;

                boolean res = this.name.equals(that.name) && areEqual(this.argumentTypes, that.argumentTypes);

                assert !res || this.isStatic == that.isStatic;

                return res;

            }

            return false;

        }

        private static boolean areEqual(Type[] args1, Type[] args2) {

            if (args1.length == args2.length) {

                for (int i = 0; i < args1.length; i++) {

                    if (!args1[i].getTypeName().equals(args2[i].getTypeName())) {

                        return false;

                    }

                }

                return true;

            }

            return false;

        }

        public int getDeclaredParameterCount() {

            return isStatic ? argumentTypes.length : argumentTypes.length - 1;

        }

        @Override

        public int hashCode() {

            return name.hashCode();

        }

        private ResolvedJavaMethod resolve(Class<?> declaringClass) {

            if (resolved == null) {

                Executable method = resolveJava(declaringClass);

                if (method == null) {

                    return null;

                }

                resolved = metaAccess.lookupJavaMethod(method);

            }

            return resolved;

        }

        private Executable resolveJava(Class<?> declaringClass) {

            try {

                Executable res;

                Class<?>[] parameterTypes = resolveTypes(argumentTypes, isStatic ? 0 : 1, argumentTypes.length);

                if (name.equals("<init>")) {

                    res = declaringClass.getDeclaredConstructor(parameterTypes);

                } else {

                    res = declaringClass.getDeclaredMethod(name, parameterTypes);

                }

                assert Modifier.isStatic(res.getModifiers()) == isStatic : res;

                return res;

            } catch (NoSuchMethodException | SecurityException e) {

                if (isOptional) {

                    return null;

                }

                throw new InternalError(e);

            }

        }

        @Override

        public String toString() {

            StringBuilder sb = new StringBuilder(name).append('(');

            for (Type p : argumentTypes) {

                if (sb.charAt(sb.length() - 1) != '(') {

                    sb.append(", ");

                }

                sb.append(p.getTypeName());

            }

            return sb.append(')').toString();

        }

    }

    private final MetaAccessProvider metaAccess;

    /**

     * Deferred registrations as well as guard for initialization. The guard uses double-checked

     * locking which is why this field is {@code volatile}.