/*

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

 */

/* @test

 * @summary unit tests for method handles which permute their arguments

 * @run testng/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest

 */

/* Examples of manual runs:

 * java -DPermuteArgsTest.{DRY_RUN=true,MAX_ARITY=253} test.java.lang.invoke.PermuteArgsTest

 * java -DPermuteArgsTest.{VERBOSE=true,MAX_ARITY=5} test.java.lang.invoke.PermuteArgsTest

 * java test.java.lang.invoke.PermuteArgsTest list3I[2,0,1] listJLJ[2,0,1]

 */

package test.java.lang.invoke;

import org.testng.*;

import org.testng.annotations.*;

import java.util.*;

import java.lang.reflect.*;

import java.lang.invoke.*;

import static java.lang.invoke.MethodHandles.*;

import static java.lang.invoke.MethodType.*;

public class PermuteArgsTest {

    private static final Class<?> CLASS = PermuteArgsTest.class;

    private static final int MAX_ARITY = Integer.getInteger(CLASS.getSimpleName()+".MAX_ARITY", 8);

    private static final boolean DRY_RUN = Boolean.getBoolean(CLASS.getSimpleName()+".DRY_RUN");

    private static final boolean VERBOSE = Boolean.getBoolean(CLASS.getSimpleName()+".VERBOSE") || DRY_RUN;

    static Object list2I(int x, int y) {

        return Arrays.asList(x, y);

    }

    static Object list3I(int x, int y, int z) {

        return Arrays.asList(x, y, z);

    }

    static Object list4I(int w, int x, int y, int z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object list2J(long x, long y) {

        return Arrays.asList(x, y);

    }

    static Object list3J(long x, long y, long z) {

        return Arrays.asList(x, y, z);

    }

    static Object list4J(long w, long x, long y, long z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object list2I2J(int w, int x, long y, long z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object list2J2I(long w, long x, int y, int z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object listLJJ(Object x, long y, long z) {

        return Arrays.asList(x, y, z);

    }

    static Object listJLJ(long x, Object y, long z) {

        return Arrays.asList(x, y, z);

    }

    static Object listJJL(long x, long y, Object z) {

        return Arrays.asList(x, y, z);

    }

    static Object listJLL(long x, Object y, Object z) {

        return Arrays.asList(x, y, z);

    }

    static Object listLJL(Object x, long y, Object z) {

        return Arrays.asList(x, y, z);

    }

    static Object listLLJ(Object x, Object y, long z) {

        return Arrays.asList(x, y, z);

    }

    static Object listJLLJ(long w, Object x, Object y, long z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object listLJJL(Object w, long x, long y, Object z) {

        return Arrays.asList(w, x, y, z);

    }

    static Object listI_etc(int... va) {

        ArrayList<Object> res = new ArrayList<>();

        for (int x : va)  res.add(x);

        return res;

    }

    static Object listIJL_etc(int x, long y, Object z, Object... va) {

        ArrayList<Object> res = new ArrayList<>();

        res.addAll(Arrays.asList(x, y, z));

        res.addAll(Arrays.asList(va));

        return res;

    }

    public static void main(String argv[]) throws Throwable {

        if (argv.length > 0) {

            for (String arg : argv) {

                // arg ::= name[n,...]

                int k = arg.indexOf('[');

                String mhName = arg.substring(0, k).trim();

                String permString = arg.substring(k);

                testOnePermutation(mhName, permString);

            }

            return;

        }

        new PermuteArgsTest().test();

    }

    static int testCases;

    @Test

    public void test() throws Throwable {

        testCases = 0;

        Lookup lookup = lookup();

        for (Method m : lookup.lookupClass().getDeclaredMethods()) {

            if (m.getName().startsWith("list") &&

                Modifier.isStatic(m.getModifiers())) {

                test(m.getName(), lookup.unreflect(m));

            }

        }

        System.out.println("ran a total of "+testCases+" test cases");

    }

    static int jump(int i, int min, int max) {

        if (i >= min && i <= max-1) {

            // jump faster

            int len = max-min;

            if (i < min + len/2)

                i = min + len/2;

            else

                i = max-1;

        }

        return i;

    }

    static void test(String name, MethodHandle mh) throws Throwable {

        if (VERBOSE)

            System.out.println("mh = "+name+" : "+mh+" { "

                               +Arrays.toString(junkArgs(mh.type().parameterArray())));

        int testCases0 = testCases;

        if (!mh.isVarargsCollector()) {

            // normal case

            testPermutations(mh);

        } else {

            // varargs case; add params up to MAX_ARITY

            MethodType mt = mh.type();

            int posArgs = mt.parameterCount() - 1;

            int arity0 = Math.max(3, posArgs);

            for (int arity = arity0; arity <= MAX_ARITY; arity++) {

                MethodHandle mh1;

                try {

                    mh1 = adjustArity(mh, arity);

                } catch (IllegalArgumentException ex) {

                    System.out.println("*** mh = "+name+" : "+mh+"; arity = "+arity+" => "+ex);

                    ex.printStackTrace(System.out);

                    break;  // cannot get this arity for this type

                }

                test("("+arity+")"+name, mh1);

                arity = jump(arity, arity0*2, MAX_ARITY);

            }

        }

        if (VERBOSE)

            System.out.println("ran "+(testCases - testCases0)+" test cases for "+name+" }");

    }

    static MethodHandle adjustArity(MethodHandle mh, int arity) {

        MethodType mt = mh.type();

        int posArgs = mt.parameterCount() - 1;

        Class<?> reptype = mt.parameterType(posArgs).getComponentType();

        MethodType mt1 = mt.dropParameterTypes(posArgs, posArgs+1);

        while (mt1.parameterCount() < arity) {

            Class<?> pt = reptype;

            if (pt == Object.class && posArgs > 0)

                // repeat types cyclically if possible:

                pt = mt1.parameterType(mt1.parameterCount() - posArgs);

            mt1 = mt1.appendParameterTypes(pt);

        }

        try {

            return mh.asType(mt1);

        } catch (WrongMethodTypeException | IllegalArgumentException ex) {

            throw new IllegalArgumentException("cannot convert to type "+mt1+" from "+mh, ex);

        }

    }

    static MethodHandle findTestMH(String name, int[] perm) throws ReflectiveOperationException {

        int arity = perm.length;

        Lookup lookup = lookup();

        for (Method m : lookup.lookupClass().getDeclaredMethods()) {

            if (m.getName().equals(name) &&

                Modifier.isStatic(m.getModifiers())) {

                MethodHandle mh = lookup.unreflect(m);

                int mhArity = mh.type().parameterCount();

                if (mh.isVarargsCollector()) {

                    if (mhArity-1 <= arity)

                        return adjustArity(mh, arity);

                } else if (mhArity == arity) {

                    return mh;

                }

            }

        }

        throw new RuntimeException("no such method for arity "+arity+": "+name);

    }

    static void testPermutations(MethodHandle mh) throws Throwable {

        HashSet<String> done = new HashSet<>();

        MethodType mt = mh.type();

        int[] perm = nullPerm(mt.parameterCount());

        final int MARGIN = (perm.length <= 10 ? 2 : 0);

        int testCases0 = testCases;

        for (int j = 0; j <= 1; j++) {

            int maxStart = perm.length-1;

            if (j != 0)  maxStart /= 2;

            for (int start = 0; start <= maxStart; start++) {

                int maxOmit = (maxStart - start) / 2;

                if (start != 0)  maxOmit = 2;

                if (j != 0)  maxOmit = 1;

                for (int omit = 0; omit <= maxOmit; omit++) {

                    int end = perm.length - omit;

                    if (end - start >= 2) {

                        //System.out.println("testPermutations"+Arrays.asList(start, end)+(j == 0 ? "" : " (reverse)"));

                        testPermutations(mh, perm, start, end, done);

                    }

                    omit = jump(omit, (start == 0 && j == 0 ? MARGIN : 0), maxOmit);

                }

                start = jump(start, (j == 0 ? MARGIN : 0), maxStart);

            }

            // do everything in reverse:

            reverse(perm, 0, perm.length);

        }

        switch (perm.length) {

        case 2: assert(testCases - testCases0 == 2); break;

        case 3: assert(testCases - testCases0 == 6); break;

        case 4: assert(testCases - testCases0 == 24); break;

        case 5: assert(testCases - testCases0 == 120); break;

        case 6: assert(testCases - testCases0 > 720/3); break;

        }

    }

    static void testPermutations(MethodHandle mh, int[] perm, int start, int end, Set<String> done) throws Throwable {

        if (end - start <= 1)  return;

        for (int j = 0; j <= 1; j++) {

            testRotations(mh, perm, start, end, done);

            if (end - start <= 2)  return;

            reverse(perm, start, end);

        }

        if (end - start <= 3)  return;

        int excess4 = (end - start) - 4;

        // composed rotations:

        int start2 = start + 1 + excess4/3;

        int end2   = end       - excess4/3;

        end2 = start2 + Math.min(start == 0 ? 4 : 3, end2 - start2);

        int skips = (perm.length+3)/5;

        for (int i = start; i < end; i++) {

            rotate(perm, start, end);

            if (skips > 1 && ((i-start) + (i-start)/7) % skips != 0)  continue;

            for (int j = 0; j <= 1; j++) {

                testPermutations(mh, perm, start2, end2, done);

                reverse(perm, start, end);

            }

        }

    }

    static void testRotations(MethodHandle mh, int[] perm, int start, int end, Set<String> done) throws Throwable {

        Object[] args = junkArgs(mh.type().parameterArray());

        for (int i = start; i < end; i++) {

            if (done.add(Arrays.toString(perm)))

                testOnePermutation(mh, perm, args);

            rotate(perm, start, end);

        }

    }

    static void testOnePermutation(MethodHandle mh, int[] perm, Object[] args) throws Throwable {

        MethodType mt = mh.type();

        MethodType pmt = methodType(mt.returnType(), unpermuteArgs(perm, mt.parameterArray(), Class[].class));

        if (VERBOSE)

            System.out.println(Arrays.toString(perm));

        testCases += 1;

        if (DRY_RUN)

            return;

        Object res = permuteArguments(mh, pmt, perm).invokeWithArguments(unpermuteArgs(perm, args));

        String str = String.valueOf(res);

        if (!Arrays.toString(args).equals(str)) {

            System.out.println(Arrays.toString(perm)+" "+str+" *** WRONG ***");

        }

    }

    // For reproducing failures:

    static void testOnePermutation(String mhName, String permString) throws Throwable {

        String s = permString;

        s = s.replace('[', ' ').replace(']', ' ').replace(',', ' ');  // easier to trim spaces

        s = s.trim();

        int[] perm = new int[s.length()];

        int arity = 0;

        while (!s.isEmpty()) {

            int k = s.indexOf(' ');

            if (k < 0)  k = s.length();

            perm[arity++] = Integer.parseInt(s.substring(0, k));

            s = s.substring(k).trim();

        }

        perm = Arrays.copyOf(perm, arity);

        testOnePermutation(mhName, perm);

    }

    static void testOnePermutation(String mhName, int[] perm) throws Throwable {

        MethodHandle mh = findTestMH(mhName, perm);

        System.out.println("mh = "+mhName+" : "+mh+" { "

                           +Arrays.toString(junkArgs(mh.type().parameterArray())));

        Object[] args = junkArgs(mh.type().parameterArray());

        testOnePermutation(mh, perm, args);

        System.out.println("}");

    }

    static Object[] junkArgs(Class<?>[] ptypes) {

        Object[] args = new Object[ptypes.length];

        for (int i = 0; i < ptypes.length; i++) {

            Class<?> pt = ptypes[i];

            Object arg;

            if (pt == Void.class)       arg = null;

            else if (pt == int.class)   arg = i + 101;

            else if (pt == long.class)  arg = i + 10_000_000_001L;

            else                        arg = "#" + (i + 1);

            args[i] = arg;

        }

        return args;

    }

    static int[] nullPerm(int len) {

        int[] perm = new int[len];

        for (int i = 0; i < len; i++)

            perm[i] = i;

        return perm;

    }

    static void rotate(int[] perm) {

        rotate(perm, 0, perm.length);

    }

    static void rotate(int[] perm, int start, int end) {

        int x = perm[end-1];

        for (int j = start; j < end; j++) {

            int y = perm[j]; perm[j] = x; x = y;

        }

    }

    static void reverse(int[] perm) {

        reverse(perm, 0, perm.length);

    }

    static void reverse(int[] perm, int start, int end) {

        int mid = start + (end - start)/2;

        for (int j = start; j < mid; j++) {

            int k = (end-1) - j;

            int x = perm[j]; perm[j] = perm[k]; perm[k] = x;

        }

    }

    // Permute the args according to the inverse of perm.

    static Object[] unpermuteArgs(int[] perm, Object[] args) {

        return unpermuteArgs(perm, args, Object[].class);

    }

    static <T> T[] unpermuteArgs(int[] perm, T[] args, Class<T[]> Tclass) {

        T[] res = Arrays.copyOf(new Object[0], perm.length, Tclass);

        for (int i = 0; i < perm.length; i++)

            res[perm[i]] = args[i];

        return res;

    }

}