/***
 * ASM performance test: measures the performances of asm package
 * Copyright (c) 2000-2011 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.objectweb.asm;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.verifier.structurals.ModifiedPass3bVerifier;
import org.objectweb.asm.commons.LocalVariablesSorter;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.analysis.Analyzer;
import org.objectweb.asm.tree.analysis.BasicValue;
import org.objectweb.asm.tree.analysis.SimpleVerifier;

import serp.bytecode.BCClass;
import serp.bytecode.BCMethod;
import serp.bytecode.Code;
import serp.bytecode.Project;

/**
 * @author Eric Bruneton
 * @author Peter Lawrey
 */
public abstract class ALLPerfTest {

    static boolean compute;

    static boolean computeFrames;

    static boolean skipDebug;

    static int repeats;

    static List<byte[]> classes = new ArrayList<byte[]>();

    static List<String> classNames = new ArrayList<String>();

    private static final int MAX_ITERATION_SEC = Integer.getInteger(
            "max.iteration.sec", 10).intValue();

    public static void main(final String[] args) throws IOException,
            InterruptedException {
        String clazz = System.getProperty("asm.test.class");
        List<String> jars = findFiles(System.getProperty("java.home"), ".jar");
        jars.addAll(findJars(File.pathSeparatorChar,
                System.getProperty("java.class.path")));
        repeats = Integer.getInteger("repeats", 3).intValue() + 1;

        Set<String> classesFound = new HashSet<String>();
        for (int i = 0; i < jars.size(); i++) {
            ZipFile zip;
            try {
                zip = new ZipFile(jars.get(i));
            } catch (IOException e) {
                System.err.println("Error openning " + jars.get(i));
                e.printStackTrace();
                continue;
            }

            Enumeration<? extends ZipEntry> entries = zip.entries();
            while (entries.hasMoreElements()) {
                ZipEntry e = entries.nextElement();
                String s = e.getName();
                if (s.endsWith(".class")) {
                    s = s.substring(0, s.length() - 6).replace('/', '.');
                    if (!classesFound.add(s)) {
                        continue;
                    }
                    if (clazz == null || s.indexOf(clazz) != -1) {
                        InputStream is = zip.getInputStream(e);
                        byte[] bytes = new ClassReader(is).b;
                        classes.add(bytes);
                        classNames.add(s);
                        is.close();
                        if (classes.size() % 2500 == 0) {
                            System.out.println("... searching, found "
                                    + classes.size() + " classes.");
                        }
                    }
                }
            }
            zip.close();
        }
        System.out.println("Found " + classes.size() + " classes.");

        RunTest nullBCELAdapt = new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) throws IOException {
                nullBCELAdapt(bytes);
            }
        };

        RunTest nullAspectjBCELAdapt = new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) throws IOException {
                nullAspectjBCELAdapt(bytes);
            }
        };

        RunTest nullJavassistAdapt = new RunTest() {
            ClassPool pool;

            @Override
            public void init() {
                pool = new ClassPool(null);
            }

            @Override
            public void test(byte[] bytes, int[] errors) throws Exception {
                nullJavassistAdapt(pool, bytes);
            }
        };

        RunTest nullSERPAdapt = new RunTest() {
            Project p;
            BCClass c;

            @Override
            public void init() {
                p = new Project();
                c = null;
            }

            @Override
            public void test(byte[] bytes, int[] errors) throws Exception {
                c = nullSERPAdapt(p, c, bytes);
            }
        };

        // get class info and deserialize tests

        runTestAll("get class info", "", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassReader cr = new ClassReader(bytes);
                cr.getAccess();
                cr.getClassName();
                cr.getSuperName();
                cr.getInterfaces();
            }
        });

        runTestAll("deserialize", "", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                new ClassReader(bytes).accept(new EmptyVisitor(), 0);
            }
        });

        runTest("deserialize", "tree package", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                new ClassReader(bytes).accept(new ClassNode(), 0);
            }
        });

        System.out.println();

        // deserialize and reserialize tests

        runTestAll("deserialize and reserialize", "", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassReader cr = new ClassReader(bytes);
                ClassWriter cw = new ClassWriter(0);
                cr.accept(cw, 0);
                cw.toByteArray();
            }
        });

        runTestAll("deserialize and reserialize", "copyPool", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassReader cr = new ClassReader(bytes);
                ClassWriter cw = new ClassWriter(cr, 0);
                cr.accept(cw, 0);
                cw.toByteArray();
            }
        });

        runTest("deserialize and reserialize", "tree package", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassWriter cw = new ClassWriter(0);
                ClassNode cn = new ClassNode();
                new ClassReader(bytes).accept(cn, 0);
                cn.accept(cw);
                cw.toByteArray();
            }
        });

        compute = false;
        computeFrames = false;

        runTest("deserialize and reserialize", "BCEL", nullBCELAdapt);

        runTest("deserialize and reserialize", "Aspectj BCEL",
                nullAspectjBCELAdapt);

        runTest("deserialize and reserialize", "Javassist", nullJavassistAdapt);

        runTest("deserialize and reserialize", "SERP", nullSERPAdapt);

        System.out.println();

        // deserialize and reserialize tests with computeMaxs

        runTest("deserialize and reserialize", "computeMaxs", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                new ClassReader(bytes).accept(cw, 0);
                cw.toByteArray();
            }
        });

        compute = true;
        computeFrames = false;

        runTest("deserialize and reserialize", "BCEL and computeMaxs",
                nullBCELAdapt);

        runTest("deserialize and reserialize", "Aspectj BCEL and computeMaxs",
                nullAspectjBCELAdapt);

        // misc. tests

        runTest("deserialize and reserialize", "LocalVariablesSorter",
                new RunTest() {
                    @Override
                    public void test(byte[] bytes, int[] errors) {
                        ClassWriter cw = new ClassWriter(0);
                        new ClassReader(bytes).accept(new ClassVisitor(
                                Opcodes.ASM4, cw) {

                            @Override
                            public MethodVisitor visitMethod(final int access,
                                    final String name, final String desc,
                                    final String signature,
                                    final String[] exceptions) {
                                return new LocalVariablesSorter(access, desc,
                                        cv.visitMethod(access, name, desc,
                                                signature, exceptions));
                            }
                        }, ClassReader.EXPAND_FRAMES);
                        cw.toByteArray();
                    }
                });

        // This test repeatedly tests the same classes as SimpleVerifier
        // actually calls Class.forName() on the class which fills the PermGen
        runTestSome("analyze", "SimpleVerifier", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassReader cr = new ClassReader(bytes);
                ClassNode cn = new ClassNode();
                cr.accept(cn, ClassReader.SKIP_DEBUG);
                List<MethodNode> methods = cn.methods;
                for (int k = 0; k < methods.size(); ++k) {
                    MethodNode method = methods.get(k);
                    Analyzer<?> a = new Analyzer<BasicValue>(
                            new SimpleVerifier());
                    try {
                        a.analyze(cn.name, method);
                    } catch (Throwable th) {
                        // System.err.println(th);
                        ++errors[0];
                    }
                }
            }
        });

        System.out.println();

        // deserialize and reserialize tests with computeFrames

        runTest("deserialize and reserialize", "computeFrames", new RunTest() {
            @Override
            public void test(byte[] bytes, int[] errors) {
                ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
                new ClassReader(bytes).accept(cw, 0);
                cw.toByteArray();
            }
        });

        // the BCEL+computeFrames tests must be done only at the end, because
        // after them other tests run very slowly, for some unknown reason
        // (memory usage?)
        compute = false;
        computeFrames = true;
        runTest("deserialize and reserialize", "BCEL and computeFrames",
                nullBCELAdapt);

        runTest("deserialize and reserialize",
                "Aspectj BCEL and computeFrames", nullAspectjBCELAdapt);
    }

    public static List<String> findFiles(String directory, String suffix) {
        List<String> matches = new ArrayList<String>();
        findFiles(matches, new File(directory), suffix);
        return matches;
    }

    static void findFiles(List<String> matches, File directory, String suffix) {
        File[] files = directory.listFiles();
        for (int i = 0; i < files.length; i++) {
            File file = files[i];
            if (file.isDirectory()) {
                findFiles(matches, file, suffix);
            } else if (file.getName().endsWith(suffix)) {
                matches.add(file.getAbsolutePath());
            }
        }
    }

    static abstract class RunTest {

        public void init() {
        }

        public abstract void test(byte[] bytes, int[] errors) throws Exception;
    }

    static void runTestAll(String testName, String with, RunTest runTest)
            throws InterruptedException {
        runTest0(1, true, testName, with, runTest);
    }

    static void runTest(String testName, String with, RunTest runTest)
            throws InterruptedException {
        runTest0(repeats - 1, false, testName, with, runTest);
    }

    static void runTestSome(String testName, String with, RunTest runTest)
            throws InterruptedException {
        runTest0(repeats - 1, true, testName, with, runTest);
    }

    private static void runTest0(int testSkip, boolean startAtZero,
            String testName, String with, RunTest runTest)
            throws InterruptedException {
        if (with.length() > 0) {
            with = " with " + with;
        }
        boolean skipBigClasses = with.contains("BCEL and computeFrames");
        int totalCount = 0;
        long totalSize = 0;
        long totalTime = 0;
        System.out.println("\nStarting " + testName + with + " test.");
        for (int i = 0; i < repeats; ++i) {
            runTest.init();
            long t = System.currentTimeMillis();
            int count = 0;
            long size = 0;
            int[] errors = { 0 };
            long longest = 0;
            int longestSize = 0;
            int skipped = 0;
            for (int j = startAtZero ? 0 : i; j < classes.size(); j += testSkip) {
                count++;
                byte[] b = classes.get(j);
                if (skipBigClasses && b.length > 16 * 1024) {
                    skipped++;
                    continue;
                }
                size += b.length;
                try {
                    long start = System.currentTimeMillis();
                    runTest.test(b, errors);
                    long end = System.currentTimeMillis();
                    long time = end - start;
                    if (longest < time) {
                        longest = time;
                        longestSize = b.length;
                    }
                    if (time > MAX_ITERATION_SEC * 1000 / 10) {
                        System.out.println("--- time to " + testName
                                + " the class " + classNames.get(j) + with
                                + " took " + time + " ms. bytes=" + b.length);
                    }
                    if (end - t > MAX_ITERATION_SEC * 1000) {
                        // System.out.println("Stopping iteration due to a
                        // longer run time.");
                        break;
                    }
                } catch (Exception ignored) {
                    errors[0]++;
                } catch (Throwable e) {
                    System.err.println(classNames.get(j) + ": " + e);
                    errors[0]++;
                }
            }
            t = System.currentTimeMillis() - t;
            String errorStr = errors[0] > 0 ? " (" + errors[0] + " errors)"
                    : "";
            String skippedStr = skipped == 0 ? ""
                    : " ("
                            + skipped
                            + " skipped as BCEL/computeFrames on >16K classes is very slow)";
            String longestStr = "";
            if (longest > 50) {
                longestStr = " the longest took " + longest + " ms ("
                        + longestSize + " bytes)";
            }
            if (i > 0) {
                System.out.println("- to " + testName + ' ' + count
                        + " classes" + with + " = " + t + " ms" + errorStr
                        + longestStr + skippedStr + '.');
                totalCount += count;
                totalSize += size;
                totalTime += t;
            }
        }
        System.out.println("Time to " + testName + ' ' + totalCount
                + " classes" + with + " = " + totalTime + " ms.\n"
                + "Processing rate = " + totalCount * 1000 / totalTime
                + " classes per sec (" + totalSize * 1000 / totalTime / 1024
                + " kB per sec).");
        System.gc();
        Thread.sleep(2500);
    }

    private static List<String> findJars(char pathSeparatorChar, String s) {
        List<String> ret = new ArrayList<String>();
        int start = 0;
        int pos = s.indexOf(pathSeparatorChar);
        while (pos >= 0) {
            String name = s.substring(start, pos);
            if (name.endsWith(".jar")) {
                ret.add(name);
            }
            start = pos + 1;
            pos = s.indexOf(pathSeparatorChar, start);
        }
        return ret;
    }

    static void nullBCELAdapt(final byte[] b) throws IOException {
        JavaClass jc = new ClassParser(new ByteArrayInputStream(b),
                "class-name").parse();
        ClassGen cg = new ClassGen(jc);
        ConstantPoolGen cp = cg.getConstantPool();
        Method[] ms = cg.getMethods();
        for (int k = 0; k < ms.length; ++k) {
            MethodGen mg = new MethodGen(ms[k], cg.getClassName(), cp);
            boolean lv = ms[k].getLocalVariableTable() == null;
            boolean ln = ms[k].getLineNumberTable() == null;
            if (lv) {
                mg.removeLocalVariables();
            }
            if (ln) {
                mg.removeLineNumbers();
            }
            mg.stripAttributes(skipDebug);
            InstructionList il = mg.getInstructionList();
            if (il != null) {
                InstructionHandle ih = il.getStart();
                while (ih != null) {
                    ih = ih.getNext();
                }
                if (compute) {
                    mg.setMaxStack();
                    mg.setMaxLocals();
                }
                if (computeFrames) {
                    ModifiedPass3bVerifier verif;
                    verif = new ModifiedPass3bVerifier(jc, k);
                    verif.do_verify();
                }
            }
            cg.replaceMethod(ms[k], mg.getMethod());
        }
        cg.getJavaClass().getBytes();
    }

    static void nullAspectjBCELAdapt(final byte[] b) throws IOException {
        org.aspectj.apache.bcel.classfile.JavaClass jc = new org.aspectj.apache.bcel.classfile.ClassParser(
                new ByteArrayInputStream(b), "class-name").parse();
        org.aspectj.apache.bcel.generic.ClassGen cg = new org.aspectj.apache.bcel.generic.ClassGen(
                jc);
        org.aspectj.apache.bcel.generic.ConstantPoolGen cp = cg
                .getConstantPool();
        org.aspectj.apache.bcel.classfile.Method[] ms = cg.getMethods();
        for (int k = 0; k < ms.length; ++k) {
            org.aspectj.apache.bcel.generic.MethodGen mg = new org.aspectj.apache.bcel.generic.MethodGen(
                    ms[k], cg.getClassName(), cp);
            boolean lv = ms[k].getLocalVariableTable() == null;
            boolean ln = ms[k].getLineNumberTable() == null;
            if (lv) {
                mg.removeLocalVariables();
            }
            if (ln) {
                mg.removeLineNumbers();
            }
            mg.stripAttributes(skipDebug);
            org.aspectj.apache.bcel.generic.InstructionList il = mg
                    .getInstructionList();
            if (il != null) {
                org.aspectj.apache.bcel.generic.InstructionHandle ih = il
                        .getStart();
                while (ih != null) {
                    ih = ih.getNext();
                }
                if (compute) {
                    mg.setMaxStack();
                    mg.setMaxLocals();
                }
                if (computeFrames) {
                    org.aspectj.apache.bcel.verifier.structurals.ModifiedPass3bVerifier verif = new org.aspectj.apache.bcel.verifier.structurals.ModifiedPass3bVerifier(
                            jc, k);
                    verif.do_verify();
                }
            }
            cg.replaceMethod(ms[k], mg.getMethod());
        }
        cg.getJavaClass().getBytes();
    }

    static void nullJavassistAdapt(ClassPool pool, final byte[] b)
            throws Exception {
        CtClass cc = pool.makeClass(new ByteArrayInputStream(b));
        CtMethod[] ms = cc.getDeclaredMethods();
        for (int j = 0; j < ms.length; ++j) {
            if (skipDebug) {
                // is there a mean to remove the debug attributes?
            }
            if (compute) {
                // how to force recomputation of maxStack and maxLocals?
            }
        }
        cc.toBytecode();
    }

    static BCClass nullSERPAdapt(Project p, BCClass c, final byte[] b)
            throws Exception {
        if (c != null) {
            p.removeClass(c);
        }
        c = p.loadClass(new ByteArrayInputStream(b));
        c.getDeclaredFields();
        BCMethod[] methods = c.getDeclaredMethods();
        for (int i = 0; i < methods.length; ++i) {
            Code code = methods[i].getCode(false);
            if (code != null) {
                while (code.hasNext()) {
                    code.next();
                }
                if (compute) {
                    code.calculateMaxStack();
                    code.calculateMaxLocals();
                }
            }
        }
        c.toByteArray();
        return c;
    }

    static class EmptyVisitor extends ClassVisitor {

        AnnotationVisitor av = new AnnotationVisitor(Opcodes.ASM4) {

            @Override
            public AnnotationVisitor visitAnnotation(String name, String desc) {
                return this;
            }

            @Override
            public AnnotationVisitor visitArray(String name) {
                return this;
            }
        };

        public EmptyVisitor() {
            super(Opcodes.ASM4);
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            return av;
        }

        @Override
        public FieldVisitor visitField(int access, String name, String desc,
                String signature, Object value) {
            return new FieldVisitor(Opcodes.ASM4) {

                @Override
                public AnnotationVisitor visitAnnotation(String desc,
                        boolean visible) {
                    return av;
                }
            };
        }

        @Override
        public MethodVisitor visitMethod(int access, String name, String desc,
                String signature, String[] exceptions) {
            return new MethodVisitor(Opcodes.ASM4) {

                @Override
                public AnnotationVisitor visitAnnotationDefault() {
                    return av;
                }

                @Override
                public AnnotationVisitor visitAnnotation(String desc,
                        boolean visible) {
                    return av;
                }

                @Override
                public AnnotationVisitor visitParameterAnnotation(
                        int parameter, String desc, boolean visible) {
                    return av;
                }
            };
        }
    }
}