/*
 * Copyright (c) 2013, 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 nsk.jvmti.RedefineClasses.StressRedefine;
package nsk.jvmti.RedefineClasses;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;

import nsk.share.TestFailure;
import nsk.share.gc.GCTestBase;
import nsk.share.test.ExecutionController;
import nsk.share.test.Stresser;
import nsk.share.test.Tests;

import vm.share.InMemoryJavaCompiler;

/**
 * There is a data structure named "dictionary" in class BlockFreelist. It stores
 * information about free memory blocks for further reusing. Allocation of new block goes
 * from dictionary only if dictionary is fat enough. (At the moment of test creation this limit is 64K.)
 *
 * This tests stresses dictionary as other test metaspace/StressDictionary does, but instead of
 * failing classloading this test leverages redefineClass method from jvmti.
 */
public class StressRedefine extends GCTestBase {
    private static int staticMethodCallersNumber = 10;
    private static int nonstaticMethodCallersNumber = 10;
    private static int redefiningThreadsNumber = 40;
    private static double corruptingBytecodeProbability = .75;

    private static volatile Class<?> myClass;
    private static ExecutionController stresser;
    private static String[] args;

    // This is random generator used for generating seeds for other Randoms. Setting seed from command line sets seed for this random.
    static Random seedGenerator;

    static {
        try {
            System.loadLibrary("stressRedefine");
        } catch (UnsatisfiedLinkError e) {
            System.err.println("Could not load stressRedefine library");
            System.err.println("java.library.path:" +
                System.getProperty("java.library.path"));
            throw e;
        }
    }

    native static int makeRedefinition(int verbose, Class<?> redefClass, byte[] classBytes);

    public static void main(String[] args) {
        StressRedefine.args = args;
        Tests.runTest(new StressRedefine(), args);
    }

        @Override
        public void run() {
                seedGenerator = new Random(runParams.getSeed());
                GenerateSourceHelper.setRandom(new Random(seedGenerator.nextLong()));
        stresser = new Stresser(args);

        for (int i = 0; i < args.length; i++ ) {
                if ("-staticMethodCallersNumber".equals(args[i])) {
                        staticMethodCallersNumber = Integer.parseInt(args[i + 1]);
                } else if ("-nonstaticMethodCallersNumber".equals(args[i])) {
                        nonstaticMethodCallersNumber = Integer.parseInt(args[i + 1]);
                } else if ("-redefiningThreadsNumber".equals(args[i])) {
                        redefiningThreadsNumber = Integer.parseInt(args[i + 1]);
                } else if ("-corruptingBytecodeProbability".equals(args[i])) {
                        corruptingBytecodeProbability = Double.parseDouble(args[i + 1]);
                }
        }

        //Dynamic attach if required
        nsk.share.jvmti.JVMTITest.commonInit(args);

        new StressRedefine().runIt();
        }

    private static class StaticMethodCaller implements Runnable {
        private Random random;
        public StaticMethodCaller() {random = new Random(seedGenerator.nextLong());}

                @Override
                public void run() {
                        while (stresser.continueExecution()) {
                                try {
                                        Object res = myClass.getMethod(GenerateSourceHelper.STATIC_METHOD_NAME, double.class, int.class, Object.class).invoke(
                                                        null, random.nextDouble(), random.nextInt(), new Object()); // Just for fun we transfer parameters to method
                                } catch (IllegalArgumentException | InvocationTargetException
                                                | IllegalAccessException | NoSuchMethodException e) {
                                        //It's okay to get exception here since we are corrupting bytecode and can't expect class to work properly.
                                        System.out.println("Got expected exception: " + e.toString());
                                }
                        }
                }
    }

    private static class NonstaticMethodCaller implements Runnable {
        private Random random;
        public NonstaticMethodCaller() {random = new Random(seedGenerator.nextLong());}

        @Override
                public void run() {
                        while (stresser.continueExecution()) {
                                try {
                                        Object res = myClass.getMethod(GenerateSourceHelper.NONSTATIC_METHOD_NAME, double.class, int.class, Object.class).
                                                        invoke(myClass.newInstance(), random.nextDouble(), random.nextInt(), new Object()); // Just for fun we transfer parameters to method
                                } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
                                        //It's okay to get exception here since we are corrupting bytecode and can't expect class to work properly.
                                        System.out.println("Got expected exception: " + e.toString());
                                }
                        }
                }
    }

    private static class Worker implements Runnable {
        private Random random;
        public Worker() {random = new Random(seedGenerator.nextLong());}

                @Override
                public void run() {
                        while (stresser.continueExecution()) {
                                byte[] bytecode = generateAndCompile();
                                if (random.nextDouble() < corruptingBytecodeProbability) {
                                        bytecode[random.nextInt(bytecode.length)] = 42;
                                }
                                makeRedefinition(2, myClass, bytecode);
                        }
                }
    }

    private void runIt() {
        myClass = new DefiningClassLoader().defineClass(generateAndCompile());
        stresser.start(0);

        List<Thread> threads = new LinkedList<Thread>();
        for (int i = 0; i < staticMethodCallersNumber; i++) {
                threads.add(new Thread(new StaticMethodCaller()));
        }
        for (int i = 0; i < nonstaticMethodCallersNumber; i++) {
                threads.add(new Thread(new NonstaticMethodCaller()));
        }
        for (int i = 0; i < redefiningThreadsNumber; i++) {
                threads.add(new Thread(new Worker()));
        }

        for (Thread thread : threads) {
                thread.start();
        }
        for (Thread thread : threads) {
                try {
                        thread.join();
                } catch (InterruptedException e) {
                        throw new TestFailure("Thread " + Thread.currentThread() + " was interrupted:", e);
                }
        }
    }

    private static byte[] generateAndCompile() {
        Map<String, CharSequence> sources = new HashMap<String, CharSequence>();
        sources.put(GenerateSourceHelper.CLASS_NAME, GenerateSourceHelper.generateSource());
        return InMemoryJavaCompiler.compile(sources).values().iterator().next();
    }

        // Auxiliary classloader. Used only once at the beginning.
        private static class DefiningClassLoader extends URLClassLoader {
                public DefiningClassLoader() {
                        super(new URL[0]);
                }

                Class<?> defineClass(byte[] bytecode) {
                        return defineClass(null, bytecode, 0, bytecode.length);
                }
        }

}