/*

 * 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file, and Oracle licenses the original version of this file under the BSD

 * license:

 */

/*

   Copyright 2009-2013 Attila Szegedi

*/

package jdk.dynalink.beans;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.reflect.AccessibleObject;

import java.lang.reflect.Constructor;

import java.lang.reflect.Executable;

import java.lang.reflect.Member;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.SecureLookupSupplier;

import jdk.dynalink.internal.AccessControlContextFactory;

import jdk.dynalink.linker.support.Lookup;

import jdk.internal.reflect.CallerSensitive;

/**

 * A dynamic method bound to exactly one Java method or constructor that is caller sensitive. Since the target method is

 * caller sensitive, it doesn't cache a method handle but rather uses the passed lookup object in

 * {@link #getTarget(CallSiteDescriptor)} to unreflect a method handle from the reflective member on

 * every request.

 */

class CallerSensitiveDynamicMethod extends SingleDynamicMethod {

    private static final AccessControlContext GET_LOOKUP_CONTEXT =

            AccessControlContextFactory.createAccessControlContext(

                    SecureLookupSupplier.GET_LOOKUP_PERMISSION_NAME);

    // Typed as "AccessibleObject" as it can be either a method or a constructor.

    // If we were Java8-only, we could use java.lang.reflect.Executable

    private final AccessibleObject target;

    private final MethodType type;

    CallerSensitiveDynamicMethod(final AccessibleObject target) {

        super(getName(target));

        this.target = target;

        this.type = getMethodType(target);

    }

    private static String getName(final AccessibleObject target) {

        final Member m = (Member)target;

        final boolean constructor = m instanceof Constructor;

        return getMethodNameWithSignature(getMethodType(target), constructor ? m.getName() :

            getClassAndMethodName(m.getDeclaringClass(), m.getName()), !constructor);

    }

    @Override

    MethodType getMethodType() {

        return type;

    }

    private static MethodType getMethodType(final AccessibleObject ao) {

        final boolean isMethod = ao instanceof Method;

        final Class<?> rtype = isMethod ? ((Method)ao).getReturnType() : ((Constructor<?>)ao).getDeclaringClass();

        final Class<?>[] ptypes = isMethod ? ((Method)ao).getParameterTypes() : ((Constructor<?>)ao).getParameterTypes();

        final MethodType type = MethodType.methodType(rtype, ptypes);

        final Member m = (Member)ao;

        return type.insertParameterTypes(0,

                isMethod ?

                        Modifier.isStatic(m.getModifiers()) ?

                                Object.class :

                                m.getDeclaringClass() :

                        StaticClass.class);

    }

    @Override

    boolean isVarArgs() {

        return target instanceof Method ? ((Method)target).isVarArgs() : ((Constructor<?>)target).isVarArgs();

    }

    @Override

    MethodHandle getTarget(final CallSiteDescriptor desc) {

        final MethodHandles.Lookup lookup = AccessController.doPrivileged(

                (PrivilegedAction<MethodHandles.Lookup>)()->desc.getLookup(),

                GET_LOOKUP_CONTEXT);

        if(target instanceof Method) {

            final MethodHandle mh = unreflect(lookup, (Method)target);

            if(Modifier.isStatic(((Member)target).getModifiers())) {

                return StaticClassIntrospector.editStaticMethodHandle(mh);

            }

            return mh;

        }

        return StaticClassIntrospector.editConstructorMethodHandle(unreflectConstructor(lookup,

                (Constructor<?>)target));

    }

    @Override

    boolean isConstructor() {

        return target instanceof Constructor;

    }

    private static MethodHandle unreflect(final MethodHandles.Lookup lookup, final Method m) {

        return Lookup.unreflect(lookup, m);

    }

    private static MethodHandle unreflectConstructor(final MethodHandles.Lookup lookup, final Constructor<?> c) {

        return Lookup.unreflectConstructor(lookup, c);

    }

}