/**

 * Back 2 Browser Bytecode Translator

 * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 2 of the License.

 *

 * This program 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 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://opensource.org/licenses/GPL-2.0.

 */

package org.apidesign.bck2brwsr.vm8;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.lang.invoke.CallSite;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.reflect.Method;

import java.net.URL;

import java.util.Enumeration;

import org.apidesign.vm4brwsr.Bck2Brwsr;

import org.objectweb.asm.ClassReader;

import org.objectweb.asm.ClassVisitor;

import org.objectweb.asm.ClassWriter;

import org.objectweb.asm.Handle;

import org.objectweb.asm.MethodVisitor;

import org.objectweb.asm.Opcodes;

import static org.objectweb.asm.Opcodes.ASM4;

import static org.objectweb.asm.Opcodes.INVOKESTATIC;

import static org.testng.Assert.*;

import org.testng.annotations.AfterClass;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

/**

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

public class InvokeDynamicTest {

    private static Class<?> invokeDynamicClass;

    private static byte[] invokeDynamicBytes;

    private static TestVM code;

    @Test public void simpleDynamicInJava() throws Exception {

        Method m = invokeDynamicClass.getMethod("dynamicSay");

        Object ret = m.invoke(m);

        assertEquals(ret, "Hello from Dynamic!");

    }

    /* Well, supporting general invokeDynamic is 

    huge hassle, so giving up. More at

    http://wiki.apidesign.org/wiki/InvokeDynamic

    @Test public void simpleDynamicInJS() throws Exception {

        code().assertExec(

            "Invoke dynamic can return a value", InvokeDynamic.class,

            "dynamicSay__Ljava_lang_String_2",

            "Hello from Dynamic!"

        );

    }

    */

    private TestVM code() throws Exception {

        if (code == null) {

            final EmulResWithInvDyn emul = new EmulResWithInvDyn();

            code = TestVM.compileClass(

                    null, null, emul,

                    InvokeDynamic.class.getName().replace('.', '/')

            );

            assertTrue(emul.loaded, "InvokeDynamic class should be processed!");

        }

        return code;

    }

    @AfterClass

    public static void releaseTheCode() {

        code = null;

    }

    //

    // the following code is inspired by 

    // https://code.google.com/p/indy-maven-plugin/

    // which I don't want to use, as it is not in a public repository

    //

    @BeforeClass 

    public static void prepareClass() throws Exception {

        InputStream is = InvokeDynamic.class.getResourceAsStream("InvokeDynamic.class");

        assertNotNull(is, "Class found");

        ClassReader reader = new ClassReader(is) {

            @Override

            public short readShort(int index) {

                if (index == 6) {

                    return Opcodes.V1_7;

                }

                return super.readShort(index);

            }

        };

        ClassWriter writer = new ClassWriter(reader, 0);

        reader.accept(

                new ClassVisitor(ASM4, writer) {

                    @Override

                    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions

                    ) {

                        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);

                        return new InvokeDynamicProcessor(mv);

                    }

                },

                0);

        is.close();

        invokeDynamicBytes = writer.toByteArray();

        final boolean[] loaded = { false };

        ClassLoader l = new ClassLoader() {

            @Override

            public Class<?> loadClass(String name) throws ClassNotFoundException {

                if (name.equals(InvokeDynamic.class.getName())) {

                    loaded[0] = true;

                    return defineClass(name, invokeDynamicBytes, 0, invokeDynamicBytes.length);

                }

                return super.loadClass(name);

            }

        };

        invokeDynamicClass = l.loadClass(InvokeDynamic.class.getName());

        assertTrue(loaded[0], "InvokeDynamic class should be loaded!");

    }

    private static class InvokeDynamicProcessor extends MethodVisitor {

        InvokeDynamicProcessor(MethodVisitor mv) {

            super(ASM4, mv);

        }

        @Override

        public void visitMethodInsn(int opcode, String owner, String name, String desc) {

            if (opcode == INVOKESTATIC) {

                if (name.startsWith("TEST_dynamic_")) {

                    final String shortName = name.substring(13);

                    Handle mh = new Handle(

                        Opcodes.H_INVOKESTATIC, owner, shortName,

                        MethodType.methodType(

                            CallSite.class,

                            MethodHandles.Lookup.class,

                            String.class, 

                            MethodType.class

                        ).toMethodDescriptorString()

                    );

                    super.visitInvokeDynamicInsn(shortName, desc, mh);

                    return;

                }

            }

            super.visitMethodInsn(opcode, owner, name, desc);

        }

    }

    private static class EmulResWithInvDyn implements Bck2Brwsr.Resources {

        boolean loaded;

        @Override

        public InputStream get(String name) throws IOException {

            if ("org/apidesign/bck2brwsr/vm8/InvokeDynamic.class".equals(name)) {

                loaded = true;

                return new ByteArrayInputStream(invokeDynamicBytes);

            }

            Enumeration<URL> en = InvokeDynamicTest.class.getClassLoader().getResources(name);

            URL u = null;

            while (en.hasMoreElements()) {

                u = en.nextElement();

            }

            if (u == null) {

                throw new IOException("Can't find " + name);

            }

            if (u.toExternalForm().contains("rt.jar!")) {

                throw new IOException("No emulation for " + u);

            }

            return u.openStream();

        }

    }

}