/*
 * 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.management.jfr;

import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.text.ParseException;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

import javax.management.AttributeChangeNotification;
import javax.management.AttributeNotFoundException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanNotificationInfo;
import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;
import javax.management.NotificationEmitter;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.StandardEmitterMBean;

import jdk.jfr.Configuration;
import jdk.jfr.EventType;
import jdk.jfr.FlightRecorder;
import jdk.jfr.FlightRecorderListener;
import jdk.jfr.FlightRecorderPermission;
import jdk.jfr.Recording;
import jdk.jfr.RecordingState;
import jdk.jfr.internal.management.ManagementSupport;

// Instantiated by service provider
final class FlightRecorderMXBeanImpl extends StandardEmitterMBean implements FlightRecorderMXBean, NotificationEmitter {

    final class MXBeanListener implements FlightRecorderListener {
        private final NotificationListener listener;
        private final NotificationFilter filter;
        private final Object handback;
        private final AccessControlContext context;

        public MXBeanListener(NotificationListener listener, NotificationFilter filter, Object handback) {
            this.context = AccessController.getContext();
            this.listener = listener;
            this.filter = filter;
            this.handback = handback;
        }

        public void recordingStateChanged(Recording recording) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    sendNotification(createNotication(recording));
                    return null;
                }
            }, context);
        }
    }

    private static final String ATTRIBUTE_RECORDINGS = "Recordings";
    private static final String OPTION_MAX_SIZE = "maxSize";
    private static final String OPTION_MAX_AGE = "maxAge";
    private static final String OPTION_NAME = "name";
    private static final String OPTION_DISK = "disk";
    private static final String OPTION_DUMP_ON_EXIT = "dumpOnExit";
    private static final String OPTION_DURATION = "duration";
    private static final String OPTION_DESTINATION = "destination";
    private static final List<String> OPTIONS = Arrays.asList(new String[] { OPTION_DUMP_ON_EXIT, OPTION_DURATION, OPTION_NAME, OPTION_MAX_AGE, OPTION_MAX_SIZE, OPTION_DISK, OPTION_DESTINATION, });
    private final StreamManager streamHandler = new StreamManager();
    private final Map<Long, Object> changes = new ConcurrentHashMap<>();
    private final AtomicLong sequenceNumber = new AtomicLong();
    private final List<MXBeanListener> listeners = new CopyOnWriteArrayList<>();
    private FlightRecorder recorder;

    FlightRecorderMXBeanImpl() {
        super(FlightRecorderMXBean.class, true, new NotificationBroadcasterSupport(createNotificationInfo()));
    }

    @Override
    public void startRecording(long id) {
        MBeanUtils.checkControl();
        getExistingRecording(id).start();
    }

    @Override
    public boolean stopRecording(long id) {
        MBeanUtils.checkControl();
        return getExistingRecording(id).stop();
    }

    @Override
    public void closeRecording(long id) {
        MBeanUtils.checkControl();
        getExistingRecording(id).close();
    }

    @Override
    public long openStream(long id, Map<String, String> options) throws IOException {
        MBeanUtils.checkControl();
        if (!FlightRecorder.isInitialized()) {
            throw new IllegalArgumentException("No recording available with id " + id);
        }
        // Make local copy to prevent concurrent modification
        Map<String, String> s = options == null ? new HashMap<>() : new HashMap<>(options);
        Instant starttime = MBeanUtils.parseTimestamp(s.get("startTime"), Instant.MIN);
        Instant endtime = MBeanUtils.parseTimestamp(s.get("endTime"), Instant.MAX);
        int blockSize = MBeanUtils.parseBlockSize(s.get("blockSize"), StreamManager.DEFAULT_BLOCK_SIZE);
        InputStream is = getExistingRecording(id).getStream(starttime, endtime);
        if (is == null) {
            throw new IOException("No recording data available");
        }
        return streamHandler.create(is, blockSize).getId();
    }

    @Override
    public void closeStream(long streamIdentifier) throws IOException {
        MBeanUtils.checkControl();
        streamHandler.getStream(streamIdentifier).close();
    }

    @Override
    public byte[] readStream(long streamIdentifier) throws IOException {
        MBeanUtils.checkMonitor();
        return streamHandler.getStream(streamIdentifier).read();
    }

    @Override
    public List<RecordingInfo> getRecordings() {
        MBeanUtils.checkMonitor();
        if (!FlightRecorder.isInitialized()) {
            return Collections.emptyList();
        }
        return MBeanUtils.transformList(getRecorder().getRecordings(), RecordingInfo::new);
    }

    @Override
    public List<ConfigurationInfo> getConfigurations() {
        MBeanUtils.checkMonitor();
        return MBeanUtils.transformList(Configuration.getConfigurations(), ConfigurationInfo::new);
    }

    @Override
    public List<EventTypeInfo> getEventTypes() {
        MBeanUtils.checkMonitor();
        List<EventType> eventTypes = AccessController.doPrivileged(new PrivilegedAction<List<EventType>>() {
            @Override
            public List<EventType> run() {
                return ManagementSupport.getEventTypes();
            }
        }, null, new FlightRecorderPermission("accessFlightRecorder"));

        return MBeanUtils.transformList(eventTypes, EventTypeInfo::new);
    }

    @Override
    public Map<String, String> getRecordingSettings(long recording) throws IllegalArgumentException {
        MBeanUtils.checkMonitor();
        return getExistingRecording(recording).getSettings();
    }

    @Override
    public void setRecordingSettings(long recording, Map<String, String> values) throws IllegalArgumentException {
        Objects.requireNonNull(values);
        MBeanUtils.checkControl();
        getExistingRecording(recording).setSettings(values);
    }

    @Override
    public long newRecording() {
        MBeanUtils.checkControl();
        getRecorder(); // ensure notification listener is setup
        return AccessController.doPrivileged(new PrivilegedAction<Recording>() {
            @Override
            public Recording run() {
                return new Recording();
            }
        }, null, new FlightRecorderPermission("accessFlightRecorder")).getId();
    }

    @Override
    public long takeSnapshot() {
        MBeanUtils.checkControl();
        return getRecorder().takeSnapshot().getId();
    }

    @Override
    public void setConfiguration(long recording, String configuration) throws IllegalArgumentException {
        Objects.requireNonNull(configuration);
        MBeanUtils.checkControl();
        try {
            Configuration c = Configuration.create(new StringReader(configuration));
            getExistingRecording(recording).setSettings(c.getSettings());
        } catch (IOException | ParseException e) {
            throw new IllegalArgumentException("Could not parse configuration", e);
        }
    }

    @Override
    public void setPredefinedConfiguration(long recording, String configurationName) throws IllegalArgumentException {
        Objects.requireNonNull(configurationName);
        MBeanUtils.checkControl();
        Recording r = getExistingRecording(recording);
        for (Configuration c : Configuration.getConfigurations()) {
            if (c.getName().equals(configurationName)) {
                r.setSettings(c.getSettings());
                return;
            }
        }
        throw new IllegalArgumentException("Could not find configuration with name " + configurationName);
    }

    @Override
    public void copyTo(long recording, String path) throws IOException {
        Objects.requireNonNull(path);
        MBeanUtils.checkControl();
        getExistingRecording(recording).dump(Paths.get(path));
    }

    @Override
    public void setRecordingOptions(long recording, Map<String, String> options) throws IllegalArgumentException {
        Objects.requireNonNull(options);
        MBeanUtils.checkControl();
        // Make local copy to prevent concurrent modification
        Map<String, String> ops = new HashMap<String, String>(options);
        for (Map.Entry<String, String> entry : ops.entrySet()) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            if (!(key instanceof String)) {
                throw new IllegalArgumentException("Option key must not be null, or other type than " + String.class);
            }
            if (!OPTIONS.contains(key)) {
                throw new IllegalArgumentException("Unknown recording option: " + key + ". Valid options are " + OPTIONS + ".");
            }
            if (value != null && !(value instanceof String)) {
                throw new IllegalArgumentException("Incorrect value for option " + key + ". Values must be of type " + String.class + " .");
            }
        }

        Recording r = getExistingRecording(recording);
        validateOption(ops, OPTION_DUMP_ON_EXIT, MBeanUtils::booleanValue);
        validateOption(ops, OPTION_DISK, MBeanUtils::booleanValue);
        validateOption(ops, OPTION_NAME, Function.identity());
        validateOption(ops, OPTION_MAX_AGE, MBeanUtils::duration);
        validateOption(ops, OPTION_MAX_SIZE, MBeanUtils::size);
        validateOption(ops, OPTION_DURATION, MBeanUtils::duration);
        validateOption(ops, OPTION_DESTINATION, x -> MBeanUtils.destination(r, x));

        // All OK, now set them.atomically
        setOption(ops, OPTION_DUMP_ON_EXIT, "false", MBeanUtils::booleanValue, x -> r.setDumpOnExit(x));
        setOption(ops, OPTION_DISK, "true", MBeanUtils::booleanValue, x -> r.setToDisk(x));
        setOption(ops, OPTION_NAME, String.valueOf(r.getId()), Function.identity(), x -> r.setName(x));
        setOption(ops, OPTION_MAX_AGE, null, MBeanUtils::duration, x -> r.setMaxAge(x));
        setOption(ops, OPTION_MAX_SIZE, "0", MBeanUtils::size, x -> r.setMaxSize(x));
        setOption(ops, OPTION_DURATION, null, MBeanUtils::duration, x -> r.setDuration(x));
        setOption(ops, OPTION_DESTINATION, null, x -> MBeanUtils.destination(r, x), x -> setOptionDestination(r, x));
    }

    @Override
    public Map<String, String> getRecordingOptions(long recording) throws IllegalArgumentException {
        MBeanUtils.checkMonitor();
        Recording r = getExistingRecording(recording);
        Map<String, String> options = new HashMap<>(10);
        options.put(OPTION_DUMP_ON_EXIT, String.valueOf(r.getDumpOnExit()));
        options.put(OPTION_DISK, String.valueOf(r.isToDisk()));
        options.put(OPTION_NAME, String.valueOf(r.getName()));
        options.put(OPTION_MAX_AGE, ManagementSupport.formatTimespan(r.getMaxAge(), " "));
        Long maxSize = r.getMaxSize();
        options.put(OPTION_MAX_SIZE, String.valueOf(maxSize == null ? "0" : maxSize.toString()));
        options.put(OPTION_DURATION, ManagementSupport.formatTimespan(r.getDuration(), " "));
        options.put(OPTION_DESTINATION, ManagementSupport.getDestinationOriginalText(r));
        return options;
    }

    @Override
    public long cloneRecording(long id, boolean stop) throws IllegalStateException, SecurityException {
        MBeanUtils.checkControl();
        return getRecording(id).copy(stop).getId();
    }

    @Override
    public ObjectName getObjectName() {
        return MBeanUtils.createObjectName();
    }

    private Recording getExistingRecording(long id) {
        if (FlightRecorder.isInitialized()) {
            Recording recording = getRecording(id);
            if (recording != null) {
                return recording;
            }
        }
        throw new IllegalArgumentException("No recording available with id " + id);
    }

    private Recording getRecording(long id) {
        List<Recording> recs = getRecorder().getRecordings();
        return recs.stream().filter(r -> r.getId() == id).findFirst().orElse(null);
    }

    private static <T, U> void setOption(Map<String, String> options, String name, String defaultValue, Function<String, U> converter, Consumer<U> setter) {
        if (!options.containsKey(name)) {
            return;
        }
        String v = options.get(name);
        if (v == null) {
            v = defaultValue;
        }
        try {
            setter.accept(converter.apply(v));
        } catch (IllegalArgumentException iae) {
            throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());
        }
    }

    private static void setOptionDestination(Recording recording, String destination){
        try {
            Path pathDestination = null;
            if(destination != null){
                pathDestination = Paths.get(destination);
            }
            recording.setDestination(pathDestination);
        } catch (IOException e) {
            IllegalArgumentException iae = new IllegalArgumentException("Not a valid destination " + destination);
            iae.addSuppressed(e);
            throw iae;
        }
    }

    private static <T, U> void validateOption(Map<String, String> options, String name, Function<String, U> validator) {
        try {
            String v = options.get(name);
            if (v == null) {
                return; // OK, will set default
            }
            validator.apply(v);
        } catch (IllegalArgumentException iae) {
            throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());
        }
    }

    private FlightRecorder getRecorder() throws SecurityException {
        // Synchronize on some private object that is always available
        synchronized (streamHandler) {
            if (recorder == null) {
                recorder = AccessController.doPrivileged(new PrivilegedAction<FlightRecorder>() {
                    @Override
                    public FlightRecorder run() {
                        return FlightRecorder.getFlightRecorder();
                    }
                }, null, new FlightRecorderPermission("accessFlightRecorder"));
            }
            return recorder;
        }
    }

    private static MBeanNotificationInfo[] createNotificationInfo() {
        String[] types = new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE };
        String name = AttributeChangeNotification.class.getName();
        String description = "Notifies if the RecordingState has changed for one of the recordings, for example if a recording starts or stops";
        MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
        return new MBeanNotificationInfo[] { info };
    }

    @Override
    public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) {
        MXBeanListener mxbeanListener = new MXBeanListener(listener, filter, handback);
        listeners.add(mxbeanListener);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run(){
                FlightRecorder.addListener(mxbeanListener);
                return null;
            }
        }, null, new FlightRecorderPermission("accessFlightRecorder"));
        super.addNotificationListener(listener, filter, handback);
    }

    @Override
    public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {
        removeListeners( x -> listener == x.listener);
        super.removeNotificationListener(listener);
    }

    @Override
    public void removeNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) throws ListenerNotFoundException {
        removeListeners( x -> listener == x.listener && filter == x.filter && handback == x.handback);
        super.removeNotificationListener(listener, filter, handback);
    }

    private void removeListeners(Predicate<MXBeanListener> p) {
        List<MXBeanListener> toBeRemoved = new ArrayList<>(listeners.size());
        for (MXBeanListener l : listeners) {
            if (p.test(l)) {
                toBeRemoved.add(l);
                FlightRecorder.removeListener(l);
            }
        }
        listeners.removeAll(toBeRemoved);
    }

    private Notification createNotication(Recording recording) {
        try {
            Long id = recording.getId();
            Object oldValue = changes.get(recording.getId());
            Object newValue = getAttribute(ATTRIBUTE_RECORDINGS);
            if (recording.getState() != RecordingState.CLOSED) {
                changes.put(id, newValue);
            } else {
                changes.remove(id);
            }
            return new AttributeChangeNotification(getObjectName(), sequenceNumber.incrementAndGet(), System.currentTimeMillis(), "Recording " + recording.getName() + " is "
                    + recording.getState(), ATTRIBUTE_RECORDINGS, newValue.getClass().getName(), oldValue, newValue);
        } catch (AttributeNotFoundException | MBeanException | ReflectionException e) {
            throw new RuntimeException("Could not create notifcation for FlightRecorderMXBean. " + e.getMessage(), e);
        }
    }
}