/*

 * Copyright (c) 1998, 2019, 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 jit.graph;

import jdk.test.lib.Utils;

import nsk.share.TestFailure;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Random;

import java.util.StringTokenizer;

import java.util.Vector;

public final class Globals {

    public static int STATIC_LOOP = 0;

    public static int NUM_TEST_CLASSES = 7;

    public static long RANDOM_LOOP = 100;

    public static boolean VERBOSE = false;

    private static final Random indexGenerator = Utils.getRandomInstance();

    private static String[] ClassArray = null;

    private static Class[] ClassInstanceArray = null;

    private static int maxClassIndex = 0;

    private static String[] MethodName_Array = null;

    private static Method[] MethodInstance_Array = null;

    // Should be prime, so that odds of an incorrect verification reduced

    public static int[] MethodID_Array = null;

    public static synchronized void initialize(String testListPath) {

        File td = new File(testListPath);

        if (!td.exists()) {

            throw new Error("TESTBUG: File " + testListPath + " Not found");

        }

        if (!td.isFile()) {

            throw new Error("TESTBUG: " + testListPath + " Must be a File");

        }

        BufferedReader classList = null;

        try {

            try {

                classList = new BufferedReader(new FileReader(td));

            } catch (FileNotFoundException e) {

                throw new Error("TESTBUG: Error finding Classlist", e);

            }

            String line = null;

            try {

                line = classList.readLine();

            } catch (IOException e) {

                throw new Error("TESTBUG: Error reading Classlist", e);

            }

            try {

                // ClassArray.length;

                maxClassIndex = Math.abs(Integer.parseInt(line));

            } catch (NumberFormatException e) {

                throw new Error("TESTBUG: Error reading Classlist - first number must be number of methods defined", e);

            }

            ClassArray = new String[maxClassIndex];

            ClassInstanceArray = new Class[maxClassIndex];

            MethodName_Array = new String[maxClassIndex];

            MethodInstance_Array = new Method[maxClassIndex];

            MethodID_Array = new int[maxClassIndex];

            int i;

            for (i = 0; i < maxClassIndex; i++) {

                try {

                    line = classList.readLine();

                } catch (IOException e) {

                    throw new Error("TESTBUG: Error reading ClasslistFile: testListPath", e);

                }

                StringTokenizer lineTokens = new StringTokenizer(line, "\t ");

                if (lineTokens.countTokens() < 3) {

                    throw new Error("TESTBUG: ClasslistFile: unexpected line:" + line);

                } else {

                    ClassArray[i] = lineTokens.nextToken();

                    MethodName_Array[i] = lineTokens.nextToken();

                    MethodID_Array[i] = Integer.parseInt(lineTokens.nextToken());

                }

            }

            maxClassIndex = i;

        } finally {

            if (classList != null) {

                try {

                    classList.close();

                } catch (IOException e) {

                    throw new Error("can't close file", e);

                }

            }

        }

        if ((NUM_TEST_CLASSES < ClassArray.length) && (NUM_TEST_CLASSES > 0)) {

            maxClassIndex = NUM_TEST_CLASSES;

        } else {

            NUM_TEST_CLASSES = maxClassIndex;

        }

    }

    // does a binary search to find the index for the ID of a method

    private static int ID_BinSearch(int begin, int end, int ID) {

        if (end < begin) {

            return (-1);

        }

        int mid = (begin + end) / 2;

        int midvalue = MethodID_Array[mid];

        if (ID == midvalue) {

            return (mid);

        } else if (ID < midvalue) {

            return (ID_BinSearch(begin, mid - 1, ID));

        } else {

            return (ID_BinSearch(mid + 1, end, ID));

        }

    }

    // based off a static index, this function selects the method to be called

    public static MethodData returnNextStaticMethod(int Method_ID) {

        //int i = ID_BinSearch(0, MethodID_Array.length - 1, Method_ID);

        int i = ID_BinSearch(0, maxClassIndex - 1, Method_ID);

        return (nextStaticMethod((i == -1) ? 0 : i));

    }

    // this function randomly selects the next method to be called by the test class

    public static MethodData nextRandomMethod() {

        int i = indexGenerator.nextInt(maxClassIndex);

        return (nextStaticMethod(i));

    }

    private static MethodData nextStaticMethod(int i) {

        Class methodsClass = null;

        Method nextMethod = null;

        try {

            methodsClass = ClassInstanceArray[i];

            if (methodsClass == null) {

                methodsClass = Class.forName(ClassArray[i]);

                ClassInstanceArray[i] = methodsClass;

            }

            nextMethod = MethodInstance_Array[i];

            if (nextMethod == null) {

                nextMethod = methodsClass.getMethod(MethodName_Array[i],

                        Vector.class, Vector.class,  Long.class, Integer.class);

                // sum vector, ID vector, function depth, static function call depth

                MethodInstance_Array[i] = nextMethod;

            }

        } catch (ClassNotFoundException e) {

            throw new Error("TESTBUG Class: " + ClassArray[i] + " Not Found", e);

        } catch (NoSuchMethodException e) {

            throw new Error("TESTBUG Method: " + ClassArray[i] + "::" + MethodName_Array[i] + " Not Found", e);

        } catch (SecurityException e) {

            throw new Error("TESTBUG Security Exception Generated by " + ClassArray[i] + "::" + MethodName_Array[i], e);

        }

        return new MethodData(ClassArray[i], MethodName_Array[i], methodsClass, nextMethod, MethodID_Array[i]);

    }

    /* These two functions are used to verify that all function were called in the proper order */

    // called by "parent" function to add childs ID to vector

    public static void addFunctionIDToVector(int FunctionIndex, Vector IDVector) {

        IDVector.addElement(FunctionIndex);

    }

    // called by "child" to add Function Index to Vector

    public static void appendSumToSummationVector(int FunctionIndex, Vector SummationVector) {

        if (SummationVector.isEmpty()) {

            SummationVector.addElement((long) FunctionIndex);

        } else {

            SummationVector.addElement((Long) SummationVector.lastElement() + FunctionIndex);

        }

    }

    // This function calls a method based off of MethodData

    public static void callMethod(MethodData methodCallStr,

                                  Vector summation, Vector ID,

                                  Long numFcalls, Integer staticFcalls)

            throws InvocationTargetException {

        try {

            methodCallStr.nextMethod.invoke(methodCallStr.instance,

                    summation, ID, numFcalls, staticFcalls);

        } catch (IllegalAccessException e) {

            // should never happen with a valid testfile

            throw new TestFailure("Illegal Access Exception", e);

        }

    }

}