/*

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

import java.lang.reflect.Member;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.NamedOperation;

import jdk.dynalink.Namespace;

import jdk.dynalink.NamespaceOperation;

import jdk.dynalink.Operation;

import jdk.dynalink.StandardNamespace;

import jdk.dynalink.StandardOperation;

import jdk.dynalink.beans.GuardedInvocationComponent.ValidationType;

import jdk.dynalink.internal.InternalTypeUtilities;

import jdk.dynalink.linker.GuardedInvocation;

import jdk.dynalink.linker.GuardingDynamicLinker;

import jdk.dynalink.linker.LinkRequest;

import jdk.dynalink.linker.LinkerServices;

import jdk.dynalink.linker.support.Guards;

import jdk.dynalink.linker.support.Lookup;

import jdk.internal.reflect.CallerSensitive;

/**

 * A base class for both {@link StaticClassLinker} and {@link BeanLinker}. Deals with common aspects of property

 * exposure and method calls for both static and instance facets of a class.

 */

abstract class AbstractJavaLinker implements GuardingDynamicLinker {

    final Class<?> clazz;

    private final MethodHandle classGuard;

    private final MethodHandle assignableGuard;

    private final Map<String, AnnotatedDynamicMethod> propertyGetters = new HashMap<>();

    private final Map<String, DynamicMethod> propertySetters = new HashMap<>();

    private final Map<String, DynamicMethod> methods = new HashMap<>();

    AbstractJavaLinker(final Class<?> clazz, final MethodHandle classGuard) {

        this(clazz, classGuard, classGuard);

    }

    AbstractJavaLinker(final Class<?> clazz, final MethodHandle classGuard, final MethodHandle assignableGuard) {

        this.clazz = clazz;

        this.classGuard = classGuard;

        this.assignableGuard = assignableGuard;

        final FacetIntrospector introspector = createFacetIntrospector();

        // Add methods and properties

        for(final Method method: introspector.getMethods()) {

            final String name = method.getName();

            // Add method

            addMember(name, method, methods);

            // Add the method as a property getter and/or setter

            if(name.startsWith("get") && name.length() > 3 && method.getParameterTypes().length == 0) {

                // Property getter

                setPropertyGetter(method, 3);

            } else if(name.startsWith("is") && name.length() > 2 && method.getParameterTypes().length == 0 &&

                    method.getReturnType() == boolean.class) {

                // Boolean property getter

                setPropertyGetter(method, 2);

            } else if(name.startsWith("set") && name.length() > 3 && method.getParameterTypes().length == 1) {

                // Property setter

                addMember(decapitalize(name.substring(3)), method, propertySetters);

            }

        }

        // Add field getter/setters as property getters/setters.

        for(final Field field: introspector.getFields()) {

            final String name = field.getName();

            // Only add a property getter when one is not defined already as a getXxx()/isXxx() method.

            if(!propertyGetters.containsKey(name)) {

                setPropertyGetter(name, introspector.unreflectGetter(field), ValidationType.EXACT_CLASS);

            }

            if(!(Modifier.isFinal(field.getModifiers()) || propertySetters.containsKey(name))) {

                addMember(name, new SimpleDynamicMethod(introspector.unreflectSetter(field), clazz, name),

                        propertySetters);

            }

        }

        // Add inner classes, but only those for which we don't hide a property with it

        for(final Map.Entry<String, MethodHandle> innerClassSpec: introspector.getInnerClassGetters().entrySet()) {

            final String name = innerClassSpec.getKey();

            if(!propertyGetters.containsKey(name)) {

                setPropertyGetter(name, innerClassSpec.getValue(), ValidationType.EXACT_CLASS);

            }

        }

    }

    private static String decapitalize(final String str) {

        assert str != null;

        if(str.isEmpty()) {

            return str;

        }

        final char c0 = str.charAt(0);

        if(Character.isLowerCase(c0)) {

            return str;

        }

        // If it has two consecutive upper-case characters, i.e. "URL", don't decapitalize

        if(str.length() > 1 && Character.isUpperCase(str.charAt(1))) {

            return str;

        }

        final char c[] = str.toCharArray();

        c[0] = Character.toLowerCase(c0);

        return new String(c);

    }

    abstract FacetIntrospector createFacetIntrospector();

    Set<String> getReadablePropertyNames() {

        return getUnmodifiableKeys(propertyGetters);

    }

    Set<String> getWritablePropertyNames() {

        return getUnmodifiableKeys(propertySetters);

    }

    Set<String> getMethodNames() {

        return getUnmodifiableKeys(methods);

    }

    private static Set<String> getUnmodifiableKeys(final Map<String, ?> m) {

        return Collections.unmodifiableSet(m.keySet());

    }

    /**

     * Sets the specified dynamic method to be the property getter for the specified property. Note that you can only

     * use this when you're certain that the method handle does not belong to a caller-sensitive method. For properties

     * that are caller-sensitive, you must use {@link #setPropertyGetter(String, SingleDynamicMethod, ValidationType)}

     * instead.

     * @param name name of the property

     * @param handle the method handle that implements the property getter

     * @param validationType the validation type for the property

     */

    private void setPropertyGetter(final String name, final SingleDynamicMethod handle, final ValidationType validationType) {

        propertyGetters.put(name, new AnnotatedDynamicMethod(handle, validationType));

    }

    /**

     * Sets the specified reflective method to be the property getter for the specified property.

     * @param getter the getter method

     * @param prefixLen the getter prefix in the method name; should be 3 for getter names starting with "get" and 2 for

     * names starting with "is".

     */

    private void setPropertyGetter(final Method getter, final int prefixLen) {

        setPropertyGetter(decapitalize(getter.getName().substring(prefixLen)), createDynamicMethod(

                getMostGenericGetter(getter)), ValidationType.INSTANCE_OF);

    }

    /**

     * Sets the specified method handle to be the property getter for the specified property. Note that you can only

     * use this when you're certain that the method handle does not belong to a caller-sensitive method. For properties

     * that are caller-sensitive, you must use {@link #setPropertyGetter(String, SingleDynamicMethod, ValidationType)}

     * instead.

     * @param name name of the property

     * @param handle the method handle that implements the property getter

     * @param validationType the validation type for the property

     */

    void setPropertyGetter(final String name, final MethodHandle handle, final ValidationType validationType) {

        setPropertyGetter(name, new SimpleDynamicMethod(handle, clazz, name), validationType);

    }

    private void addMember(final String name, final AccessibleObject ao, final Map<String, DynamicMethod> methodMap) {

        addMember(name, createDynamicMethod(ao), methodMap);

    }

    private void addMember(final String name, final SingleDynamicMethod method, final Map<String, DynamicMethod> methodMap) {

        final DynamicMethod existingMethod = methodMap.get(name);

        final DynamicMethod newMethod = mergeMethods(method, existingMethod, clazz, name);

        if(newMethod != existingMethod) {

            methodMap.put(name, newMethod);

        }

    }

    /**

     * Given one or more reflective methods or constructors, creates a dynamic method that represents them all. The

     * methods should represent all overloads of the same name (or all constructors of the class).

     * @param members the reflective members

     * @param clazz the class declaring the reflective members

     * @param name the common name of the reflective members.

     * @return a dynamic method representing all the specified reflective members.

     */

    static DynamicMethod createDynamicMethod(final Iterable<? extends AccessibleObject> members, final Class<?> clazz, final String name) {

        DynamicMethod dynMethod = null;

        for(final AccessibleObject method: members) {

            dynMethod = mergeMethods(createDynamicMethod(method), dynMethod, clazz, name);

        }

        return dynMethod;

    }

    /**

     * Given a reflective method or a constructor, creates a dynamic method that represents it. This method will

     * distinguish between caller sensitive and ordinary methods/constructors, and create appropriate caller sensitive

     * dynamic method when needed.

     * @param m the reflective member

     * @return the single dynamic method representing the reflective member

     */

    private static SingleDynamicMethod createDynamicMethod(final AccessibleObject m) {

        if (m.isAnnotationPresent(CallerSensitive.class)) {

            // Method has @CallerSensitive annotation

            return new CallerSensitiveDynamicMethod(m);

        }

        // Method has no @CallerSensitive annotation

        final MethodHandle mh;

        try {

            mh = unreflectSafely(m);

        } catch (final IllegalAccessError e) {

            // java.lang.invoke can in some case conservatively treat as caller sensitive methods that aren't

            // marked with the annotation. In this case, we'll fall back to treating it as caller sensitive.

            return new CallerSensitiveDynamicMethod(m);

        }

        // Proceed with non-caller sensitive

        final Member member = (Member)m;

        return new SimpleDynamicMethod(mh, member.getDeclaringClass(), member.getName(), m instanceof Constructor);

    }

    /**

     * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be

     * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were

     * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege

     * unreflector as its caller, and thus completely useless.

     * @param m the method or constructor

     * @return the method handle

     */

    private static MethodHandle unreflectSafely(final AccessibleObject m) {

        if(m instanceof Method) {

            final Method reflMethod = (Method)m;

            final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);

            if(Modifier.isStatic(reflMethod.getModifiers())) {

                return StaticClassIntrospector.editStaticMethodHandle(handle);

            }

            return handle;

        }

        return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));

    }

    private static DynamicMethod mergeMethods(final SingleDynamicMethod method, final DynamicMethod existing, final Class<?> clazz, final String name) {

        if(existing == null) {

            return method;

        } else if(existing.contains(method)) {

            return existing;

        } else if(existing instanceof SingleDynamicMethod) {

            final OverloadedDynamicMethod odm = new OverloadedDynamicMethod(clazz, name);

            odm.addMethod(((SingleDynamicMethod)existing));

            odm.addMethod(method);

            return odm;

        } else if(existing instanceof OverloadedDynamicMethod) {

            ((OverloadedDynamicMethod)existing).addMethod(method);

            return existing;

        }

        throw new AssertionError();

    }

    @Override

    public GuardedInvocation getGuardedInvocation(final LinkRequest request, final LinkerServices linkerServices)

            throws Exception {

        final CallSiteDescriptor callSiteDescriptor = request.getCallSiteDescriptor();

        final MissingMemberHandlerFactory missingMemberHandlerFactory;

        final LinkerServices directLinkerServices;

        if (linkerServices instanceof LinkerServicesWithMissingMemberHandlerFactory) {

            final LinkerServicesWithMissingMemberHandlerFactory lswmmhf = ((LinkerServicesWithMissingMemberHandlerFactory)linkerServices);

            missingMemberHandlerFactory = lswmmhf.missingMemberHandlerFactory;

            directLinkerServices = lswmmhf.linkerServices;

        } else {

            missingMemberHandlerFactory = null;

            directLinkerServices = linkerServices;

        }

        final GuardedInvocationComponent gic = getGuardedInvocationComponent(

                new ComponentLinkRequest(request, directLinkerServices,

                        missingMemberHandlerFactory));

        return gic != null ? gic.getGuardedInvocation() : null;

    }

    static final class ComponentLinkRequest {

        final LinkRequest linkRequest;

        final LinkerServices linkerServices;

        final MissingMemberHandlerFactory missingMemberHandlerFactory;

        final Operation baseOperation;

        final List<Namespace> namespaces;

        final Object name;

        ComponentLinkRequest(final LinkRequest linkRequest,

                final LinkerServices linkerServices,

                final MissingMemberHandlerFactory missingMemberHandlerFactory) {

            this.linkRequest = linkRequest;

            this.linkerServices = linkerServices;

            this.missingMemberHandlerFactory = missingMemberHandlerFactory;

            final Operation namedOp = linkRequest.getCallSiteDescriptor().getOperation();

            this.name = NamedOperation.getName(namedOp);

            final Operation namespaceOp = NamedOperation.getBaseOperation(namedOp);

            this.baseOperation = NamespaceOperation.getBaseOperation(namespaceOp);

            this.namespaces = Arrays.asList(NamespaceOperation.getNamespaces(namespaceOp));

        }

        private ComponentLinkRequest(final LinkRequest linkRequest,

                final LinkerServices linkerServices,

                final MissingMemberHandlerFactory missingMemberHandlerFactory,

                final Operation baseOperation, final List<Namespace> namespaces, final Object name) {

            this.linkRequest = linkRequest;

            this.linkerServices = linkerServices;

            this.missingMemberHandlerFactory = missingMemberHandlerFactory;

            this.baseOperation = baseOperation;

            this.namespaces = namespaces;

            this.name = name;

        }

        CallSiteDescriptor getDescriptor() {

            return linkRequest.getCallSiteDescriptor();

        }

        ComponentLinkRequest popNamespace() {

            return new ComponentLinkRequest(linkRequest, linkerServices,

                    missingMemberHandlerFactory, baseOperation,

                namespaces.subList(1, namespaces.size()), name);

        }

    }

    protected GuardedInvocationComponent getGuardedInvocationComponent(final ComponentLinkRequest req)

    throws Exception {

        if (req.namespaces.isEmpty()) {

            return null;

        }

        final Namespace ns = req.namespaces.get(0);

        final Operation op = req.baseOperation;

        if (op == StandardOperation.GET) {

            if (ns == StandardNamespace.PROPERTY) {

                return getPropertyGetter(req.popNamespace());

            } else if (ns == StandardNamespace.METHOD) {

                return getMethodGetter(req.popNamespace());

            }

        } else if (op == StandardOperation.SET && ns == StandardNamespace.PROPERTY) {

            return getPropertySetter(req.popNamespace());

        }

        return getNextComponent(req.popNamespace());

    }

    GuardedInvocationComponent getNextComponent(final ComponentLinkRequest req) throws Exception {

        if (req.namespaces.isEmpty()) {

            return createNoSuchMemberHandler(req.missingMemberHandlerFactory,

                    req.linkRequest, req.linkerServices);

        }

        final GuardedInvocationComponent gic = getGuardedInvocationComponent(req);

        if (gic != null) {

            return gic;

        }

        return getNextComponent(req.popNamespace());

    }

    private GuardedInvocationComponent createNoSuchMemberHandler(

            final MissingMemberHandlerFactory missingMemberHandlerFactory,

            final LinkRequest linkRequest, final LinkerServices linkerServices) throws Exception {

        if (missingMemberHandlerFactory == null) {

            return null;

        }

        final MethodHandle handler = missingMemberHandlerFactory.createMissingMemberHandler(linkRequest, linkerServices);

        if (handler == null) {

            return null;

        }

        final MethodType type = linkRequest.getCallSiteDescriptor().getMethodType();

        // The returned handler is allowed to differ in return type.

        assert handler.type().changeReturnType(type.returnType()).equals(type);

        return getClassGuardedInvocationComponent(handler, type);

    }

    static final <T> List<T> pop(final List<T> l) {

        return l.subList(1, l.size());

    }

    MethodHandle getClassGuard(final CallSiteDescriptor desc) {

        return getClassGuard(desc.getMethodType());

    }

    MethodHandle getClassGuard(final MethodType type) {

        return Guards.asType(classGuard, type);

    }

    GuardedInvocationComponent getClassGuardedInvocationComponent(final MethodHandle invocation, final MethodType type) {

        return new GuardedInvocationComponent(invocation, getClassGuard(type), clazz, ValidationType.EXACT_CLASS);

    }

    abstract SingleDynamicMethod getConstructorMethod(final String signature);

    private MethodHandle getAssignableGuard(final MethodType type) {

        return Guards.asType(assignableGuard, type);

    }

    private GuardedInvocation createGuardedDynamicMethodInvocation(final CallSiteDescriptor callSiteDescriptor,

            final LinkerServices linkerServices, final String methodName, final Map<String, DynamicMethod> methodMap){

        final MethodHandle inv = getDynamicMethodInvocation(callSiteDescriptor, linkerServices, methodName, methodMap);

        return inv == null ? null : new GuardedInvocation(inv, getClassGuard(callSiteDescriptor.getMethodType()));

    }

    private MethodHandle getDynamicMethodInvocation(final CallSiteDescriptor callSiteDescriptor,

            final LinkerServices linkerServices, final String methodName, final Map<String, DynamicMethod> methodMap) {

        final DynamicMethod dynaMethod = getDynamicMethod(methodName, methodMap);

        return dynaMethod != null ? dynaMethod.getInvocation(callSiteDescriptor, linkerServices) : null;

    }

    private DynamicMethod getDynamicMethod(final String methodName, final Map<String, DynamicMethod> methodMap) {

        final DynamicMethod dynaMethod = methodMap.get(methodName);

        return dynaMethod != null ? dynaMethod : getExplicitSignatureDynamicMethod(methodName, methodMap);

    }

    private SingleDynamicMethod getExplicitSignatureDynamicMethod(final String fullName,

            final Map<String, DynamicMethod> methodsMap) {

        // What's below is meant to support the "name(type, type, ...)" syntax that programmers can use in a method name

        // to manually pin down an exact overloaded variant. This is not usually required, as the overloaded method

        // resolution works correctly in almost every situation. However, in presence of many language-specific

        // conversions with a radically dynamic language, most overloaded methods will end up being constantly selected

        // at invocation time, so a programmer knowledgeable of the situation might choose to pin down an exact overload

        // for performance reasons.

        // Is the method name lexically of the form "name(types)"?

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

        if(fullName.charAt(lastChar) != ')') {

            return null;

        }

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

        if(openBrace == -1) {