/*

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

 */

package java.lang.constant;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandleInfo;

import java.util.OptionalInt;

import java.util.stream.Stream;

import jdk.internal.vm.annotation.Stable;

import static java.lang.invoke.MethodHandleInfo.REF_getField;

import static java.lang.invoke.MethodHandleInfo.REF_getStatic;

import static java.lang.invoke.MethodHandleInfo.REF_invokeInterface;

import static java.lang.invoke.MethodHandleInfo.REF_invokeSpecial;

import static java.lang.invoke.MethodHandleInfo.REF_invokeStatic;

import static java.lang.invoke.MethodHandleInfo.REF_invokeVirtual;

import static java.lang.invoke.MethodHandleInfo.REF_newInvokeSpecial;

import static java.lang.invoke.MethodHandleInfo.REF_putField;

import static java.lang.invoke.MethodHandleInfo.REF_putStatic;

/**

 * A <a href="package-summary.html#nominal">nominal descriptor</a> for a direct

 * {@link MethodHandle}.  A {@linkplain DirectMethodHandleDesc} corresponds to

 * a {@code Constant_MethodHandle_info} entry in the constant pool of a classfile.

 *

 * @since 12

 */

public sealed interface DirectMethodHandleDesc

        extends MethodHandleDesc

        permits DirectMethodHandleDescImpl {

    /**

     * Kinds of method handles that can be described with {@linkplain DirectMethodHandleDesc}.

     *

     * @since 12

     */

    enum Kind {

        /** A method handle for a method invoked as with {@code invokestatic} */

        STATIC(REF_invokeStatic),

        /** A method handle for a method invoked as with {@code invokestatic} */

        INTERFACE_STATIC(REF_invokeStatic, true),

        /** A method handle for a method invoked as with {@code invokevirtual} */

        VIRTUAL(REF_invokeVirtual),

        /** A method handle for a method invoked as with {@code invokeinterface} */

        INTERFACE_VIRTUAL(REF_invokeInterface, true),

        /** A method handle for a method invoked as with {@code invokespecial} */

        SPECIAL(REF_invokeSpecial),

        /** A method handle for an interface method invoked as with {@code invokespecial} */

        INTERFACE_SPECIAL(REF_invokeSpecial, true),

        /** A method handle for a constructor */

        CONSTRUCTOR(REF_newInvokeSpecial),

        /** A method handle for a read accessor for an instance field  */

        GETTER(REF_getField),

        /** A method handle for a write accessor for an instance field  */

        SETTER(REF_putField),

        /** A method handle for a read accessor for a static field  */

        STATIC_GETTER(REF_getStatic),

        /** A method handle for a write accessor for a static field  */

        STATIC_SETTER(REF_putStatic);

        /** The corresponding {@code refKind} value for this kind of method handle,

         * as defined by {@link MethodHandleInfo}

         */

        public final int refKind;

        /** Is this an interface

         */

        public final boolean isInterface;

        Kind(int refKind) {

            this(refKind, false);

        }

        Kind(int refKind, boolean isInterface) { this.refKind = refKind; this.isInterface = isInterface; }

        /**

         * Returns the enumeration member with the given {@code refKind} field.

         * Behaves as if {@code valueOf(refKind, false)}.  As a special case,

         * if {@code refKind} is {@code REF_invokeInterface} (9) then the

         * {@code isInterface} field will be true.

         *

         * @param refKind refKind of desired member

         * @return the matching enumeration member

         * @throws IllegalArgumentException if there is no such member

         */

        public static Kind valueOf(int refKind) {

            return valueOf(refKind, refKind == REF_invokeInterface);

        }

        /**

         * Returns the enumeration member with the given the {@code refKind} and

         * {@code isInterface} arguments.

         * For most values of {@code refKind} there is an exact match regardless of the value of {@code isInterface}.

         * These are:

         * <UL>

         *     <LI>{@code REF_invokeVirtual} which matches to {@code VIRTUAL}

         *     <LI>{@code REF_invokeInterface} which matches to {@code INTERFACE_VIRTUAL}

         *     <LI>{@code REF_newInvokeSpecial} which matches to {@code CONSTRUCTOR}

         *     <LI>{@code REF_getField} which matches to {@code GETTER}

         *     <LI>{@code REF_putField} which matches to {@code SETTER}

         *     <LI>{@code REF_getStatic} which matches to {@code STATIC_GETTER}

         *     <LI>{@code REF_putStatic} which matches to {@code STATIC_SETTER}

         * </UL>

         * As for the rest, the returned kind will depend on the value (false or true accordingly) of {@code isInterface}:

         * <UL>

         *     <LI>{@code REF_invokeStatic} which matches to {@code STATIC} or {@code INTERFACE_STATIC}

         *     <LI>{@code REF_invokeSpecial} which matches to {@code SPECIAL} or {@code INTERFACE_SPECIAL}

         * </UL>

         * @param refKind refKind of desired member

         * @param isInterface whether desired member is for interface methods

         * @return the matching enumeration member

         * @throws IllegalArgumentException if there is no such member

         */

        public static Kind valueOf(int refKind, boolean isInterface) {

            int i = tableIndex(refKind, isInterface);

            if (i >= 2 && i < TABLE.length) {

                return TABLE[i];

            }

            throw new IllegalArgumentException(String.format("refKind=%d isInterface=%s", refKind, isInterface));

        }

        private static int tableIndex(int refKind, boolean isInterface) {

            if (refKind < 0)  return refKind;

            return (refKind * 2) + (isInterface ? 1 : 0);

        }

        private static final @Stable Kind[] TABLE;

        static {

            // Pack the static table.

            int max = 0;

            for (Kind k : values())

                max = Math.max(max, tableIndex(k.refKind, true));

            TABLE = new Kind[max+1];

            for (Kind kind : values()) {

                int i = tableIndex(kind.refKind, kind.isInterface);

                if (i >= TABLE.length || TABLE[i] != null)

                    throw new AssertionError("TABLE entry for " + kind);

                TABLE[i] = kind;

            }

            // Pack in some aliases also.

            int ii = tableIndex(REF_invokeInterface, false);

            if (TABLE[ii] != null)

                throw new AssertionError("TABLE entry for (invokeInterface, false) used by " + TABLE[ii]);

            TABLE[ii] = INTERFACE_VIRTUAL;

            for (Kind kind : values()) {

                if (!kind.isInterface) {

                    // Add extra cache entry to alias the isInterface case.

                    // For example, (REF_getStatic, X) will produce STATIC_GETTER

                    // for either truth value of X.

                    int i = tableIndex(kind.refKind, true);

                    if (TABLE[i] == null) {

                        TABLE[i] = kind;

                    }

                }

            }

        }

        /**

         * Does this {@code Kind} correspond to a virtual method invocation?

         *

         * @return if this {@code Kind} corresponds to a virtual method invocation

         */

        boolean isVirtualMethod() {

            switch (this) {

                case VIRTUAL:

                case SPECIAL:

                case INTERFACE_VIRTUAL:

                case INTERFACE_SPECIAL:

                    return true;

                default:

                    return false;

            }

        }

    }

    /**

     * Returns the {@code kind} of the method handle described by this nominal

     * descriptor.

     *

     * @return the {@link Kind}

     */

    Kind kind();

    /**

     * Returns the {@code refKind} of the method handle described by this nominal

     * reference, as defined by {@link MethodHandleInfo}.

     *

     * @return the reference kind

     */

    int refKind();

    /**

     * Indicates if the method is declared by an interface

     *

     * @return true if the method is declared by an interface

     */

    boolean isOwnerInterface();

    /**

     * Returns a {@link ClassDesc} describing the class declaring the

     * method or field described by this nominal descriptor.

     *

     * @return the class declaring the method or field

     */

    ClassDesc owner();

    /**

     * Returns the name of the method or field described by this nominal descriptor.

     * For constructors, returns the reserved name {@code "<init>"}.

     *

     * @return the name of the method or field

     */

    String methodName();

    /**

     * Returns the lookup descriptor of the method handle described by this descriptor,

     * after adjusting for the invocation mode.  This will correspond to either

     * a method type descriptor string (for methods and constructors), or a field

     * descriptor string (for field access method handles).  The lookup descriptor

     * string is in the same format as accepted by {@link MethodHandleDesc#of(Kind, ClassDesc, String, String)}.

     *

     * @return the lookup descriptor string

     */

    String lookupDescriptor();

}