/*

 * Copyright (c) 2016, 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;

import jdk.internal.reflect.ReflectionFactory;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.security.AccessController;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.Map;

/**

 * A collection of most specific public methods. Methods are added to it using

 * {@link #merge(Method)} method. Only the most specific methods for a

 * particular signature are kept.

 */

final class PublicMethods {

    /**

     * a map of (method name, parameter types) -> linked list of Method(s)

     */

    private final Map<Key, MethodList> map = new LinkedHashMap<>();

    /**

     * keeps track of the number of collected methods

     */

    private int methodCount;

    /**

     * Merges new method with existing methods. New method is either

     * ignored (if a more specific method with same signature exists) or added

     * to the collection. When it is added to the collection, it may replace one

     * or more existing methods with same signature if they are less specific

     * than added method.

     * See comments in code...

     */

    void merge(Method method) {

        Key key = new Key(method);

        MethodList existing = map.get(key);

        int xLen = existing == null ? 0 : existing.length();

        MethodList merged = MethodList.merge(existing, method);

        methodCount += merged.length() - xLen;

        // replace if head of list changed

        if (merged != existing) {

            map.put(key, merged);

        }

    }

    /**

     * Dumps methods to array.

     */

    Method[] toArray() {

        Method[] array = new Method[methodCount];

        int i = 0;

        for (MethodList ml : map.values()) {

            for (; ml != null; ml = ml.next) {

                array[i++] = ml.method;

            }

        }

        return array;

    }

    /**

     * Method (name, parameter types) tuple.

     */

    private static final class Key {

        private static final ReflectionFactory reflectionFactory =

            AccessController.doPrivileged(

                new ReflectionFactory.GetReflectionFactoryAction());

        private final String name; // must be interned (as from Method.getName())

        private final Class<?>[] ptypes;

        Key(Method method) {

            name = method.getName();

            ptypes = reflectionFactory.getExecutableSharedParameterTypes(method);

        }

        static boolean matches(Method method,

                               String name, // may not be interned

                               Class<?>[] ptypes) {

            return method.getName().equals(name) &&

                   Arrays.equals(

                       reflectionFactory.getExecutableSharedParameterTypes(method),

                       ptypes

                   );

        }

        @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (!(o instanceof Key)) return false;

            Key that = (Key) o;

            //noinspection StringEquality (guaranteed interned String(s))

            return name == that.name &&

                   Arrays.equals(ptypes, that.ptypes);

        }

        @Override

        public int hashCode() {

            return System.identityHashCode(name) + // guaranteed interned String

                   31 * Arrays.hashCode(ptypes);

        }

    }

    /**

     * Node of a inked list containing Method(s) sharing the same

     * (name, parameter types) tuple.

     */

    static final class MethodList {

        Method method;

        MethodList next;

        private MethodList(Method method) {

            this.method = method;

        }

        /**

         * @return the head of a linked list containing given {@code methods}

         *         filtered by given method {@code name}, parameter types

         *         {@code ptypes} and including or excluding static methods as

         *         requested by {@code includeStatic} flag.

         */

        static MethodList filter(Method[] methods, String name,

                                 Class<?>[] ptypes, boolean includeStatic) {

            MethodList head = null, tail = null;

            for (Method method : methods) {

                if ((includeStatic || !Modifier.isStatic(method.getModifiers())) &&

                    Key.matches(method, name, ptypes)) {

                    if (tail == null) {

                        head = tail = new MethodList(method);

                    } else {

                        tail = tail.next = new MethodList(method);

                    }

                }

            }

            return head;

        }

        /**

         * This method should only be called with the {@code head} (possibly null)

         * of a list of Method(s) that share the same (method name, parameter types)

         * and another {@code methodList} that also contains Method(s) with the

         * same and equal (method name, parameter types) as the 1st list.

         * It modifies the 1st list and returns the head of merged list

         * containing only the most specific methods for each signature

         * (i.e. return type). The returned head of the merged list may or

         * may not be the same as the {@code head} of the given list.

         * The given {@code methodList} is not modified.

         */

        static MethodList merge(MethodList head, MethodList methodList) {

            for (MethodList ml = methodList; ml != null; ml = ml.next) {

                head = merge(head, ml.method);

            }

            return head;

        }

        private static MethodList merge(MethodList head, Method method) {

            Class<?> dclass = method.getDeclaringClass();

            Class<?> rtype = method.getReturnType();

            MethodList prev = null;

            for (MethodList l = head; l != null; l = l.next) {

                // eXisting method

                Method xmethod = l.method;

                // only merge methods with same signature:

                // (return type, name, parameter types) tuple

                // as we only keep methods with same (name, parameter types)

                // tuple together in one list, we only need to check return type

                if (rtype == xmethod.getReturnType()) {

                    Class<?> xdclass = xmethod.getDeclaringClass();

                    if (dclass.isInterface() == xdclass.isInterface()) {

                        // both methods are declared by interfaces

                        // or both by classes

                        if (dclass.isAssignableFrom(xdclass)) {

                            // existing method is the same or overrides

                            // new method - ignore new method

                            return head;

                        }

                        if (xdclass.isAssignableFrom(dclass)) {

                            // new method overrides existing

                            // method - knock out existing method

                            if (prev != null) {

                                prev.next = l.next;

                            } else {

                                head = l.next;

                            }

                            // keep iterating

                        } else {

                            // unrelated (should only happen for interfaces)

                            prev = l;

                            // keep iterating

                        }

                    } else if (dclass.isInterface()) {

                        // new method is declared by interface while

                        // existing method is declared by class -

                        // ignore new method

                        return head;

                    } else /* xdclass.isInterface() */ {

                        // new method is declared by class while

                        // existing method is declared by interface -

                        // knock out existing method

                        if (prev != null) {

                            prev.next = l.next;

                        } else {

                            head = l.next;

                        }

                        // keep iterating

                    }

                } else {

                    // distinct signatures

                    prev = l;

                    // keep iterating

                }

            }

            // append new method to the list

            if (prev == null) {

                head = new MethodList(method);

            } else {

                prev.next = new MethodList(method);

            }

            return head;

        }

        private int length() {

            int len = 1;

            for (MethodList ml = next; ml != null; ml = ml.next) {

                len++;

            }

            return len;

        }

        /**

         * @return 1st method in list with most specific return type

         */

        Method getMostSpecific() {

            Method m = method;

            Class<?> rt = m.getReturnType();

            for (MethodList ml = next; ml != null; ml = ml.next) {

                Method m2 = ml.method;

                Class<?> rt2 = m2.getReturnType();

                if (rt2 != rt && rt.isAssignableFrom(rt2)) {

                    // found more specific return type

                    m = m2;

                    rt = rt2;

                }

            }

            return m;

        }

    }

}