/*

 * Copyright (c) 2012, 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 org.graalvm.compiler.debug;

import static java.util.FormattableFlags.LEFT_JUSTIFY;

import static java.util.FormattableFlags.UPPERCASE;

import static org.graalvm.compiler.debug.DebugOptions.Count;

import static org.graalvm.compiler.debug.DebugOptions.Counters;

import static org.graalvm.compiler.debug.DebugOptions.Dump;

import static org.graalvm.compiler.debug.DebugOptions.DumpOnError;

import static org.graalvm.compiler.debug.DebugOptions.DumpOnPhaseChange;

import static org.graalvm.compiler.debug.DebugOptions.DumpPath;

import static org.graalvm.compiler.debug.DebugOptions.ListMetrics;

import static org.graalvm.compiler.debug.DebugOptions.Log;

import static org.graalvm.compiler.debug.DebugOptions.MemUseTrackers;

import static org.graalvm.compiler.debug.DebugOptions.ShowDumpFiles;

import static org.graalvm.compiler.debug.DebugOptions.Time;

import static org.graalvm.compiler.debug.DebugOptions.Timers;

import static org.graalvm.compiler.debug.DebugOptions.TrackMemUse;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.PrintStream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardOpenOption;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Formatter;

import java.util.List;

import java.util.Map;

import java.util.SortedMap;

import java.util.TreeMap;

import org.graalvm.compiler.options.OptionKey;

import org.graalvm.compiler.options.OptionValues;

import org.graalvm.graphio.GraphOutput;

import jdk.vm.ci.meta.JavaMethod;

/**

 * A facility for logging and dumping as well as a container for values associated with

 * {@link MetricKey}s.

 *

 * A {@code DebugContext} object must only be used on the thread that created it. This means it

 * needs to be passed around as a parameter. For convenience, it can be encapsulated in a widely

 * used object that is in scope wherever a {@code DebugContext} is needed. However, care must be

 * taken when such objects can be exposed to multiple threads (e.g., they are in a non-thread-local

 * cache).

 */

public final class DebugContext implements AutoCloseable {

    public static final Description NO_DESCRIPTION = null;

    public static final GlobalMetrics NO_GLOBAL_METRIC_VALUES = null;

    public static final Iterable<DebugHandlersFactory> NO_CONFIG_CUSTOMIZERS = Collections.emptyList();

    public static final PrintStream DEFAULT_LOG_STREAM = TTY.out;

    /**

     * Contains the immutable parts of a debug context. This separation allows the immutable parts

     * to be shared and reduces the overhead of initialization since most immutable fields are

     * configured by parsing options.

     */

    final Immutable immutable;

    /**

     * Determines whether metrics are enabled.

     */

    boolean metricsEnabled;

    DebugConfig currentConfig;

    ScopeImpl currentScope;

    CloseableCounter currentTimer;

    CloseableCounter currentMemUseTracker;

    Scope lastClosedScope;

    Throwable lastExceptionThrown;

    private IgvDumpChannel sharedChannel;

    private GraphOutput<?, ?> parentOutput;

    /**

     * Stores the {@link MetricKey} values.

     */

    private long[] metricValues;

    /**

     * Determines if dynamic scopes are enabled.

     */

    public boolean areScopesEnabled() {

        return immutable.scopesEnabled;

    }

    public <G, N, M> GraphOutput<G, M> buildOutput(GraphOutput.Builder<G, N, M> builder) throws IOException {

        if (parentOutput != null) {

            return builder.build(parentOutput);

        } else {

            if (sharedChannel == null) {

                sharedChannel = new IgvDumpChannel(() -> getDumpPath(".bgv", false), immutable.options);

            }

            final GraphOutput<G, M> output = builder.build(sharedChannel);

            parentOutput = output;

            return output;

        }

    }

    /**

     * Adds version properties to the provided map. The version properties are read at a start of

     * the JVM from a JVM specific location. Each property identifiers a commit of a certain

     * component in the system. The properties added to the {@code properties} map are prefixed with

     * {@code "version."} prefix.

     *

     * @param properties map to add the version properties to or {@code null}

     * @return {@code properties} with version properties added or an unmodifiable map containing

     *         the version properties if {@code properties == null}

     */

    public static Map<Object, Object> addVersionProperties(Map<Object, Object> properties) {

        return Versions.VERSIONS.withVersions(properties);

    }

    /**

     * The immutable configuration that can be shared between {@link DebugContext} objects.

     */

    static final class Immutable {

        private static final Immutable[] CACHE = new Immutable[5];

        /**

         * The options from which this object was configured.

         */

        final OptionValues options;

        /**

         * Specifies if dynamic scopes are enabled.

         */

        final boolean scopesEnabled;

        final boolean listMetrics;

        /**

         * Names of unscoped counters. A counter is unscoped if this set is empty or contains the

         * counter's name.

         */

        final EconomicSet<String> unscopedCounters;

        /**

         * Names of unscoped timers. A timer is unscoped if this set is empty or contains the

         * timer's name.

         */

        final EconomicSet<String> unscopedTimers;

        /**

         * Names of unscoped memory usage trackers. A memory usage tracker is unscoped if this set

         * is empty or contains the memory usage tracker's name.

         */

        final EconomicSet<String> unscopedMemUseTrackers;

        private static EconomicSet<String> parseUnscopedMetricSpec(String spec, boolean unconditional, boolean accumulatedKey) {

            EconomicSet<String> res;

            if (spec == null) {

                if (!unconditional) {

                    res = null;

                } else {

                    res = EconomicSet.create();

                }

            } else {

                res = EconomicSet.create();

                if (!spec.isEmpty()) {

                    if (!accumulatedKey) {

                        res.addAll(Arrays.asList(spec.split(",")));

                    } else {

                        for (String n : spec.split(",")) {

                            res.add(n + AccumulatedKey.ACCUMULATED_KEY_SUFFIX);

                            res.add(n + AccumulatedKey.FLAT_KEY_SUFFIX);

                        }

                    }

                }

            }

            return res;

        }

        static Immutable create(OptionValues options) {

            int i = 0;

            while (i < CACHE.length) {

                Immutable immutable = CACHE[i];

                if (immutable == null) {

                    break;

                }

                if (immutable.options == options) {

                    return immutable;

                }

                i++;

            }

            Immutable immutable = new Immutable(options);

            if (i < CACHE.length) {

                CACHE[i] = immutable;

            }

            return immutable;

        }

        private static boolean isNotEmpty(OptionKey<String> option, OptionValues options) {

            return option.getValue(options) != null && !option.getValue(options).isEmpty();

        }

        private Immutable(OptionValues options) {

            this.options = options;

            String timeValue = Time.getValue(options);

            String trackMemUseValue = TrackMemUse.getValue(options);

            this.unscopedCounters = parseUnscopedMetricSpec(Counters.getValue(options), "".equals(Count.getValue(options)), false);

            this.unscopedTimers = parseUnscopedMetricSpec(Timers.getValue(options), "".equals(timeValue), true);

            this.unscopedMemUseTrackers = parseUnscopedMetricSpec(MemUseTrackers.getValue(options), "".equals(trackMemUseValue), true);

            if (unscopedTimers != null ||

                            unscopedMemUseTrackers != null ||

                            timeValue != null ||

                            trackMemUseValue != null) {

                try {

                    Class.forName("java.lang.management.ManagementFactory");

                } catch (ClassNotFoundException ex) {

                    throw new IllegalArgumentException("Time, Timers, MemUseTrackers and TrackMemUse options require java.management module");

                }

            }

            this.scopesEnabled = DumpOnError.getValue(options) ||

                            Dump.getValue(options) != null ||

                            Log.getValue(options) != null ||

                            isNotEmpty(DebugOptions.Count, options) ||

                            isNotEmpty(DebugOptions.Time, options) ||

                            isNotEmpty(DebugOptions.TrackMemUse, options) ||

                            DumpOnPhaseChange.getValue(options) != null;

            this.listMetrics = ListMetrics.getValue(options);

        }

        private Immutable() {

            this.options = new OptionValues(EconomicMap.create());

            this.unscopedCounters = null;

            this.unscopedTimers = null;

            this.unscopedMemUseTrackers = null;

            this.scopesEnabled = false;

            this.listMetrics = false;

        }

        public boolean hasUnscopedMetrics() {

            return unscopedCounters != null || unscopedTimers != null || unscopedMemUseTrackers != null;

        }

    }

    /**

     * Gets the options this debug context was constructed with.

     */

    public OptionValues getOptions() {

        return immutable.options;

    }

    static class Activated extends ThreadLocal<DebugContext> {

    }

    private static final Activated activated = new Activated();

    /**

     * An object used to undo the changes made by DebugContext#activate().

     */

    public static class Activation implements AutoCloseable {

        private final DebugContext parent;

        Activation(DebugContext parent) {

            this.parent = parent;

        }

        @Override

        public void close() {

            activated.set(parent);

        }

    }

    /**

     * Activates this object as the debug context {@linkplain DebugContext#forCurrentThread for the

     * current thread}. This method should be used in a try-with-resources statement.

     *

     * @return an object that will deactivate the debug context for the current thread when

     *         {@link Activation#close()} is called on it

     */

    public Activation activate() {

        Activation res = new Activation(activated.get());

        activated.set(this);

        return res;

    }

    /**

     * Shared object used to represent a disabled debug context.

     */

    public static final DebugContext DISABLED = new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, new Immutable(), NO_CONFIG_CUSTOMIZERS);

    /**

     * Gets the debug context for the current thread. This should only be used when there is no

     * other reasonable means to get a hold of a debug context.

     */

    public static DebugContext forCurrentThread() {

        DebugContext current = activated.get();

        if (current == null) {

            return DISABLED;

        }

        return current;

    }

    private final GlobalMetrics globalMetrics;

    /**

     * Describes the computation associated with a {@link DebugContext}.

     */

    public static class Description {

        /**

         * The primary input to the computation.

         */

        final Object compilable;

        /**

         * A runtime based identifier that is most likely to be unique.

         */

        final String identifier;

        public Description(Object compilable, String identifier) {

            this.compilable = compilable;

            this.identifier = identifier;

        }

        @Override

        public String toString() {

            String compilableName = compilable instanceof JavaMethod ? ((JavaMethod) compilable).format("%H.%n(%p)%R") : String.valueOf(compilable);

            return identifier + ":" + compilableName;

        }

        final String getLabel() {

            if (compilable instanceof JavaMethod) {

                JavaMethod method = (JavaMethod) compilable;

                return method.format("%h.%n(%p)%r");

            }

            return String.valueOf(compilable);

        }

    }

    private final Description description;

    /**

     * Gets a description of the computation associated with this debug context.

     *

     * @return {@code null} if no description is available

     */

    public Description getDescription() {

        return description;

    }

    /**

     * Gets the global metrics associated with this debug context.

     *

     * @return {@code null} if no global metrics are available

     */

    public GlobalMetrics getGlobalMetrics() {

        return globalMetrics;

    }

    /**

     * Creates a {@link DebugContext} based on a given set of option values and {@code factory}.

     */

    public static DebugContext create(OptionValues options, DebugHandlersFactory factory) {

        return new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, Immutable.create(options), Collections.singletonList(factory));

    }

    /**

     * Creates a {@link DebugContext} based on a given set of option values and {@code factories}.

     * The {@link DebugHandlersFactory#LOADER} can be used for the latter.

     */

    public static DebugContext create(OptionValues options, Iterable<DebugHandlersFactory> factories) {

        return new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, Immutable.create(options), factories);

    }

    /**

     * Creates a {@link DebugContext}.

     */

    public static DebugContext create(OptionValues options, Description description, GlobalMetrics globalMetrics, PrintStream logStream, Iterable<DebugHandlersFactory> factories) {

        return new DebugContext(description, globalMetrics, logStream, Immutable.create(options), factories);

    }

    private DebugContext(Description description, GlobalMetrics globalMetrics, PrintStream logStream, Immutable immutable, Iterable<DebugHandlersFactory> factories) {

        this.immutable = immutable;

        this.description = description;

        this.globalMetrics = globalMetrics;

        if (immutable.scopesEnabled) {

            OptionValues options = immutable.options;

            List<DebugDumpHandler> dumpHandlers = new ArrayList<>();

            List<DebugVerifyHandler> verifyHandlers = new ArrayList<>();

            for (DebugHandlersFactory factory : factories) {

                for (DebugHandler handler : factory.createHandlers(options)) {

                    if (handler instanceof DebugDumpHandler) {

                        dumpHandlers.add((DebugDumpHandler) handler);

                    } else {

                        assert handler instanceof DebugVerifyHandler;

                        verifyHandlers.add((DebugVerifyHandler) handler);

                    }

                }

            }

            currentConfig = new DebugConfigImpl(options, logStream, dumpHandlers, verifyHandlers);

            currentScope = new ScopeImpl(this, Thread.currentThread());

            currentScope.updateFlags(currentConfig);

            metricsEnabled = true;

        } else {

            metricsEnabled = immutable.hasUnscopedMetrics() || immutable.listMetrics;

        }

    }

    public Path getDumpPath(String extension, boolean directory) {

        try {

            String id = description == null ? null : description.identifier;

            String label = description == null ? null : description.getLabel();

            Path result = PathUtilities.createUnique(immutable.options, DumpPath, id, label, extension, directory);

            if (ShowDumpFiles.getValue(immutable.options)) {

                TTY.println("Dumping debug output to %s", result.toAbsolutePath().toString());

            }

            return result;

        } catch (IOException ex) {

            throw rethrowSilently(RuntimeException.class, ex);

        }

    }

    /**

     * A special dump level that indicates the dumping machinery is enabled but no dumps will be

     * produced except through other options.

     */

    public static final int ENABLED_LEVEL = 0;

    /**

     * Basic debug level.

     *

     * For HIR dumping, only ~5 graphs per method: after parsing, after inlining, after high tier,

     * after mid tier, after low tier.

     *

     * LIR dumping: After LIR generation, after each pre-allocation, allocation and post allocation

     * stage, and after code installation.

     */

    public static final int BASIC_LEVEL = 1;

    /**

     * Informational debug level.

     *

     * HIR dumping: One graph after each applied top-level phase.

     *

     * LIR dumping: After each applied phase.

     */

    public static final int INFO_LEVEL = 2;

    /**

     * Verbose debug level.

     *

     * HIR dumping: One graph after each phase (including sub phases).

     *

     * LIR dumping: After each phase including sub phases.

     */

    public static final int VERBOSE_LEVEL = 3;

    /**

     * Detailed debug level.

     *

     * HIR dumping: Graphs within phases where interesting for a phase, max ~5 per phase.

     *

     * LIR dumping: Dump CFG within phases where interesting.

     */

    public static final int DETAILED_LEVEL = 4;

    /**

     * Very detailed debug level.

     *

     * HIR dumping: Graphs per node granularity graph change (before/after change).

     *

     * LIR dumping: Intermediate CFGs of phases where interesting.

     */

    public static final int VERY_DETAILED_LEVEL = 5;

    public boolean isDumpEnabled(int dumpLevel) {

        return currentScope != null && currentScope.isDumpEnabled(dumpLevel);

    }

    /**

     * Determines if verification is enabled for any {@link JavaMethod} in the current scope.

     *

     * @see DebugContext#verify(Object, String)

     */

    public boolean isVerifyEnabledForMethod() {

        if (currentScope == null) {

            return false;

        }

        if (currentConfig == null) {

            return false;

        }

        return currentConfig.isVerifyEnabledForMethod(currentScope);

    }