/*
 * Copyright (c) 2004, 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 sun.jvm.hotspot.runtime;

import java.util.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;

public class PerfDataEntry extends VMObject {
    private static JIntField  entryLengthField;
    private static JIntField  nameOffsetField;
    private static JIntField  vectorLengthField;
    private static JByteField dataTypeField;
    private static JByteField flagsField;
    private static JByteField dataUnitsField;
    private static JByteField dataVariabilityField;
    private static JIntField  dataOffsetField;

    static {
        VM.registerVMInitializedObserver(new Observer() {
                public void update(Observable o, Object data) {
                    initialize(VM.getVM().getTypeDataBase());
                }
            });
    }

    private static synchronized void initialize(TypeDataBase db) {
        Type type = db.lookupType("PerfDataEntry");
        entryLengthField = type.getJIntField("entry_length");
        nameOffsetField = type.getJIntField("name_offset");
        vectorLengthField = type.getJIntField("vector_length");
        dataTypeField = type.getJByteField("data_type");
        flagsField = type.getJByteField("flags");
        dataUnitsField = type.getJByteField("data_units");
        dataVariabilityField = type.getJByteField("data_variability");
        dataOffsetField = type.getJIntField("data_offset");
    }

    public PerfDataEntry(Address addr) {
        super(addr);
    }

    // Accessors

    public int entryLength() {
        return (int) entryLengthField.getValue(addr);
    }

    public int nameOffset() {
        return (int) nameOffsetField.getValue(addr);
    }

    public int vectorLength() {
        return (int) vectorLengthField.getValue(addr);
    }

    // returns one of the constants in BasicType class
    public int dataType() {
        char ch = (char) (byte) dataTypeField.getValue(addr);
        return BasicType.charToType(ch);
    }

    public byte flags() {
        return (byte) flagsField.getValue(addr);
    }

    public boolean supported() {
        return (flags() & 0x1) != 0;
    }

    // NOTE: Keep this in sync with PerfData::Units enum in VM code
    public interface PerfDataUnits {
        public static final int U_None   = 1;
        public static final int U_Bytes  = 2;
        public static final int U_Ticks  = 3;
        public static final int U_Events = 4;
        public static final int U_String = 5;
        public static final int U_Hertz  = 6;
    }

    // returns one of the constants in PerfDataUnits
    public int dataUnits() {
        return (int) dataUnitsField.getValue(addr);
    }

    // NOTE: Keep this in sync with PerfData::Variability enum in VM code
    public interface PerfDataVariability {
        public static final int V_Constant  = 1;
        public static final int V_Monotonic = 2;
        public static final int V_Variable  = 3;
    }

    // returns one of the constants in PerfDataVariability
    public int dataVariability() {
        return (int) dataVariabilityField.getValue(addr);
    }

    public int dataOffset() {
        return (int) dataOffsetField.getValue(addr);
    }

    public String name() {
        int off = nameOffset();
        return CStringUtilities.getString(addr.addOffsetTo(off));
    }

    public boolean booleanValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tBoolean, "not a boolean");
        }
        return addr.getJBooleanAt(dataOffset());
    }

    public char charValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tChar, "not a char");
        }
        return addr.getJCharAt(dataOffset());
    }

    public byte byteValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tByte, "not a byte");
        }
        return addr.getJByteAt(dataOffset());

    }

    public short shortValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tShort, "not a short");
        }
        return addr.getJShortAt(dataOffset());
    }

    public int intValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tInt, "not an int");
        }
        return addr.getJIntAt(dataOffset());
    }

    public long longValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tLong, "not a long");
        }
        return addr.getJLongAt(dataOffset());
    }

    public float floatValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tFloat, "not a float");
        }
        return addr.getJFloatAt(dataOffset());
    }

    public double doubleValue() {
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(vectorLength() == 0 &&
                        dataType() == BasicType.tDouble, "not a double");
        }
        return addr.getJDoubleAt(dataOffset());
    }

    public boolean[] booleanArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tBoolean, "not a boolean vector");
        }
        boolean[] res = new boolean[len];
        final int off = dataOffset();
        final long size =  getHeap().getBooleanSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJBooleanAt(off + i * size);
        }
        return res;
    }

    public char[] charArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tChar, "not a char vector");
        }
        char[] res = new char[len];
        final int off = dataOffset();
        final long size = getHeap().getCharSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJCharAt(off + i * size);
        }
        return res;
    }

    public byte[] byteArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tByte, "not a byte vector");
        }
        byte[] res = new byte[len];
        final int off = dataOffset();
        final long size = getHeap().getByteSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJByteAt(off + i * size);
        }
        return res;
    }

    public short[] shortArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tShort, "not a short vector");
        }
        short[] res = new short[len];
        final int off = dataOffset();
        final long size = getHeap().getShortSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJShortAt(off + i * size);
        }
        return res;
    }

    public int[] intArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tInt, "not an int vector");
        }
        int[] res = new int[len];
        final int off = dataOffset();
        final long size = getHeap().getIntSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJIntAt(off + i * size);
        }
        return res;
    }

    public long[] longArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tLong, "not a long vector");
        }
        long[] res = new long[len];
        final int off = dataOffset();
        final long size = getHeap().getLongSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJLongAt(off + i * size);
        }
        return res;
    }

    public float[] floatArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tFloat, "not a float vector");
        }
        float[] res = new float[len];
        final int off = dataOffset();
        final long size = getHeap().getFloatSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJFloatAt(off + i * size);
        }
        return res;
    }

    public double[] doubleArrayValue() {
        int len = vectorLength();
        if (Assert.ASSERTS_ENABLED) {
            Assert.that(len > 0 &&
                        dataType() == BasicType.tDouble, "not a double vector");
        }
        double[] res = new double[len];
        final int off = dataOffset();
        final long size = getHeap().getDoubleSize();
        for (int i = 0; i < len; i++) {
            res[i] = addr.getJDoubleAt(off + i * size);
        }
        return res;
    }

    // value as String
    public String valueAsString() {
        int dataType = dataType();
        int len = vectorLength();
        String str = null;
        if (len == 0) { // scalar
            switch (dataType) {
            case BasicType.tBoolean:
                str = Boolean.toString(booleanValue());
                break;
            case BasicType.tChar:
                str = "'" + Character.toString(charValue()) + "'";
                break;
            case BasicType.tByte:
                str = Byte.toString(byteValue());
                break;
            case BasicType.tShort:
                str = Short.toString(shortValue());
                break;
            case BasicType.tInt:
                str = Integer.toString(intValue());
                break;
            case BasicType.tLong:
                str = Long.toString(longValue());
                break;
            case BasicType.tFloat:
                str = Float.toString(floatValue());
                break;
            case BasicType.tDouble:
                str = Double.toString(doubleValue());
                break;
            default:
                str = "<unknown scalar value>";
                break;
            }
        } else { // vector
            switch (dataType) {
            case BasicType.tBoolean: {
                boolean[] res = booleanArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Boolean.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            case BasicType.tChar: {
                // char[] is returned as a String
                str = new String(charArrayValue());
                break;
            }

            case BasicType.tByte: {
                // byte[] is returned as a String
                try {
                    str = new String(byteArrayValue(), "US-ASCII");
                } catch (java.io.UnsupportedEncodingException e) {
                    str = "can't decode string : " + e.getMessage();
                }
                break;
            }

            case BasicType.tShort: {
                short[] res = shortArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Short.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            case BasicType.tInt: {
                int[] res = intArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Integer.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            case BasicType.tLong: {
                long[] res = longArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Long.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            case BasicType.tFloat: {
                float[] res = floatArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Float.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            case BasicType.tDouble: {
                double[] res = doubleArrayValue();
                StringBuffer buf = new StringBuffer();
                buf.append('[');
                for (int i = 0; i < res.length; i++) {
                    buf.append(Double.toString(res[i]));
                    buf.append(", ");
                }
                buf.append(']');
                str = buf.toString();
                break;
            }

            default:
                str = "<unknown vector value>";
                break;
            }
        }

        // add units
        switch (dataUnits()) {
        case PerfDataUnits.U_None:
            break;
        case PerfDataUnits.U_Bytes:
            str += " byte(s)";
            break;
        case PerfDataUnits.U_Ticks:
            str += " tick(s)";
            break;
        case PerfDataUnits.U_Events:
            str += " event(s)";
            break;
        case PerfDataUnits.U_String:
            break;
        case PerfDataUnits.U_Hertz:
            str += " Hz";
            break;
        }

        return str;
    }

    // -- Internals only below this point
    private ObjectHeap getHeap() {
        return VM.getVM().getObjectHeap();
    }
}