/*

 * Copyright (c) 2016, 2018, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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 jdk.jfr.internal;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.List;

import java.util.StringJoiner;

import jdk.internal.org.objectweb.asm.ClassWriter;

import jdk.internal.org.objectweb.asm.Label;

import jdk.internal.org.objectweb.asm.MethodVisitor;

import jdk.internal.org.objectweb.asm.Opcodes;

import jdk.internal.org.objectweb.asm.Type;

import jdk.internal.org.objectweb.asm.commons.Method;

import jdk.jfr.Event;

import jdk.jfr.EventType;

import jdk.jfr.SettingControl;

import jdk.jfr.ValueDescriptor;

import jdk.jfr.internal.EventInstrumentation.FieldInfo;

import jdk.jfr.internal.EventInstrumentation.SettingInfo;

import jdk.jfr.internal.handlers.EventHandler;

final class EventHandlerCreator {

    // TODO:

    // How can we find out class version without loading a

    // class as resource in a privileged block and use ASM to inspect

    // the contents. Using '52' even though we know later versions

    // are available. The reason for this is compatibility aspects

    // with for example WLS.

    private static final int CLASS_VERSION = 52;

    // This is needed so a new EventHandler is automatically generated in MetadataRespoistory

    // if a user Event class is loaded using APPCDS/CDS.

    private static final String SUFFIX  = "_" + System.currentTimeMillis() + "-" + JVM.getJVM().getPid();

    private static final String FIELD_EVENT_TYPE = "platformEventType";

    private static final String FIELD_PREFIX_STRING_POOL = "stringPool";

    private final static Class<? extends EventHandler> eventHandlerProxy = EventHandlerProxyCreator.proxyClass;

    private final static Type TYPE_STRING_POOL = Type.getType(StringPool.class);

    private final static Type TYPE_EVENT_WRITER = Type.getType(EventWriter.class);

    private final static Type TYPE_PLATFORM_EVENT_TYPE = Type.getType(PlatformEventType.class);

    private final static Type TYPE_EVENT_HANDLER = Type.getType(eventHandlerProxy);

    private final static Type TYPE_SETTING_CONTROL = Type.getType(SettingControl.class);

    private final static Type TYPE_EVENT_TYPE = Type.getType(EventType.class);

    private final static Type TYPE_EVENT_CONTROL = Type.getType(EventControl.class);

    private final static String DESCRIPTOR_EVENT_HANDLER = "(" + Type.BOOLEAN_TYPE.getDescriptor() + TYPE_EVENT_TYPE.getDescriptor() + TYPE_EVENT_CONTROL.getDescriptor() + ")V";

    private final static Method METHOD_GET_EVENT_WRITER = new Method("getEventWriter", "()" + TYPE_EVENT_WRITER.getDescriptor());

    private final static Method METHOD_EVENT_HANDLER_CONSTRUCTOR = new Method("<init>", DESCRIPTOR_EVENT_HANDLER);

    private final static Method METHOD_RESET = new Method("reset", "()V");

    private final ClassWriter classWriter;

    private final String className;

    private final String internalClassName;

    private final List<SettingInfo> settingInfos;

    private final List<FieldInfo> fields;

    public EventHandlerCreator(long id, List<SettingInfo> settingInfos, List<FieldInfo> fields) {

        this.classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

        this.className = makeEventHandlerName(id);

        this.internalClassName = ASMToolkit.getInternalName(className);

        this.settingInfos = settingInfos;

        this.fields = fields;

    }

    public static String makeEventHandlerName(long id) {

        return eventHandlerProxy.getName() + id + SUFFIX;

    }

    public EventHandlerCreator(long id, List<SettingInfo> settingInfos, EventType type, Class<? extends Event> eventClass) {

        this(id, settingInfos, createFieldInfos(eventClass, type));

    }

    private static List<FieldInfo> createFieldInfos(Class<? extends Event> eventClass, EventType type) throws Error {

        List<FieldInfo> fieldInfos = new ArrayList<>();

        for (ValueDescriptor v : type.getFields()) {

            // Only value descriptors that are not fields on the event class.

            if (v != TypeLibrary.STACK_TRACE_FIELD && v != TypeLibrary.THREAD_FIELD) {

                String fieldName = PrivateAccess.getInstance().getFieldName(v);

                String fieldDescriptor = ASMToolkit.getDescriptor(v.getTypeName());

                Class<?> c = eventClass;

                String internalName = null;

                while (c != Event.class) {

                    try {

                        Field field = c.getDeclaredField(fieldName);

                        if (c == eventClass || !Modifier.isPrivate(field.getModifiers())) {

                            internalName = ASMToolkit.getInternalName(c.getName());

                            break;

                        }

                    } catch (NoSuchFieldException | SecurityException e) {

                        // ignore

                    }

                    c = c.getSuperclass();

                }

                if (internalName != null) {

                    fieldInfos.add(new FieldInfo(fieldName, fieldDescriptor, internalName));

                } else {

                    throw new InternalError("Could not locate field " + fieldName + " for event type" + type.getName());

                }

            }

        }

        return fieldInfos;

    }

    public Class<? extends EventHandler> makeEventHandlerClass() {

        buildClassInfo();

        buildConstructor();

        buildWriteMethod();

        byte[] bytes = classWriter.toByteArray();

        ASMToolkit.logASM(className, bytes);

        return SecuritySupport.defineClass(className, bytes, Event.class.getClassLoader()).asSubclass(EventHandler.class);

    }

    public static EventHandler instantiateEventHandler(Class<? extends EventHandler> handlerClass, boolean registered, EventType eventType, EventControl eventControl) throws Error {

        final Constructor<?> cc;

        try {

            cc = handlerClass.getDeclaredConstructors()[0];

        } catch (Exception e) {

            throw (Error) new InternalError("Could not get handler constructor for " + eventType.getName()).initCause(e);

        }

        // Users should not be allowed to create instances of the event handler

        // so we need to unlock it here.

        SecuritySupport.setAccessible(cc);

        try {

            List<SettingInfo> settingInfos = eventControl.getSettingInfos();

            Object[] arguments = new Object[3 + settingInfos.size()];

            arguments[0] = registered;

            arguments[1] = eventType;

            arguments[2] = eventControl;

            for (SettingInfo si : settingInfos) {

                arguments[si.index + 3] = si.settingControl;

            }

            return (EventHandler) cc.newInstance(arguments);

        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {

            throw (Error) new InternalError("Could not instantiate event handler for " + eventType.getName() + ". " + e.getMessage()).initCause(e);

        }

    }

    private void buildConstructor() {

        MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PRIVATE, METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), makeConstructorDescriptor(settingInfos), null, null);

        mv.visitVarInsn(Opcodes.ALOAD, 0); // this

        mv.visitVarInsn(Opcodes.ILOAD, 1); // registered

        mv.visitVarInsn(Opcodes.ALOAD, 2); // event type

        mv.visitVarInsn(Opcodes.ALOAD, 3); // event control

        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(eventHandlerProxy), METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), METHOD_EVENT_HANDLER_CONSTRUCTOR.getDescriptor(), false);

        for (SettingInfo si : settingInfos) {

            mv.visitVarInsn(Opcodes.ALOAD, 0); // this

            mv.visitVarInsn(Opcodes.ALOAD, si.index + 4); // Setting Control

            mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor());

        }

        // initialized string field writers

        int fieldIndex = 0;

        for (FieldInfo field : fields) {

            if (field.isString()) {

                mv.visitVarInsn(Opcodes.ALOAD, 0);

                mv.visitVarInsn(Opcodes.ALOAD, 0);

                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(eventHandlerProxy), "createStringFieldWriter", "()" + TYPE_STRING_POOL.getDescriptor(), false);

                mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor());

            }

            fieldIndex++;

        }

        mv.visitInsn(Opcodes.RETURN);

        mv.visitMaxs(0, 0);

        mv.visitEnd();

    }

    private void buildClassInfo() {

        String internalSuperName = ASMToolkit.getInternalName(eventHandlerProxy.getName());

        classWriter.visit(CLASS_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, internalClassName, null, internalSuperName, null);

        for (SettingInfo si : settingInfos) {

            classWriter.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor(), null, null);

        }

        int fieldIndex = 0;

        for (FieldInfo field : fields) {

            if (field.isString()) {

                classWriter.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, FIELD_PREFIX_STRING_POOL+ fieldIndex, TYPE_STRING_POOL.getDescriptor(), null, null);

            }

            fieldIndex++;

        }

    }

    private void visitMethod(final MethodVisitor mv, final int opcode, final Type type, final Method method) {

        mv.visitMethodInsn(opcode, type.getInternalName(), method.getName(), method.getDescriptor(), false);

    }

    private void buildWriteMethod() {

        int argIndex = 0; // // indexes the argument type array, the argument type array does not include 'this'

        int slotIndex = 1; // indexes the proper slot in the local variable table, takes type size into account, therefore sometimes argIndex != slotIndex

        int fieldIndex = 0;

        Method desc = ASMToolkit.makeWriteMethod(fields);

        Type[] argumentTypes = Type.getArgumentTypes(desc.getDescriptor());

        MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PUBLIC, desc.getName(), desc.getDescriptor(), null, null);

        mv.visitCode();

        Label start = new Label();

        Label endTryBlock = new Label();

        Label exceptionHandler = new Label();

        mv.visitTryCatchBlock(start, endTryBlock, exceptionHandler, "java/lang/Throwable");

        mv.visitLabel(start);

        visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER);

        // stack: [BW]

        mv.visitInsn(Opcodes.DUP);

        // stack: [BW], [BW]

        // write begin event

        mv.visitVarInsn(Opcodes.ALOAD, 0);

        // stack: [BW], [BW], [this]

        mv.visitFieldInsn(Opcodes.GETFIELD, TYPE_EVENT_HANDLER.getInternalName(), FIELD_EVENT_TYPE, TYPE_PLATFORM_EVENT_TYPE.getDescriptor());

        // stack: [BW], [BW], [BS]

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.BEGIN_EVENT.asASM());

        // stack: [BW], [integer]

        Label recursive = new Label();

        mv.visitJumpInsn(Opcodes.IFEQ, recursive);

        // stack: [BW]

        // write startTime

        mv.visitInsn(Opcodes.DUP);

        // stack: [BW], [BW]

        mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);

        // stack: [BW], [BW], [long]

        slotIndex += argumentTypes[argIndex++].getSize();

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM());

        // stack: [BW]

        fieldIndex++;

        // write duration

        mv.visitInsn(Opcodes.DUP);

        // stack: [BW], [BW]

        mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);

        // stack: [BW], [BW], [long]

        slotIndex += argumentTypes[argIndex++].getSize();

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM());

        // stack: [BW]

        fieldIndex++;

        // write eventThread

        mv.visitInsn(Opcodes.DUP);

        // stack: [BW], [BW]

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_EVENT_THREAD.asASM());

        // stack: [BW]

        // write stackTrace

        mv.visitInsn(Opcodes.DUP);

        // stack: [BW], [BW]

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_STACK_TRACE.asASM());

        // stack: [BW]

        // write custom fields

        while (fieldIndex < fields.size()) {

            mv.visitInsn(Opcodes.DUP);

            // stack: [BW], [BW]

            mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);

            // stack:[BW], [BW], [field]

            slotIndex += argumentTypes[argIndex++].getSize();

            FieldInfo field = fields.get(fieldIndex);

            if (field.isString()) {

                mv.visitVarInsn(Opcodes.ALOAD, 0);

                // stack:[BW], [BW], [field], [this]

                mv.visitFieldInsn(Opcodes.GETFIELD, this.internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor());

                // stack:[BW], [BW], [field], [string]

            }

            EventWriterMethod eventMethod = EventWriterMethod.lookupMethod(field);

            visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, eventMethod.asASM());

            // stack: [BW]

            fieldIndex++;

        }

        // stack: [BW]

        // write end event (writer already on stack)

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.END_EVENT.asASM());

        // stack [integer]

        // notified -> restart event write attempt

        mv.visitJumpInsn(Opcodes.IFEQ, start);

        // stack:

        mv.visitLabel(endTryBlock);

        Label end = new Label();

        mv.visitJumpInsn(Opcodes.GOTO, end);

        mv.visitLabel(exceptionHandler);

        // stack: [ex]

        mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/Throwable"});

        visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER);

        // stack: [ex] [BW]

        mv.visitInsn(Opcodes.DUP);

        // stack: [ex] [BW] [BW]

        Label rethrow = new Label();

        mv.visitJumpInsn(Opcodes.IFNULL, rethrow);

        // stack: [ex] [BW]

        mv.visitInsn(Opcodes.DUP);

        // stack: [ex] [BW] [BW]

        visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, METHOD_RESET);

        mv.visitLabel(rethrow);

        // stack:[ex] [BW]

        mv.visitFrame(Opcodes.F_SAME, 0, null, 2, new Object[] {"java/lang/Throwable", TYPE_EVENT_WRITER.getInternalName()});

        mv.visitInsn(Opcodes.POP);

        // stack:[ex]

        mv.visitInsn(Opcodes.ATHROW);

        mv.visitLabel(recursive);

        // stack: [BW]

        mv.visitFrame(Opcodes.F_SAME, 0, null, 1, new Object[] { TYPE_EVENT_WRITER.getInternalName()} );

        mv.visitInsn(Opcodes.POP);

        mv.visitLabel(end);

        // stack:

        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);

        mv.visitInsn(Opcodes.RETURN);

        mv.visitMaxs(0, 0);

        mv.visitEnd();

    }

    private static String makeConstructorDescriptor(List<SettingInfo> settingsInfos) {

        StringJoiner constructordescriptor = new StringJoiner("", "(", ")V");

        constructordescriptor.add(Type.BOOLEAN_TYPE.getDescriptor());

        constructordescriptor.add(Type.getType(EventType.class).getDescriptor());

        constructordescriptor.add(Type.getType(EventControl.class).getDescriptor());

        for (int i = 0; i < settingsInfos.size(); i++) {

            constructordescriptor.add(TYPE_SETTING_CONTROL.getDescriptor());

        }

        return constructordescriptor.toString();

    }

}