/*

 * 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.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import jdk.jfr.AnnotationElement;

import jdk.jfr.Event;

import jdk.jfr.SettingControl;

import jdk.jfr.ValueDescriptor;

/**

 * Internal data structure that describes a type,

 *

 * Used to create event types, value descriptor and annotations.

 *

 */

public class Type implements Comparable<Type> {

    public static final String SUPER_TYPE_ANNOTATION = java.lang.annotation.Annotation.class.getName();

    public static final String SUPER_TYPE_SETTING = SettingControl.class.getName();

    public static final String SUPER_TYPE_EVENT = Event.class.getName();

    public static final String EVENT_NAME_PREFIX = "jdk.";

    public static final String TYPES_PREFIX = "jdk.types.";

    public static final String SETTINGS_PREFIX = "jdk.settings.";

    // Initialization of known types

    private final static Map<Type, Class<?>> knownTypes = new HashMap<>();

    static final Type BOOLEAN = register(boolean.class, new Type("boolean", null, 4));

    static final Type CHAR = register(char.class, new Type("char", null, 5));

    static final Type FLOAT = register(float.class, new Type("float", null, 6));

    static final Type DOUBLE = register(double.class, new Type("double", null, 7));

    static final Type BYTE = register(byte.class, new Type("byte", null, 8));

    static final Type SHORT = register(short.class, new Type("short", null, 9));

    static final Type INT = register(int.class, new Type("int", null, 10));

    static final Type LONG = register(long.class, new Type("long", null, 11));

    static final Type CLASS = register(Class.class, new Type("java.lang.Class", null, 20));

    static final Type STRING = register(String.class, new Type("java.lang.String", null, 21));

    static final Type THREAD = register(Thread.class, new Type("java.lang.Thread", null, 22));

    static final Type STACK_TRACE = register(null, new Type(TYPES_PREFIX + "StackTrace", null, 23));

    private final AnnotationConstruct annos = new AnnotationConstruct();

    private final String name;

    private final String superType;

    private final boolean constantPool;

    private List<ValueDescriptor> fields = new ArrayList<>();

    private Boolean simpleType; // calculated lazy

    private boolean remove = true;

    private long id;

    /**

     * Creates a type

     *

     * @param javaTypeName i.e "java.lang.String"

     * @param superType i.e "java.lang.Annotation"

     * @param id the class id that represents the class in the JVM

     *

     */

    public Type(String javaTypeName, String superType, long typeId) {

        this(javaTypeName, superType, typeId, false);

    }

    Type(String javaTypeName, String superType, long typeId, boolean contantPool) {

        this(javaTypeName, superType, typeId, contantPool, null);

    }

    Type(String javaTypeName, String superType, long typeId, boolean contantPool, Boolean simpleType) {

        Objects.requireNonNull(javaTypeName);

        if (!isValidJavaIdentifier(javaTypeName)) {

            throw new IllegalArgumentException(javaTypeName + " is not a valid Java identifier");

        }

        this.constantPool = contantPool;

        this.superType = superType;

        this.name = javaTypeName;

        this.id = typeId;

        this.simpleType = simpleType;

    }

    static boolean isDefinedByJVM(long id) {

        return id < JVM.RESERVED_CLASS_ID_LIMIT;

    }

    public static long getTypeId(Class<?> clazz) {

        Type type = Type.getKnownType(clazz);

        return type == null ? JVM.getJVM().getTypeId(clazz) : type.getId();

    }

    static Collection<Type> getKnownTypes() {

        return knownTypes.keySet();

    }

    public static boolean isValidJavaIdentifier(String identifier) {

        if (identifier.isEmpty()) {

            return false;

        }

        if (!Character.isJavaIdentifierStart(identifier.charAt(0))) {

            return false;

        }

        for (int i = 1; i < identifier.length(); i++) {

            char c = identifier.charAt(i);

            if (c != '.') {

                if (!Character.isJavaIdentifierPart(c)) {

                    return false;

                }

            }

        }

        return true;

    }

    public static boolean isValidJavaFieldType(String name) {

        for (Map.Entry<Type, Class<?>> entry : knownTypes.entrySet()) {

            Class<?> clazz = entry.getValue();

            if (clazz != null && name.equals(clazz.getName())) {

                return true;

            }

        }

        return false;

    }

    public static Type getKnownType(String typeName) {

        for (Type type : knownTypes.keySet()) {

            if (type.getName().equals(typeName)) {

                return type;

            }

        }

        return null;

    }

    static boolean isKnownType(Class<?> type) {

        if (type.isPrimitive()) {

            return true;

        }

        if (type.equals(Class.class) || type.equals(Thread.class) || type.equals(String.class)) {

            return true;

        }

        return false;

    }

    public static Type getKnownType(Class<?> clazz) {

        for (Map.Entry<Type, Class<?>> entry : knownTypes.entrySet()) {

            if (clazz != null && clazz.equals(entry.getValue())) {

                return entry.getKey();

            }

        }

        return null;

    }

    public String getName() {

        return name;

    }

    public String getLogName() {

       return getName() + "(" + getId() + ")";

    }

    public List<ValueDescriptor> getFields() {

        if (fields instanceof ArrayList) {

            ((ArrayList<ValueDescriptor>) fields).trimToSize();

            fields = Collections.unmodifiableList(fields);

        }

        return fields;

    }

    public boolean isSimpleType() {

        if (simpleType == null) {

            simpleType = calculateSimpleType();

        }

        return simpleType.booleanValue();

    }

    private boolean calculateSimpleType() {

        if (fields.size() != 1) {

            return false;

        }

        // annotation, settings and event can never be simple types

        return superType == null;

    }

    public boolean isDefinedByJVM() {

        return id < JVM.RESERVED_CLASS_ID_LIMIT;

    }

    private static Type register(Class<?> clazz, Type type) {

        knownTypes.put(type, clazz);

        return type;

    }

    public void add(ValueDescriptor valueDescriptor) {

        Objects.requireNonNull(valueDescriptor);

        fields.add(valueDescriptor);

    }

    void trimFields() {

        getFields();

    }

    void setAnnotations(List<AnnotationElement> annotations) {

        annos.setAnnotationElements(annotations);

    }

    public String getSuperType() {

        return superType;

    }

    public long getId() {

        return id;

    }

    public boolean isConstantPool() {

        return constantPool;

    }

    public String getLabel() {

        return annos.getLabel();

    }

    public List<AnnotationElement> getAnnotationElements() {

        return annos.getUnmodifiableAnnotationElements();

    }

    public <T> T getAnnotation(Class<? extends java.lang.annotation.Annotation> clazz) {

        return annos.getAnnotation(clazz);

    }

    public String getDescription() {

        return annos.getDescription();

    }

    @Override

    public int hashCode() {

        return Long.hashCode(id);

    }

    @Override

    public boolean equals(Object object) {

        if (object instanceof Type) {

            Type that = (Type) object;

            return that.id == this.id;

        }

        return false;

    }

    @Override

    public int compareTo(Type that) {

        return Long.compare(this.id, that.id);

    }

    void log(String action, LogTag logTag, LogLevel level) {

        if (Logger.shouldLog(logTag, level) && !isSimpleType()) {

            Logger.log(logTag, LogLevel.TRACE, action + " " + typeText() + " " + getLogName() + " {");

            for (ValueDescriptor v : getFields()) {

                String array = v.isArray() ? "[]" : "";

                Logger.log(logTag, LogLevel.TRACE, "  " + v.getTypeName() + array + " " + v.getName() + ";");

            }

            Logger.log(logTag, LogLevel.TRACE, "}");

        } else {

            if (Logger.shouldLog(logTag, LogLevel.INFO) && !isSimpleType()) {

                Logger.log(logTag, LogLevel.INFO, action + " " + typeText() + " " + getLogName());

            }

        }

    }

    private String typeText() {

        if (this instanceof PlatformEventType) {

            return "event type";

        }

        if (Type.SUPER_TYPE_SETTING.equals(superType)) {

            return "setting type";

        }

        if (Type.SUPER_TYPE_ANNOTATION.equals(superType)) {

            return "annotation type";

        }

        return "type";

    }

    @Override

    public String toString() {

        StringBuilder sb = new StringBuilder();

        sb.append(getLogName());

        if (!getFields().isEmpty()) {

            sb.append(" {\n");

            for (ValueDescriptor td : getFields()) {

                sb.append("  type=" + td.getTypeName() + "(" + td.getTypeId() + ") name=" + td.getName() + "\n");

            }

            sb.append("}\n");

        }

        return sb.toString();

    }

    public void setRemove(boolean remove) {

       this.remove = remove;

    }

    public boolean getRemove() {

        return remove;

    }

    public void setId(long id) {

        this.id = id;

    }

}