/*
 * Copyright (c) 2011, 2021, 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 vm.mlvm.meth.share;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.lang.management.MemoryUsage;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.ManagementFactory;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.BiConsumer;

import jdk.test.lib.Platform;

import nsk.share.test.LazyIntArrayToString;
import nsk.share.test.TestUtils;
import vm.mlvm.meth.share.transform.v2.MHArrayEnvelopeTFPair;
import vm.mlvm.meth.share.transform.v2.MHCall;
import vm.mlvm.meth.share.transform.v2.MHCollectSpreadTF;
import vm.mlvm.meth.share.transform.v2.MHConstantTF;
import vm.mlvm.meth.share.transform.v2.MHDropTF;
import vm.mlvm.meth.share.transform.v2.MHDropTF2;
import vm.mlvm.meth.share.transform.v2.MHFilterRetValTF;
import vm.mlvm.meth.share.transform.v2.MHFilterTF;
import vm.mlvm.meth.share.transform.v2.MHFoldTF;
import vm.mlvm.meth.share.transform.v2.MHIdentityTF;
import vm.mlvm.meth.share.transform.v2.MHInsertTF;
import vm.mlvm.meth.share.transform.v2.MHMacroTF;
import vm.mlvm.meth.share.transform.v2.MHOutboundCallTF;
import vm.mlvm.meth.share.transform.v2.MHOutboundVirtualCallTF;
import vm.mlvm.meth.share.transform.v2.MHPermuteTF;
import vm.mlvm.meth.share.transform.v2.MHTF;
import vm.mlvm.meth.share.transform.v2.MHTFPair;
import vm.mlvm.meth.share.transform.v2.MHThrowCatchTFPair;
import vm.mlvm.meth.share.transform.v2.MHVarargsCollectSpreadTF;
import vm.mlvm.share.Env;

public class MHTransformationGen {

    public static final int MAX_CYCLES = 1000;

    private static final int MAX_ARGUMENTS = 10;

    private static final boolean FILTER_OUT_KNOWN_BUGS = false;

    private static final boolean USE_THROW_CATCH = false; // Test bugs

    /**
     * The class is used for periodical checks if a code-cache consuming operation
     * could be executed (i.e. if code cache has enought free space for a typical operation).
     */
    private static class CodeCacheMonitor {

        private static final Optional<MemoryPoolMXBean> NON_SEGMENTED_CODE_CACHE_POOL;
        private static final Optional<MemoryPoolMXBean> NON_NMETHODS_POOL;
        private static final Optional<MemoryPoolMXBean> PROFILED_NMETHODS_POOL;
        private static final Optional<MemoryPoolMXBean> NON_PROFILED_NMETHODS_POOL;

        // Trial runs show up that maximal increase in code cache consumption between checks (for one
        // cycle/tree build in MHTransformationGen::createSequence), falls within the following intervals:
        //
        // | Threads number | Without Xcomp | With Xcomp |
        // |----------------|---------------|------------|
        // |       1        |   100-200 K   |  400-500 K |
        // |      10        |    1 - 2 M    |    5-6 M   |
        //
        // Those numbers are approximate (since trees are generated randomly and the total consumption
        // between checks depends on how threads are aligned - for example, if all threads finish up their
        // cycles approximately at one time, the consumption increase will be the highest, like with a
        // resonance's amplitude)
        // The 10 threads is chosen as it is a typical number for multi-threaded tests.
        //
        // Based on these numbers, values of 10 M for Xcomp and 5 M for non-Xcomp, were suggested.
        private static final int NON_SEGMENTED_CACHE_ALLOWANCE = Platform.isComp() ? 10_000_000 : 5_000_000;
        private static final int SEGMENTED_CACHE_ALLOWANCE = Platform.isComp() ? 10_000_000 : 5_000_000;

        static {
            var pools = ManagementFactory.getMemoryPoolMXBeans();
            NON_SEGMENTED_CODE_CACHE_POOL = pools.stream()
                .filter(pool -> pool.getName().equals("CodeCache")).findFirst();
            NON_NMETHODS_POOL = pools.stream()
                .filter(pool -> pool.getName().equals("CodeHeap 'non-nmethods'")).findFirst();
            PROFILED_NMETHODS_POOL = pools.stream()
                .filter(pool -> pool.getName().equals("CodeHeap 'profiled nmethods'")).findFirst();
            NON_PROFILED_NMETHODS_POOL = pools.stream()
                .filter(pool -> pool.getName().equals("CodeHeap 'non-profiled nmethods'")).findFirst();
        }

        public static final boolean isCodeCacheEffectivelyFull() {
            var result = new Object() { boolean value = false; };

            BiConsumer<MemoryPoolMXBean, Integer> check = (pool, limit) -> {
                var usage = pool.getUsage();
                result.value |= usage.getMax() - usage.getUsed() < limit;
            };

            NON_SEGMENTED_CODE_CACHE_POOL.ifPresent(pool -> check.accept(pool, NON_SEGMENTED_CACHE_ALLOWANCE));
            NON_NMETHODS_POOL.ifPresent(pool -> check.accept(pool, SEGMENTED_CACHE_ALLOWANCE));
            PROFILED_NMETHODS_POOL.ifPresent(pool -> check.accept(pool, SEGMENTED_CACHE_ALLOWANCE));
            NON_PROFILED_NMETHODS_POOL.ifPresent(pool -> check.accept(pool, SEGMENTED_CACHE_ALLOWANCE));

            return result.value;
        }
    };

    public static class ThrowCatchTestException extends Throwable {
        private static final long serialVersionUID = -6749961303738648241L;
    }

    @SuppressWarnings("unused")
    public static MHMacroTF createSequence(Argument finalRetVal, Object boundObj, MethodHandle finalMH, Argument[] finalArgs) throws Throwable {
        Env.traceDebug("Generating sequence.");

        MHMacroTF graph = new MHMacroTF("sequence");

        MHTF outTF;
        if ( boundObj != null )
            outTF = new MHOutboundVirtualCallTF(finalRetVal, boundObj, finalMH, finalArgs);
        else
            outTF = new MHOutboundCallTF(finalRetVal, finalMH, finalArgs);

        Env.traceDebug("Outbound call=%s", outTF);
        graph.addTransformation(outTF);

        if ( MAX_CYCLES == 0 )
            return graph;

        List<MHTFPair> pendingPWTFs = new LinkedList<MHTFPair>();

        final int cyclesToBuild = nextInt(MAX_CYCLES);
        for ( int i = 0; i < cyclesToBuild; i++) {
            if (CodeCacheMonitor.isCodeCacheEffectivelyFull()) {
                Env.traceNormal("Not enought code cache to build up MH sequences anymore. " +
                        " Has only been able to achieve " + i + " out of " + cyclesToBuild);
                break;
            }

            MHCall lastCall = graph.computeInboundCall();
            Argument[] lastArgs = lastCall.getArgs();
            MethodType type = lastCall.getTargetMH().type();
            Argument lastRetVal = lastCall.getRetVal();

            int lastArgsSlots = computeVmSlotCount(lastArgs);
            if ( boundObj != null )
                lastArgsSlots += TestTypes.getSlotsCount(boundObj.getClass());

            Env.traceDebug("Current last call: %s", lastCall);

            MHTF tf = null;
            MHTFPair tfPair = null;

            int nextCase = nextInt(11);

            Env.traceDebug("Adding case #" + nextCase);
            try {
                switch ( nextCase ) {
                    case 0: { // add next pending TF
                        if ( pendingPWTFs.size() > 0 ) {
                            MHTFPair pwtf = pendingPWTFs.remove(0);
                            tf = pwtf.getInboundTF(lastCall);
                            Env.traceDebug("(adding pending inbound transformation)");
                        }
                    }
                    break;

                    case 1: { // Drop arguments
                        int pos = nextInt(lastArgs.length);
                        int nArgs = nextInt(MAX_ARGUMENTS);
                        if ( nArgs == 0 )
                            break;

                        Argument[] values = new Argument[nArgs];
                        for ( int j = 0; j < nArgs; j++ )
                            values[j] = RandomArgumentGen.next();

                        int valuesSlots = computeVmSlotCount(values);

                        int newValuesCount = nArgs;
                        while ( valuesSlots + lastArgsSlots > MAX_ARGUMENTS ) {
                            valuesSlots -= TestTypes.getSlotsCount(values[newValuesCount - 1].getType());
                            --newValuesCount;
                        }

                        if ( newValuesCount != nArgs )
                            values = Arrays.copyOf(values, newValuesCount);

                        if ( Env.getRNG().nextBoolean() )
                            tf = new MHDropTF(lastCall, pos, values);
                        else
                            tf = new MHDropTF2(lastCall, pos, values);
                    }
                    break;

                    case 2: { // Insert arguments
                        if ( lastArgs.length == 0 )
                            break;

                        int pos = nextInt(lastArgs.length);

                        int p;
                        for ( p = pos; p < pos + lastArgs.length; p++ ) {
                            if ( ! lastArgs[p % lastArgs.length].isPreserved() )
                                break;
                        }

                        pos = p % lastArgs.length;
                        if ( lastArgs[pos].isPreserved() )
                            break;

                        int nArgs = 1 + nextInt(lastArgs.length - pos - 1);

                        for ( p = pos + 1; p < pos + nArgs; p++ ) {
                            if ( lastArgs[p].isPreserved() )
                                break;
                        }

                        nArgs = p - pos;

                        Argument[] values = Arrays.copyOfRange(lastArgs, pos, pos + nArgs);

                        tf = new MHInsertTF(lastCall, pos, values, false);
                    }
                    break;

                    case 3: { // Throw + catch
                        if ( ! USE_THROW_CATCH )
                            break;

                        if ( lastArgsSlots + 1 >= MAX_ARGUMENTS )
                            break;

                        Argument testArg = RandomArgumentGen.next();
                        Env.traceDebug("testArgument=%s", testArg);

                        Object testValue2;
                        boolean eqTest = (Boolean) RandomValueGen.next(Boolean.class);
                        if ( eqTest ) {
                            testValue2 = testArg.getValue();
                        } else {
                            testValue2 = RandomValueGen.nextDistinct(testArg.getType(), testArg.getValue());
                        }

                        tfPair = new MHThrowCatchTFPair(lastCall, testArg, testValue2, eqTest, new ThrowCatchTestException());
                    }
                    break;

                    case 4: { // Permute arguments

                        List<Integer> targetArgNumbers = new LinkedList<Integer>();
                        for ( int n = 0;  n < lastArgs.length; n++ )
                            targetArgNumbers.add(n);
                        Collections.shuffle(targetArgNumbers, Env.getRNG());

                        Argument[] sourceArgs = new Argument[lastArgs.length];
                        for ( int n = 0; n < lastArgs.length; n++ ) {
                            sourceArgs[targetArgNumbers.get(n)] = lastArgs[n];
                        }

                        MethodType newMT = MethodType.methodType(type.returnType(), Arguments.typesArray(sourceArgs));

                        // Java has no other means for converting Integer[] to int[]
                        int[] permuteArray = new int[targetArgNumbers.size()];
                        for ( int n = 0; n < permuteArray.length; n++ )
                            permuteArray[n] = targetArgNumbers.get(n);

                        Env.traceDebug("Permute: permuteArray=%s; newMT=%s; oldMT=%s", new LazyIntArrayToString(permuteArray), newMT, lastCall.getTargetMH());

                        tf = new MHPermuteTF(lastCall, newMT, permuteArray);
                    }
                    break;

                    case 5: { // Fold arguments
                        if ( lastArgs.length == 0 )
                            break;

                        Argument arg = lastArgs[0];
                        if ( arg.isPreserved() )
                            break;

                        Argument[] restOfArgs = TestUtils.cdr(lastArgs);

                        MHMacroTF mTF = new MHMacroTF("fold arguments");
                        mTF.addOutboundCall(lastCall);

                        MHCall combinerCall = mTF.addTransformation(new MHDropTF(
                                mTF.addTransformation(new MHConstantTF(arg)),
                                0, restOfArgs
                        ));

                        Env.traceDebug("combinerCall=%s", combinerCall);
                        Env.traceDebug("targetCall=%s", lastCall);

                        mTF.addTransformation(new MHFoldTF(
                                lastCall,
                                combinerCall
                        ));

                        tf = mTF;
                    }
                    break;

                    case 6: { // Filter arguments
                        if ( lastArgs.length == 0 )
                            break;

                        int pos = nextInt(lastArgs.length);
                        int nArgs = 1 + nextInt(lastArgs.length - pos - 1);

                        MHMacroTF mTF = new MHMacroTF("identity filter arguments");
                        mTF.addOutboundCall(lastCall);

                        MHCall[] filters = new MHCall[nArgs];
                        for ( int n = 0; n < filters.length; n++ ) {
                            if ( nextInt(5) != 0 ) {
                                filters[n] = mTF.addTransformation(new MHIdentityTF(lastArgs[n + pos]));
                            }
                        }

                        mTF.addTransformation(new MHFilterTF(lastCall, pos, filters));

                        tf = mTF;
                    }
                    break;

                    case 7: { // filter
                        if ( lastArgs.length <= 1 )
                            break;

                        int pos = nextInt(lastArgs.length);
                        int nArgs;
                        if ( pos == lastArgs.length - 1 )
                            nArgs = 1;
                        else
                            nArgs = 1 + nextInt(lastArgs.length - pos - 1);

                        MHMacroTF mTF = new MHMacroTF("replace filter arguments");
                        mTF.addOutboundCall(lastCall);

                        MHCall[] filters = new MHCall[nArgs];

                        loop:
                        for ( int n = 0; n < nArgs; n++ ) {
                            Argument arg = lastArgs[pos + n];
                            if ( nextInt(5) == 0 || arg.isPreserved() )
                                continue;

                            Class<?> argType = arg.getType();
                            Object value = RandomValueGen.next(argType);
                            Argument newArg = new Argument(argType, value);

                            filters[n] = mTF.addTransformation(new MHDropTF(
                                             mTF.addTransformation(new MHConstantTF(arg)),
                                             0, new Argument[] { newArg }
                                         ));
                        }

                        mTF.addTransformation(new MHFilterTF(lastCall, pos, filters));

                        tf = mTF;
                    }
                    break;

                    case 8: { // Filter return value
                        if ( lastRetVal.isPreserved() )
                            break;

                        Class<?> lastRetType = lastRetVal.getType();
                        if ( lastRetType.equals(void.class) )
                            break;

                        Argument newRetVal = new Argument(lastRetType, RandomValueGen.next(lastRetType));

                        MHMacroTF mTF = new MHMacroTF("filter retval");
                        mTF.addOutboundCall(lastCall);
                        mTF.addTransformation(new MHFilterRetValTF(lastCall,
                                mTF.addTransformation(new MHDropTF(
                                            mTF.addTransformation(new MHConstantTF(newRetVal)),
                                            0,
                                            new Argument[] { lastRetVal }
                                ))
                        ));

                        tf = mTF;
                    }
                    break;

                    case 9: { // Envelope argument into array
                        if ( lastArgs.length >= 0 )
                            break;

                        int arraySize = 1 + nextInt(0xffff);
                        int arrayIdx = nextInt(arraySize);
                        int argNum = nextInt(lastArgs.length);
                        tfPair = new MHArrayEnvelopeTFPair(lastCall, argNum, arrayIdx, arraySize);
                    }
                    break;

                    case 10: { // Collect + spread
                        if ( nextInt(1) == 0 )
                            tf = new MHCollectSpreadTF(lastCall);
                        else
                            tf = new MHVarargsCollectSpreadTF(lastCall);
                    }
                    break;
                }

                if ( FILTER_OUT_KNOWN_BUGS ) {
                    if ( tfPair != null ) {
                        Env.traceDebug("Checking transformation pair %s", tfPair);

                        tfPair.getInboundTF(tfPair.getOutboundTF().computeInboundCall()).computeInboundCall();
                    } else if ( tf != null ) {
                        Env.traceDebug("Checking transformation %s", tf);
                        tf.computeInboundCall();
                    }
                }

            } catch ( Throwable e ) {
                if ( ! FILTER_OUT_KNOWN_BUGS )
                    throw e;

                String msg = e.getMessage();
                for ( Throwable t = e.getCause(); t != null; t = t.getCause() ) {
                    msg += " ";
                    msg += t.getMessage();
                }

                if ( msg != null
                  && ! msg.contains("NONE SO FAR 2011-07-10")
                   ) {
                    throw e;
                }

                Env.traceDebug("Failed to add transformation %s; Error: %s", tf, msg);
                tfPair = null;
                tf = null;
            }

            if ( tfPair != null ) {
                MHTF oTF = tfPair.getOutboundTF();
                Env.traceDebug("Adding outbound transformation %s", oTF);
                graph.addTransformation(oTF);
                pendingPWTFs.add(tfPair);
            } else if ( tf != null ) {
                Env.traceDebug("Adding transformation %s", tf);
                graph.addTransformation(tf);
            } else {
                Env.traceDebug("Skipping transformation");
            }
        }

        while ( pendingPWTFs.size() > 0 ) {
            MHTFPair pwtf = pendingPWTFs.remove(0);
            MHTF tf = pwtf.getInboundTF(graph.computeInboundCall());

            Env.traceDebug("Adding pending inbound transformation: %s", tf);
            graph.addTransformation(tf);
        }

        Env.traceVerbose("MHTransformationGen produced graph: %s", graph);

        return graph;
    }

    private static int computeVmSlotCount(Argument[] values) {
        int count = 0;
        for ( Argument v : values )
            count += TestTypes.getSlotsCount(v.getType());
        return count;
    }

    public static Object callSequence(MHMacroTF seq, boolean checkRetVal) throws Throwable {
        Env.traceVerbose("Calling sequence...");
        MHCall call = seq.computeInboundCall();
        Object result;
        try {
            if ( checkRetVal ) {
                result = call.callAndCheckRetVal();
            } else {
                result = call.call();
            }
        } catch ( Throwable t ) {
            Env.traceNormal(t, "Exception during calling a sequence");
            throw (Exception) (new Exception("Exception in sequence " + seq.toString()).initCause(t));
        }
        Env.traceVerbose("Sequence result = %s", result);
        return result;
    }

    public static Object createAndCallSequence(Argument finalRetVal, Object boundObj, MethodHandle finalMH, Argument[] finalArgs, boolean checkRetVal) throws Throwable {
        return callSequence(createSequence(finalRetVal, boundObj, finalMH, finalArgs), checkRetVal);
    }

    public static void transformToMatchArgsNum(MHMacroTF graph, int argNumMin, int argNumMax) throws Throwable {
        MHCall lastCall = graph.computeInboundCall();
        Argument[] lastArgs = lastCall.getArgs();

        if ( lastArgs.length > argNumMax ) {

            // TODO: preserved args
            MHTF tf = new MHInsertTF(lastCall, argNumMax, Arrays.copyOfRange(lastArgs, argNumMax, lastArgs.length), false);
            Env.traceVerbose("Adding transformation to match %d limit: %s", argNumMax, tf);
            graph.addTransformation(tf);

        } else if ( lastArgs.length < argNumMin ) {

            int argsToInsert = argNumMin - lastArgs.length;

            Argument[] values = new Argument[argsToInsert];
            for ( int j = 0; j < argsToInsert; j++ )
                values[j] = RandomArgumentGen.next();

            int pos = 0;

            MHTF tf = new MHDropTF(lastCall, pos, values);
            Env.traceVerbose("Adding transformation to match %d arguments: %s", argNumMin, tf);
            graph.addTransformation(tf);

        }
    }

    private static int nextInt(int i) {
        if ( i == 0 )
            return 0;
        else
            return Env.getRNG().nextInt(i);
    }
}