/*
 * Copyright (c) 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 org.graalvm.compiler.core.test;

import java.lang.invoke.ConstantCallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;

import org.graalvm.compiler.nodes.util.GraphUtil;
import org.junit.Assert;
import org.junit.Test;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;

import jdk.vm.ci.code.BailoutException;
import jdk.vm.ci.meta.ResolvedJavaMethod;

/**
 * Unit tests derived from https://github.com/oracle/graal/pull/1690.
 */
public class GraphUtilOriginalValueTests extends CustomizedBytecodePatternTest {

    static class LinkedNode {
        LinkedNode next;
    }

    static class A extends LinkedNode {
    }

    static class B extends LinkedNode {
    }

    static class C extends LinkedNode {
    }

    public static Class<?> getLastClass(A a) {
        LinkedNode current = a;
        Class<?> currentKlass = null;
        while (current != null) {
            // This must not be folded to A.class
            currentKlass = current.getClass();

            current = current.next;
        }
        return currentKlass;
    }

    @Test
    public void testGetClass() {
        A a = new A();
        a.next = new B();

        test("getLastClass", a);
    }

    static final ConstantCallSite cs1 = init(A.class);
    static final ConstantCallSite cs2 = init(B.class);
    static final ConstantCallSite cs3 = init(C.class);

    static ConstantCallSite init(Class<?> c) {
        try {
            return new ConstantCallSite(MethodHandles.lookup().unreflectConstructor(c.getDeclaredConstructor()));
        } catch (Exception e) {
            throw new InternalError(e);
        }
    }

    public static boolean findTarget(MethodHandle key) {
        ConstantCallSite cs = cs1;
        while (cs != null) {
            if (cs.getTarget() == key) {
                return true;
            }
            if (cs == cs1) {
                cs = cs2;
            } else if (cs == cs2) {
                cs = cs3;
            } else {
                cs = null;
            }
        }
        return false;
    }

    @Test
    public void testGetTarget() {
        cs1.getTarget();
        cs2.getTarget();
        test("findTarget", cs3.getTarget());
    }

    @Override
    protected byte[] generateClass(String internalClassName) {
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
        cw.visit(52, ACC_SUPER | ACC_PUBLIC, internalClassName, null, "java/lang/Object", null);

        String getDescriptor = "(Ljava/lang/Object;)V";
        MethodVisitor m = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "unbalancedMonitors", getDescriptor, null, null);
        Label loopHead = new Label();
        Label end = new Label();
        m.visitCode();

        // @formatter:off
        /*
         * void unbalancedMonitors(Object o) {
         *     monitorenter(o);
         *     while (o.toString() != o) {
         *         monitorexit(o);
         *         o = o.toString();
         *     }
         * }
         */
        // @formatter:on

        m.visitVarInsn(ALOAD, 0);
        m.visitInsn(MONITORENTER);
        m.visitLabel(loopHead);
        m.visitVarInsn(ALOAD, 0);
        m.visitInsn(MONITOREXIT);
        m.visitVarInsn(ALOAD, 0);
        m.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "toString", "()Ljava/lang/String;", false);
        m.visitVarInsn(ALOAD, 0);
        m.visitJumpInsn(IF_ACMPEQ, end);
        m.visitVarInsn(ALOAD, 0);
        m.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "toString", "()Ljava/lang/String;", false);
        m.visitVarInsn(ASTORE, 0);
        m.visitJumpInsn(GOTO, loopHead);
        m.visitLabel(end);
        m.visitInsn(RETURN);
        m.visitMaxs(2, 2);
        m.visitEnd();

        cw.visitEnd();
        return cw.toByteArray();
    }

    /**
     * Tests that the use of {@link GraphUtil#originalValue} in parsing MONITOREXIT correctly
     * detects unbalanced monitors.
     */
    @Test
    public void testUnbalancedMonitors() throws ClassNotFoundException {
        Class<?> testClass = getClass("UnbalancedMonitors");
        ResolvedJavaMethod t1 = getResolvedJavaMethod(testClass, "unbalancedMonitors");
        try {
            parseForCompile(t1);
            Assert.fail("expected a " + BailoutException.class.getName());
        } catch (BailoutException e) {
            String msg = e.getMessage();
            Assert.assertTrue(msg, msg.contains("unbalanced monitors"));
        }
    }
}