/*
 * Copyright (c) 2014, 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.
 *
 * 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 test.java.lang.invoke.MethodHandles;

import jdk.test.lib.TimeLimitedRunner;
import jdk.test.lib.Asserts;
import jdk.test.lib.Utils;
import test.java.lang.invoke.lib.CodeCacheOverflowProcessor;
import test.java.lang.invoke.lib.Helper;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/* @test
 * @library /java/lang/invoke/common /test/lib
 * @build jdk.test.lib.TimeLimitedRunner
 * @compile CatchExceptionTest.java
 * @run main/othervm -esa test.java.lang.invoke.MethodHandles.CatchExceptionTest
 * @key intermittent randomness
 */
public class CatchExceptionTest {
    private static final List<Class<?>> ARGS_CLASSES;
    protected static final int MAX_ARITY = Helper.MAX_ARITY - 1;

    static {
        Class<?> classes[] = {
                Object.class,
                long.class,
                int.class,
                byte.class,
                Integer[].class,
                double[].class,
                String.class,
        };
        ARGS_CLASSES = Collections.unmodifiableList(
                Helper.randomClasses(classes, MAX_ARITY));
    }

    private final TestCase testCase;
    private final int nargs;
    private final int argsCount;
    private final MethodHandle catcher;
    private int dropped;
    private MethodHandle thrower;

    public CatchExceptionTest(TestCase testCase, final boolean isVararg,
                              final int argsCount, final int catchDrops) {
        this.testCase = testCase;
        this.dropped = catchDrops;
        MethodHandle thrower = testCase.thrower;
        int throwerLen = thrower.type().parameterCount();
        List<Class<?>> classes;
        int extra = Math.max(0, argsCount - throwerLen);
        classes = getThrowerParams(isVararg, extra);
        this.argsCount = throwerLen + classes.size();
        thrower = Helper.addTrailingArgs(thrower, this.argsCount, classes);
        if (isVararg && argsCount > throwerLen) {
            MethodType mt = thrower.type();
            Class<?> lastParam = mt.parameterType(mt.parameterCount() - 1);
            thrower = thrower.asVarargsCollector(lastParam);
        }
        this.thrower = thrower;
        this.dropped = Math.min(this.argsCount, catchDrops);
        catcher = testCase.getCatcher(getCatcherParams());
        nargs = Math.max(2, this.argsCount);
    }

    public static void main(String[] args) throws Throwable {
        CodeCacheOverflowProcessor.runMHTest(CatchExceptionTest::test);
    }

    public static void test() throws Throwable {
        System.out.println("classes = " + ARGS_CLASSES);

        TestFactory factory = new TestFactory();
        long timeout = Helper.IS_THOROUGH ? 0L : Utils.adjustTimeout(Utils.DEFAULT_TEST_TIMEOUT);
        // subtract vm init time and reserve time for vm exit
        timeout *= 0.9;
        TimeLimitedRunner runner = new TimeLimitedRunner(timeout, 2.0d,
                () -> {
                    CatchExceptionTest test = factory.nextTest();
                    if (test != null) {
                        test.runTest();
                        return true;
                    }
                    return false;
                });
        for (CatchExceptionTest test : TestFactory.MANDATORY_TEST_CASES) {
            test.runTest();
        }
        runner.call();
    }

    private List<Class<?>> getThrowerParams(boolean isVararg, int argsCount) {
        return Helper.getParams(ARGS_CLASSES, isVararg, argsCount);
    }

    private List<Class<?>> getCatcherParams() {
        int catchArgc = 1 + this.argsCount - dropped;
        List<Class<?>> result = new ArrayList<>(
                thrower.type().parameterList().subList(0, catchArgc - 1));
        // prepend throwable
        result.add(0, testCase.throwableClass);
        return result;
    }

    private void runTest() {
        if (Helper.IS_VERBOSE) {
            System.out.printf("CatchException(%s, isVararg=%b argsCount=%d " +
                            "dropped=%d)%n",
                    testCase, thrower.isVarargsCollector(), argsCount, dropped);
        }

        Helper.clear();

        Object[] args = Helper.randomArgs(
                argsCount, thrower.type().parameterArray());
        Object arg0 = Helper.MISSING_ARG;
        Object arg1 = testCase.thrown;
        if (argsCount > 0) {
            arg0 = args[0];
        }
        if (argsCount > 1) {
            args[1] = arg1;
        }
        Asserts.assertEQ(nargs, thrower.type().parameterCount());
        if (argsCount < nargs) {
            Object[] appendArgs = {arg0, arg1};
            appendArgs = Arrays.copyOfRange(appendArgs, argsCount, nargs);
            thrower = MethodHandles.insertArguments(
                    thrower, argsCount, appendArgs);
        }
        Asserts.assertEQ(argsCount, thrower.type().parameterCount());

        MethodHandle target = MethodHandles.catchException(
                testCase.filter(thrower), testCase.throwableClass,
                testCase.filter(catcher));

        Asserts.assertEQ(thrower.type(), target.type());
        Asserts.assertEQ(argsCount, target.type().parameterCount());

        Object returned;
        try {
            returned = target.invokeWithArguments(args);
        } catch (Throwable ex) {
            if (CodeCacheOverflowProcessor.isThrowableCausedByVME(ex)) {
                // This error will be treated by CodeCacheOverflowProcessor
                // to prevent the test from failing because of code cache overflow.
                throw new Error(ex);
            }
            testCase.assertCatch(ex);
            returned = ex;
        }

        testCase.assertReturn(returned, arg0, arg1, dropped, args);
    }
}

class TestFactory {
    public static final List<CatchExceptionTest> MANDATORY_TEST_CASES = new ArrayList<>();

    private static final int MIN_TESTED_ARITY = 10;

    static {
        for (int[] args : new int[][]{
                {0, 0},
                {MIN_TESTED_ARITY, 0},
                {MIN_TESTED_ARITY, MIN_TESTED_ARITY},
                {CatchExceptionTest.MAX_ARITY, 0},
                {CatchExceptionTest.MAX_ARITY, CatchExceptionTest.MAX_ARITY},
        }) {
                MANDATORY_TEST_CASES.addAll(createTests(args[0], args[1]));
        }
    }

    private int count;
    private int args;
    private int dropArgs;
    private int currentMaxDrops;
    private int maxArgs;
    private int maxDrops;
    private int constructor;
    private int constructorSize;
    private boolean isVararg;

    public TestFactory() {
        if (Helper.IS_THOROUGH) {
            maxArgs = maxDrops = CatchExceptionTest.MAX_ARITY;
        } else {
            maxArgs = MIN_TESTED_ARITY
                    + Helper.RNG.nextInt(CatchExceptionTest.MAX_ARITY
                            - MIN_TESTED_ARITY)
                    + 1;
            maxDrops = MIN_TESTED_ARITY
                    + Helper.RNG.nextInt(maxArgs - MIN_TESTED_ARITY)
                    + 1;
            args = 1;
        }

        System.out.printf("maxArgs = %d%nmaxDrops = %d%n", maxArgs, maxDrops);
        constructorSize = TestCase.CONSTRUCTORS.size();
    }

    private static List<CatchExceptionTest> createTests(int argsCount,
            int catchDrops) {
        if (catchDrops > argsCount || argsCount < 0 || catchDrops < 0) {
            throw new IllegalArgumentException("argsCount = " + argsCount
                    + ", catchDrops = " + catchDrops
            );
        }
        List<CatchExceptionTest> result = new ArrayList<>(
                TestCase.CONSTRUCTORS.size());
        for (Supplier<TestCase> constructor : TestCase.CONSTRUCTORS) {
            result.add(new CatchExceptionTest(constructor.get(),
                    /* isVararg = */ true,
                    argsCount,
                    catchDrops));
            result.add(new CatchExceptionTest(constructor.get(),
                    /* isVararg = */ false,
                    argsCount,
                    catchDrops));
        }
        return result;
    }

    /**
     * @return next test from test matrix:
     * {varArgs, noVarArgs} x TestCase.rtypes x TestCase.THROWABLES x {1, .., maxArgs } x {0, .., maxDrops}
     */
    public CatchExceptionTest nextTest() {
        if (constructor < constructorSize) {
            return createTest();
        }
        constructor = 0;
        count++;
        if (!Helper.IS_THOROUGH && count > Helper.TEST_LIMIT) {
            System.out.println("test limit is exceeded");
            return null;
        }
        if (dropArgs <= currentMaxDrops) {
            if (dropArgs == 0) {
                if (Helper.IS_THOROUGH || Helper.RNG.nextBoolean()) {
                    ++dropArgs;
                    return createTest();
                } else if (Helper.IS_VERBOSE) {
                    System.out.printf(
                            "argsCount=%d : \"drop\" scenarios are skipped%n",
                            args);
                }
            } else {
                ++dropArgs;
                return createTest();
            }
        }

        if (args < maxArgs) {
            dropArgs = 0;
            currentMaxDrops = Math.min(args, maxDrops);
            ++args;
            return createTest();
        }
        return null;
    }

    private CatchExceptionTest createTest() {
        if (!Helper.IS_THOROUGH) {
            return new CatchExceptionTest(
                    TestCase.CONSTRUCTORS.get(constructor++).get(),
                    Helper.RNG.nextBoolean(), args, dropArgs);
        } else {
           if (isVararg) {
               isVararg = false;
               return new CatchExceptionTest(
                       TestCase.CONSTRUCTORS.get(constructor++).get(),
                       isVararg, args, dropArgs);
           } else {
               isVararg = true;
               return new CatchExceptionTest(
                       TestCase.CONSTRUCTORS.get(constructor).get(),
                       isVararg, args, dropArgs);
           }
        }
    }
}

class TestCase<T> {
    private static enum ThrowMode {
        NOTHING,
        CAUGHT,
        UNCAUGHT,
        ADAPTER
    }

    @SuppressWarnings("unchecked")
    public static final List<Supplier<TestCase>> CONSTRUCTORS;
    private static final MethodHandle FAKE_IDENTITY;
    private static final MethodHandle THROW_OR_RETURN;
    private static final MethodHandle CATCHER;

    static {
        try {
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            THROW_OR_RETURN = lookup.findStatic(
                    TestCase.class,
                    "throwOrReturn",
                    MethodType.methodType(Object.class, Object.class,
                            Throwable.class)
            );
            CATCHER = lookup.findStatic(
                    TestCase.class,
                    "catcher",
                    MethodType.methodType(Object.class, Object.class));
            FAKE_IDENTITY = lookup.findVirtual(
                    TestCase.class, "fakeIdentity",
                    MethodType.methodType(Object.class, Object.class));

        } catch (NoSuchMethodException | IllegalAccessException e) {
            throw new Error(e);
        }
        PartialConstructor[] constructors = {
                create(Object.class, Object.class::cast),
                create(String.class, Objects::toString),
                create(int[].class, x -> new int[]{Objects.hashCode(x)}),
                create(long.class,
                        x -> Objects.hashCode(x) & (-1L >>> 32)),
                create(void.class, TestCase::noop)};
        Throwable[] throwables = {
                new ClassCastException("testing"),
                new java.io.IOException("testing"),
                new LinkageError("testing")};
        List<Supplier<TestCase>> list = new ArrayList<>(constructors.length
                * throwables.length * ThrowMode.values().length);
        //noinspection unchecked
        for (PartialConstructor f : constructors) {
            for (ThrowMode mode : ThrowMode.values()) {
                for (Throwable t : throwables) {
                    list.add(f.apply(mode, t));
                }
            }
        }
        CONSTRUCTORS = Collections.unmodifiableList(list);
    }

    public final Class<T> rtype;
    public final ThrowMode throwMode;
    public final Throwable thrown;
    public final Class<? extends Throwable> throwableClass;
    /**
     * MH which takes 2 args (Object,Throwable), 1st is the return value,
     * 2nd is the exception which will be thrown, if it's supposed in current
     * {@link #throwMode}.
     */
    public final MethodHandle thrower;
    private final Function<Object, T> cast;
    protected MethodHandle filter;
    private int fakeIdentityCount;

    private TestCase(Class<T> rtype, Function<Object, T> cast,
            ThrowMode throwMode, Throwable thrown)
            throws NoSuchMethodException, IllegalAccessException {
        this.cast = cast;
        filter = MethodHandles.lookup().findVirtual(
                Function.class,
                "apply",
                MethodType.methodType(Object.class, Object.class))
                              .bindTo(cast);
        this.rtype = rtype;
        this.throwMode = throwMode;
        this.throwableClass = thrown.getClass();
        switch (throwMode) {
            case NOTHING:
                this.thrown = null;
                break;
            case ADAPTER:
            case UNCAUGHT:
                this.thrown = new Error("do not catch this");
                break;
            default:
                this.thrown = thrown;
        }

        MethodHandle throwOrReturn = THROW_OR_RETURN;
        if (throwMode == ThrowMode.ADAPTER) {
            MethodHandle fakeIdentity = FAKE_IDENTITY.bindTo(this);
            for (int i = 0; i < 10; ++i) {
                throwOrReturn = MethodHandles.filterReturnValue(
                        throwOrReturn, fakeIdentity);
            }
        }
        thrower = throwOrReturn.asType(MethodType.genericMethodType(2));
    }

    private static Void noop(Object x) {
        return null;
    }

    private static <T2> PartialConstructor create(
            Class<T2> rtype, Function<Object, T2> cast) {
        return (t, u) -> () -> {
            try {
                return new TestCase<>(rtype, cast, t, u);
            } catch (NoSuchMethodException | IllegalAccessException e) {
                throw new Error(e);
            }
        };
    }

    private static <T extends Throwable>
    Object throwOrReturn(Object normal, T exception) throws T {
        if (exception != null) {
            Helper.called("throwOrReturn/throw", normal, exception);
            throw exception;
        }
        Helper.called("throwOrReturn/normal", normal, exception);
        return normal;
    }

    private static <T extends Throwable>
    Object catcher(Object o) {
        Helper.called("catcher", o);
        return o;
    }

    public MethodHandle filter(MethodHandle target) {
        return MethodHandles.filterReturnValue(target, filter);
    }

    public MethodHandle getCatcher(List<Class<?>> classes) {
        return MethodHandles.filterReturnValue(Helper.AS_LIST.asType(
                        MethodType.methodType(Object.class, classes)),
                CATCHER
        );
    }

    @Override
    public String toString() {
        return "TestCase{" +
                "rtype=" + rtype +
                ", throwMode=" + throwMode +
                ", throwableClass=" + throwableClass +
                '}';
    }

    public String callName() {
        return "throwOrReturn/" +
                (throwMode == ThrowMode.NOTHING
                        ? "normal"
                        : "throw");
    }

    public void assertReturn(Object returned, Object arg0, Object arg1,
            int catchDrops, Object... args) {
        int lag = 0;
        if (throwMode == ThrowMode.CAUGHT) {
            lag = 1;
        }
        Helper.assertCalled(lag, callName(), arg0, arg1);

        if (throwMode == ThrowMode.NOTHING) {
            assertEQ(cast.apply(arg0), returned);
        } else if (throwMode == ThrowMode.CAUGHT) {
            List<Object> catchArgs = new ArrayList<>(Arrays.asList(args));
            // catcher receives an initial subsequence of target arguments:
            catchArgs.subList(args.length - catchDrops, args.length).clear();
            // catcher also receives the exception, prepended:
            catchArgs.add(0, thrown);
            Helper.assertCalled("catcher", catchArgs);
            assertEQ(cast.apply(catchArgs), returned);
        }
        Asserts.assertEQ(0, fakeIdentityCount);
    }

    private void assertEQ(T t, Object returned) {
        if (rtype.isArray()) {
            Asserts.assertEQ(t.getClass(), returned.getClass());
            int n = Array.getLength(t);
            Asserts.assertEQ(n, Array.getLength(returned));
            for (int i = 0; i < n; ++i) {
                Asserts.assertEQ(Array.get(t, i), Array.get(returned, i));
            }
        } else {
            Asserts.assertEQ(t, returned);
        }
    }

    private Object fakeIdentity(Object x) {
        System.out.println("should throw through this!");
        ++fakeIdentityCount;
        return x;
    }

    public void assertCatch(Throwable ex) {
        try {
            Asserts.assertSame(thrown, ex,
                    "must get the out-of-band exception");
        } catch (Throwable t) {
            ex.printStackTrace();
        }
    }

    public interface PartialConstructor
            extends BiFunction<ThrowMode, Throwable, Supplier<TestCase>> {
    }
}