package eu.mikroskeem.utils.test.reflect;

import eu.mikroskeem.utils.reflect.Reflect;
import org.junit.Assert;
import org.junit.Test;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

import static org.objectweb.asm.Opcodes.*;
import static org.objectweb.asm.Opcodes.RETURN;

public class TestReflect {
    @Test
    public void testGetClass(){
        Assert.assertEquals(String.class, Reflect.getClass("java.lang.String"));
        Assert.assertNotEquals(String.class, Reflect.getClass("java.lang.Integer"));
    }

    @Test
    public void testClassFind(){
        Assert.assertTrue(Reflect.classExists("java.lang.String"));
        Assert.assertFalse(Reflect.classExists("foo.bar.baz.xyz"));
    }

    @Test
    public void testGetMethod(){
        Class reflectClass = Reflect.getClass("eu.mikroskeem.utils.reflect.Reflect");
        Method method = Reflect.getMethod(reflectClass, "getClass", String.class);
        Assert.assertNotNull(method);
        Method invalidMethod = Reflect.getMethod(reflectClass, "getClass", Integer.class);
        Assert.assertNull(invalidMethod);
    }

    @Test
    public void testInvokeMethod(){
        Class reflectClass = Reflect.getClass("eu.mikroskeem.utils.reflect.Reflect");
        Method method = Reflect.getMethod(reflectClass, "getClass", String.class);
        Class<?> resultClazz = (Class)Reflect.invokeMethod(method, null, "java.lang.String");
        Assert.assertEquals(String.class, resultClazz);
    }

    @Test
    public void testGetField(){
        Class reflectTestClass = Reflect.getClass("eu.mikroskeem.utils.test.reflect.ReflectionTestClass");
        Field foobarField = Reflect.getField(reflectTestClass, "FOOBAR");
        Assert.assertNotNull(foobarField);
        Field invalidField = Reflect.getField(reflectTestClass, "ROOMAZ");
        Assert.assertNull(invalidField);
    }

    @Test
    public void testReadField(){
        Class reflectTestClass = Reflect.getClass("eu.mikroskeem.utils.test.reflect.ReflectionTestClass");
        Field foobarField = Reflect.getField(reflectTestClass, "FOOBAR");
        String value = (String)Reflect.readField(foobarField, null);
        Assert.assertEquals("nope", value);
    }

    @Test
    public void testWriteField(){
        Class reflectTestClass = Reflect.getClass("eu.mikroskeem.utils.test.reflect.ReflectionTestClass");
        Field bazfed = Reflect.getField(reflectTestClass, "BAZFED");
        Reflect.writeField(bazfed, null, "no yeah man :(");
        String value = (String)Reflect.readField(bazfed, null);
        Assert.assertEquals("no yeah man :(", value);
    }

    @Test
    public void testSimpleReadField(){
        SimpleReflectionTestClass testClass = new SimpleReflectionTestClass();
        Assert.assertEquals("nope", Reflect.simpleReadField(testClass, "FOOBAR"));
    }

    @Test
    public void testSimpleWriteField(){
        SimpleReflectionTestClass testClass = new SimpleReflectionTestClass();
        Reflect.simpleWriteField(testClass, "FOOBAR", "yeah");
        Assert.assertEquals("yeah", Reflect.simpleReadField(testClass, "FOOBAR"));
    }

    @Test
    public void testClassLoading(){
        String className = "eu.mikroskeem.utils.test.reflect.GeneratedTestClass";
        String classNameInternal = className.replaceAll("\\.", "/");

        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
        cw.visit(
                V1_8,
                ACC_PUBLIC + ACC_SUPER,
                classNameInternal,
                null,
                Type.getInternalName(Object.class),
                null);
        FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_STATIC, "test", Type.getDescriptor(String.class), null, "hey");
        fv.visitEnd();
        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
        mv.visitVarInsn(ALOAD, 0);
        mv.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(Object.class), "<init>", "()V", false);
        mv.visitInsn(RETURN);
        mv.visitMaxs(0, 0);
        mv.visitEnd();
        cw.visitEnd();

        Class<?> generated = Reflect.defineClass(ClassLoader.getSystemClassLoader(), className, cw.toByteArray());
        Field testField = Reflect.getField(generated, "test");
        String testFieldContent = (String) Reflect.readField(testField, null);
        Assert.assertTrue(Reflect.classExists(className));
        Assert.assertEquals("hey", testFieldContent);
    }

    @Test
    public void testConstructing(){
        Assert.assertNotNull(Reflect.fastConstruct(
                DifferentConstructors.class,
                new Reflect.TypeWrapper(1, Integer.class),
                new Reflect.TypeWrapper(2, Integer.class),
                new Reflect.TypeWrapper(3, int.class),
                new Reflect.TypeWrapper(true, boolean.class)
        ));
        Assert.assertNotNull(Reflect.fastConstruct(
                DifferentConstructors.class,
                new Reflect.TypeWrapper("kek", String.class),
                new Reflect.TypeWrapper("kek", String.class)
        ));
    }
}