/*

 * Copyright (c) 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.api.consumer;

import java.io.IOException;

import java.time.Duration;

import java.time.Instant;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.function.Function;

import jdk.jfr.Event;

import jdk.jfr.Recording;

import jdk.jfr.StackTrace;

import jdk.jfr.Timespan;

import jdk.jfr.Timestamp;

import jdk.jfr.Unsigned;

import jdk.jfr.consumer.RecordedClass;

import jdk.jfr.consumer.RecordedEvent;

import jdk.jfr.consumer.RecordedObject;

import jdk.jfr.consumer.RecordedThread;

import jdk.test.lib.Asserts;

import jdk.test.lib.jfr.Events;

/*

 * @test

 * @summary Verifies the methods of the RecordedObject

 * @key jfr

 * @library /test/lib

 * @run main/othervm jdk.jfr.api.consumer.TestRecordedObject

 */

public class TestRecordedObject {

    private final static boolean BOOLEAN_VALUE = true;

    private final static byte VALUE = 47;

    private final static String STRING_VALUE = "47";

    private final static Class<?> CLASS_VALUE = String.class;

    private final static Thread THREAD_VALUE = Thread.currentThread();

    private final static Instant INSTANT_VALUE = Instant.now();

    private final static Duration DURATION_VALUE = Duration.ofSeconds(47);

    @StackTrace(false)

    static final class EventWithValues extends Event {

        boolean booleanField = BOOLEAN_VALUE;

        byte byteField = VALUE;

        char charField = VALUE;

        short shortField = VALUE;

        int intField = VALUE;

        long longField = VALUE;

        float floatField = VALUE;

        double doubleField = VALUE;

        String stringField = STRING_VALUE;

        Class<?> classField = CLASS_VALUE;

        Thread threadField = THREAD_VALUE;

        @Timespan(Timespan.NANOSECONDS)

        long durationField = DURATION_VALUE.toNanos();

        @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)

        long instantField = INSTANT_VALUE.toEpochMilli();

        Thread nullField = null;

        Class<?> nullField2 = null;

        @Timespan(Timespan.MICROSECONDS)

        long durationMicros = DURATION_VALUE.toNanos() / 1000;

        @Timespan(Timespan.MILLISECONDS)

        long durationMillis = DURATION_VALUE.toMillis();

        @Timespan(Timespan.SECONDS)

        long durationSeconds = DURATION_VALUE.toSeconds();

        @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)

        long instantMillis = 1000;

        @Timestamp(Timespan.TICKS)

        long instantTicks = 0;

        @Unsigned

        byte unsignedByte = Byte.MIN_VALUE;

        @Unsigned

        char unsignedChar = 'q';

        @Unsigned

        short unsignedShort = Short.MIN_VALUE;

        @Unsigned

        int unsignedInt = Integer.MIN_VALUE;

        @Unsigned

        long unsignedLong = Long.MIN_VALUE; // unsigned should be ignored

        @Unsigned

        float unsignedFloat = Float.MIN_VALUE; // unsigned should be ignored

        @Unsigned

        double unsignedDouble = Double.MIN_VALUE; // unsigned should be ignored

    }

    private final static Set<String> ALL = createAll();

    public static void main(String[] args) throws Throwable {

        RecordedObject event = makeRecordedObject();

        // Primitives

        testGetBoolean(event);

        testGetByte(event);

        testGetChar(event);

        testGetShort(event);

        testGetInt(event);

        testGetLong(event);

        testGetDouble(event);

        testGetFloat(event);

        // // Complex types

        testGetString(event);

        testGetInstant(event);

        testGetDuration(event);

        testGetThread(event);

        testGetClass(event);

        // Misc.

        testNestedNames(event);

        testTimeUnits(event);

        testUnsigned(event);

    }

    private static void testUnsigned(RecordedObject event) {

        // Unsigned byte value

        Asserts.assertEquals(event.getByte("unsignedByte"), Byte.MIN_VALUE);

        Asserts.assertEquals(event.getInt("unsignedByte"), Byte.toUnsignedInt(Byte.MIN_VALUE));

        Asserts.assertEquals(event.getLong("unsignedByte"), Byte.toUnsignedLong(Byte.MIN_VALUE));

        Asserts.assertEquals(event.getShort("unsignedByte"), (short)Byte.toUnsignedInt(Byte.MIN_VALUE));

        // Unsigned char, nothing should happen, it is unsigned

        Asserts.assertEquals(event.getChar("unsignedChar"), 'q');

        Asserts.assertEquals(event.getInt("unsignedChar"), (int)'q');

        Asserts.assertEquals(event.getLong("unsignedChar"), (long)'q');

        // Unsigned short

        Asserts.assertEquals(event.getShort("unsignedShort"), Short.MIN_VALUE);

        Asserts.assertEquals(event.getInt("unsignedShort"), Short.toUnsignedInt(Short.MIN_VALUE));

        Asserts.assertEquals(event.getLong("unsignedShort"), Short.toUnsignedLong(Short.MIN_VALUE));

        // Unsigned int

        Asserts.assertEquals(event.getInt("unsignedInt"), Integer.MIN_VALUE);

        Asserts.assertEquals(event.getLong("unsignedInt"), Integer.toUnsignedLong(Integer.MIN_VALUE));

        // Unsigned long, nothing should happen

        Asserts.assertEquals(event.getLong("unsignedLong"), Long.MIN_VALUE);

        // Unsigned float, nothing should happen

        Asserts.assertEquals(event.getFloat("unsignedFloat"), Float.MIN_VALUE);

        // Unsigned double, nothing should happen

        Asserts.assertEquals(event.getDouble("unsignedDouble"), Double.MIN_VALUE);

    }

    private static void testTimeUnits(RecordedObject event) {

        Asserts.assertEquals(event.getDuration("durationMicros"), DURATION_VALUE);

        Asserts.assertEquals(event.getDuration("durationMillis"), DURATION_VALUE);

        Asserts.assertEquals(event.getDuration("durationSeconds"), DURATION_VALUE);

        Asserts.assertEquals(event.getInstant("instantMillis").toEpochMilli(), 1000L);

        if (!event.getInstant("instantTicks").isBefore(INSTANT_VALUE)) {

            throw new AssertionError("Expected start time of JVM to before call to Instant.now()");

        }

    }

    private static void testNestedNames(RecordedObject event) {

        RecordedThread t = event.getValue("threadField");

        // Nested with getValue

        try {

            event.getValue("nullField.javaName");

            throw new AssertionError("Expected NullPointerException");

        } catch (NullPointerException npe) {

            // OK, expected;

        }

        try {

            event.getValue("nullField.does.not.exist");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException iae) {

            // OK, expected;

        }

        // Nested getLong

        try {

            event.getLong("nullField.javaName");

            throw new AssertionError("Expected NullPointerException");

        } catch (NullPointerException npe) {

            // OK, expected;

        }

        try {

            event.getLong("nullField.does.not.exist");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        if (t.getOSThreadId() != event.getLong("threadField.osThreadId")) {

            throw new AssertionError("Incorrect result from nested long value");

        }

        // Nested getString

        try {

            event.getString("nullField.osThreadId");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        try {

            event.getLong("nullField.does.not.exist");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        if (!t.getJavaName().equals(event.getString("threadField.javaName"))) {

            throw new AssertionError("Incorrect result from nested long value");

        }

        // Nested getClass

        try {

            event.getClass("nullField.osThreadId");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        try {

            event.getClass("nullField.does.not.exist");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        // Nested getThread

        try {

            event.getThread("nullField2.name");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

        try {

            event.getThread("nullField2.does.not.exist");

            throw new AssertionError("Expected IllegalArgumentException");

        } catch (IllegalArgumentException npe) {

            // OK, expected;

        }

    }

    private static void testGetBoolean(RecordedObject e) {

        assertGetter(x -> e.getBoolean(x), BOOLEAN_VALUE, "boolean");

    }

    private static void testGetByte(RecordedObject e) {

        assertGetter(x -> e.getByte(x), (byte) VALUE, "byte");

    }

    private static void testGetChar(RecordedObject e) {

        assertGetter(x -> e.getChar(x), (char) VALUE, "char");

    }

    private static void testGetShort(RecordedObject e) {

        assertGetter(x -> e.getShort(x), (short) VALUE, "byte", "short");

    }

    private static void testGetInt(RecordedObject e) {

        assertGetter(x -> e.getInt(x), (int) VALUE, "byte", "char", "short", "int");

    }

    private static void testGetLong(RecordedObject e) {

        assertGetter(x -> e.getLong(x), (long) VALUE, "byte", "char", "short", "int", "long");

    }

    private static void testGetFloat(RecordedObject e) {

        assertGetter(x -> e.getFloat(x), (float) VALUE, "byte", "char", "short", "int", "long", "float");

    }

    private static void testGetDouble(RecordedObject e) {

        assertGetter(x -> e.getDouble(x), (double) VALUE, "byte", "char", "short", "int", "long", "float", "double");

    }

    private static void testGetString(RecordedObject e) {

        assertGetter(x -> e.getString(x), STRING_VALUE, "string");

    }

    private static void testGetInstant(RecordedObject e) {

        assertGetter(x -> e.getInstant(x), Instant.ofEpochMilli(INSTANT_VALUE.toEpochMilli()), "instant");

    }

    private static void testGetDuration(RecordedObject e) {

        assertGetter(x -> e.getDuration(x), DURATION_VALUE, "duration");

    }

    private static void testGetThread(RecordedObject e) {

        RecordedThread thread = e.getValue("threadField");

        if (!thread.getJavaName().equals(THREAD_VALUE.getName())) {

            throw new AssertionError("Expected thread to have name " + THREAD_VALUE.getName());

        }

        assertGetter(x -> {

            // OK to access nullField if it is correct type

            // Chose a second null field with class type

            if ("nullField".equals(x)) {

                return e.getThread("nullField2");

            } else {

                return e.getThread(x);

            }

        }, thread, "thread");

    }

    private static void testGetClass(RecordedObject e) {

        RecordedClass clazz = e.getValue("classField");

        if (!clazz.getName().equals(CLASS_VALUE.getName())) {

            throw new AssertionError("Expected class to have name " + CLASS_VALUE.getName());

        }

        assertGetter(x -> e.getClass(x), clazz, "class");

    }

    private static <T> void assertGetter(Function<String, T> f, T expectedValue, String... validTypes) {

        Set<String> valids = new HashSet<String>(Arrays.asList(validTypes));

        Set<String> invalids = new HashSet<String>(ALL);

        invalids.removeAll(valids);

        for (String valid : valids) {

            T result = f.apply(valid + "Field");

            if (!expectedValue.equals(result)) {

                throw new AssertionError("Incorrect return value " + result + ". Expected " + expectedValue);

            }

        }

        for (String invalid : invalids) {

            try {

                f.apply(invalid + "Field");

            } catch (IllegalArgumentException iae) {

                // OK, as expected

            } catch (Exception e) {

                throw new AssertionError("Unexpected exception for invalid field " + invalid + ". " + e.getClass().getName() + " : " + e.getMessage(), e);

            }

        }

        String[] illegals = { "missingField", "nullField.javaName.does.not.exist", "nullField" };

        for (String illegal : illegals) {

            try {

                f.apply(illegal);

                throw new AssertionError("Expected IllegalArgumentException when accessing " + illegal);

            } catch (IllegalArgumentException iae) {

                // OK, as expected

            } catch (Exception e) {

                throw new AssertionError("Expected IllegalArgumentException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);

            }

        }

        try {

            f.apply(null);

            throw new AssertionError("Expected NullpointerException exception when passing in null value");

        } catch (NullPointerException iae) {

            // OK, as expected

        } catch (Exception e) {

            throw new AssertionError("Expected NullpointerException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);

        }

    }

    private static RecordedObject makeRecordedObject() throws IOException {

        Recording r = new Recording();

        r.start();

        EventWithValues t = new EventWithValues();

        t.commit();

        r.stop();

        List<RecordedEvent> events = Events.fromRecording(r);

        Events.hasEvents(events);

        return events.get(0);

    }

    private static Set<String> createAll() {

        Set<String> set = new HashSet<>();

        set.add("boolean");

        set.add("byte");

        set.add("char");

        set.add("short");

        set.add("int");

        set.add("long");

        set.add("float");

        set.add("double");

        set.add("string");

        set.add("class");

        set.add("thread");

        set.add("instant");

        set.add("duration");

        return set;

    }

}