/*

 * Copyright (c) 2009, 2019, 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 invokespecial;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

public class Checker extends shared.Checker {

    public Checker(Class staticTargetClass, Class dynamicTargetClass) {

        super(staticTargetClass, dynamicTargetClass);

    }

    public String check (Class callerClass) {

        // If objectref is null, the invokespecial instruction throws a NullPointerException.

        if (dynamicTargetClass == null) {

            return "java.lang.NullPointerException";

        }

        // TODO: find a citation from spec for this case

        Method resolvedMethod;

        try {

            // May throw VerifyError

            resolvedMethod = getMethodInHierarchy(staticTargetClass);

        } catch (Throwable e) {

            return e.getClass().getName();

        }

        if (resolvedMethod == null) {

            return "java.lang.NoSuchMethodError";

        }

       // If:

       //   - the resolved method is protected (4.7)

       //   - it is a member of a superclass of the current class

       //   - the method is not declared in the same run-time package (5.3) as the current class

       // then:

       //   the class of objectref must be either the current class or a subclass of the

       // current class.

        if (Modifier.isProtected(resolvedMethod.getModifiers())) {

            Method methodInSuperclass = getMethodInHierarchy(resolvedMethod.getDeclaringClass().getSuperclass());

            if (methodInSuperclass != null) {

                String resolvedMethodPkg = getClassPackageName(resolvedMethod.getDeclaringClass());

                String methodInSuperclassPkg = getClassPackageName(methodInSuperclass.getDeclaringClass());

                if (!resolvedMethodPkg.equals(methodInSuperclassPkg)) {

                    //TODO: clarify this

//                    if (callerClass == methodInSuperclass.getDeclaringClass()) {

//                        return "java.lang.IllegalAccessError";

//                    }

                }

            }

        }

       /*

        * The resolved method is selected for invocation unless all of

        * the following conditions are true:

        *     * TODO: The ACC_SUPER flag (see Table 4.1, "Class access and property

        *       modifiers") is set for the current class.

        *     * The class of the resolved method is a superclass of the

        *       current class - assumed by construction procedure

        *

        *     * The resolved method is not an instance initialization method (3.9).

        */

        if (!"<init>".equals(methodName)) {

           /*

            * Let C be the direct superclass of the current class:

            *    * If C contains a declaration for an instance method with the same

            *      name and descriptor as the resolved method, then this method will be

            *      invoked. The lookup procedure terminates.

            *    * Otherwise, if C has a superclass, this same lookup procedure is

            *      performed recursively using the direct superclass of C. The method to

            *      be invoked is the result of the recursive invocation of this lookup

            *      procedure.

            *    * Otherwise, an AbstractMethodError is raised.

            *      TODO: so far, sometimes NSME is thrown

            */

            Class klass = dynamicTargetClass.getSuperclass();

            while (klass != Object.class) {

                Method method = getDeclaredMethod(klass);

                if (method != null) {

                    /*

                     * If the resolved method is a class (static) method, the

                     * invokespecial instruction throws an IncompatibleClassChangeError.

                     */

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

                        return "java.lang.IncompatibleClassChangeError";

                    }

                    // Check access rights

                    if ( checkAccess(method, callerClass)

//                         && !(

//                                 Modifier.isProtected(method.getModifiers())

//                                 && (

//                                     staticTargetClass.isAssignableFrom(callerClass)

//                                     || getClassPackageName(staticTargetClass).equals(getClassPackageName(callerClass))

//                                    )

//

//                            )

                        )

                    {

                        return String.format("%s.%s"

                                , method.getDeclaringClass().getSimpleName()

                                , methodName

                                );

                    } else {

                        // IAE is thrown when located method can't be accessed from the call site

                        return "java.lang.IllegalAccessError";

                    }

                }

                klass = klass.getSuperclass();

            }

            return "java.lang.AbstractMethodError";

        } else {

            // The resolved method is an instance initialization method (3.9).

        }

        // TODO: change

        return "---";

    }

}