/*
 * Copyright (c) 2012, 2015, 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 java.io.PrintStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.graalvm.compiler.options.Option;
import org.graalvm.compiler.options.OptionType;
import org.graalvm.compiler.options.OptionValue;

import jdk.vm.ci.code.BailoutException;
import jdk.vm.ci.meta.JavaMethod;

public class GraalDebugConfig implements DebugConfig {
    @SuppressWarnings("all")
    private static boolean assertionsEnabled() {
        boolean assertionsEnabled = false;
        assert assertionsEnabled = true;
        return assertionsEnabled;
    }

    public static class Options {
        // @formatter:off
        @Option(help = "Pattern for scope(s) in which dumping is enabled (see DebugFilter and Debug.dump)", type = OptionType.Debug)
        public static final OptionValue<String> Dump = new OptionValue<>(null);
        @Option(help = "Pattern for scope(s) in which counting is enabled (see DebugFilter and Debug.counter). " +
                       "An empty value enables all counters unconditionally.", type = OptionType.Debug)
        public static final OptionValue<String> Count = new OptionValue<>(null);
        @Option(help = "Pattern for scope(s) in which verification is enabled (see DebugFilter and Debug.verify).", type = OptionType.Debug)
        public static final OptionValue<String> Verify = new OptionValue<String>() {
            @Override
            protected String defaultValue() {
                return assertionsEnabled() ? "" : null;
            }
        };
        @Option(help = "Pattern for scope(s) in which memory use tracking is enabled (see DebugFilter and Debug.counter). " +
                       "An empty value enables all memory use trackers unconditionally.", type = OptionType.Debug)
        public static final OptionValue<String> TrackMemUse = new OptionValue<>(null);
        @Option(help = "Pattern for scope(s) in which timing is enabled (see DebugFilter and Debug.timer). " +
                       "An empty value enables all timers unconditionally.", type = OptionType.Debug)
        public static final OptionValue<String> Time = new OptionValue<>(null);
        @Option(help = "Pattern for scope(s) in which logging is enabled (see DebugFilter and Debug.log)", type = OptionType.Debug)
        public static final OptionValue<String> Log = new OptionValue<>(null);
        @Option(help = "Pattern for filtering debug scope output based on method context (see MethodFilter)", type = OptionType.Debug)
        public static final OptionValue<String> MethodFilter = new OptionValue<>(null);
        @Option(help = "Only check MethodFilter against the root method in the context if true, otherwise check all methods", type = OptionType.Debug)
        public static final OptionValue<Boolean> MethodFilterRootOnly = new OptionValue<>(false);

        @Option(help = "How to print counters and timing values:%n" +
                       "Name - aggregate by unqualified name%n" +
                       "Partial - aggregate by partially qualified name (e.g., A.B.C.D.Counter and X.Y.Z.D.Counter will be merged to D.Counter)%n" +
                       "Complete - aggregate by qualified name%n" +
                       "Thread - aggregate by qualified name and thread", type = OptionType.Debug)
        public static final OptionValue<String> DebugValueSummary = new OptionValue<>("Name");
        @Option(help = "Print counters and timers in a human readable form.", type = OptionType.Debug)
        public static final OptionValue<Boolean> DebugValueHumanReadable = new OptionValue<>(true);
        @Option(help = "Omit reporting 0-value counters", type = OptionType.Debug)
        public static final OptionValue<Boolean> SuppressZeroDebugValues = new OptionValue<>(true);
        @Option(help = "Only report debug values for maps which match the regular expression.", type = OptionType.Debug)
        public static final OptionValue<String> DebugValueThreadFilter = new OptionValue<>(null);
        @Option(help = "Write debug values into a file instead of the terminal. " +
                       "If DebugValueSummary is Thread, the thread name will be prepended.", type = OptionType.Debug)
        public static final OptionValue<String> DebugValueFile = new OptionValue<>(null);
        @Option(help = "Send Graal compiler IR to dump handlers on error", type = OptionType.Debug)
        public static final OptionValue<Boolean> DumpOnError = new OptionValue<>(false);
        @Option(help = "Intercept also bailout exceptions", type = OptionType.Debug)
        public static final OptionValue<Boolean> InterceptBailout = new OptionValue<>(false);
        @Option(help = "Enable more verbose log output when available", type = OptionType.Debug)
        public static final OptionValue<Boolean> LogVerbose = new OptionValue<>(false);

        @Option(help = "The directory where various Graal dump files are written.")
        public static final OptionValue<String> DumpPath = new OptionValue<>(".");

        @Option(help = "Enable dumping to the C1Visualizer. Enabling this option implies PrintBackendCFG.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintCFG = new OptionValue<>(false);
        @Option(help = "Enable dumping LIR, register allocation and code generation info to the C1Visualizer.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintBackendCFG = new OptionValue<>(true);
        @Option(help = "Base filename when dumping C1Visualizer output to files.", type = OptionType.Debug)
        public static final OptionValue<String> PrintCFGFileName = new OptionValue<>("compilations");

        @Option(help = "Output probabilities for fixed nodes during binary graph dumping", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintGraphProbabilities = new OptionValue<>(false);
        @Option(help = "Enable dumping to the IdealGraphVisualizer.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintIdealGraph = new OptionValue<>(true);
        @Option(help = "Dump IdealGraphVisualizer output in binary format", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintBinaryGraphs = new OptionValue<>(true);
        @Option(help = "Print Ideal graphs as opposed to sending them over the network.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintIdealGraphFile = new OptionValue<>(false);
        @Option(help = "Base filename when dumping Ideal graphs to files.", type = OptionType.Debug)
        public static final OptionValue<String> PrintIdealGraphFileName = new OptionValue<>("runtime-graphs");

        @Option(help = "", type = OptionType.Debug)
        public static final OptionValue<String> PrintIdealGraphAddress = new OptionValue<>("127.0.0.1");
        @Option(help = "", type = OptionType.Debug)
        public static final OptionValue<Integer> PrintIdealGraphPort = new OptionValue<>(4444);
        @Option(help = "", type = OptionType.Debug)
        public static final OptionValue<Integer> PrintBinaryGraphPort = new OptionValue<>(4445);
        @Option(help = "", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintIdealGraphSchedule = new OptionValue<>(false);
        @Option(help = "Enable dumping Truffle ASTs to the IdealGraphVisualizer.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintTruffleTrees = new OptionValue<>(true);

        @Option(help = "Enable dumping canonical text from for graphs.", type = OptionType.Debug)
        public static final OptionValue<Boolean> PrintCanonicalGraphStrings = new OptionValue<>(false);
        @Option(help = "Base directory when dumping graphs strings to files.", type = OptionType.Debug)
        public static final OptionValue<String> PrintCanonicalGraphStringsDirectory = new OptionValue<>("graph-strings");
        @Option(help = "Choose format used when dumping canonical text for graphs: " +
                "0 gives a scheduled graph (better for spotting changes involving the schedule)" +
                "while 1 gives a CFG containing expressions rooted at fixed nodes (better for spotting small structure differences)", type = OptionType.Debug)
        public static final OptionValue<Integer> PrintCanonicalGraphStringFlavor = new OptionValue<>(0);
        @Option(help = "Exclude virtual nodes when dumping canonical text for graphs.", type = OptionType.Debug)
        public static final OptionValue<Boolean> CanonicalGraphStringsExcludeVirtuals = new OptionValue<>(true);
        @Option(help = "Exclude virtual nodes when dumping canonical text for graphs.", type = OptionType.Debug)
        public static final OptionValue<Boolean> CanonicalGraphStringsCheckConstants = new OptionValue<>(false);
        @Option(help = "Attempts to remove object identity hashes when dumping canonical text for graphs.", type = OptionType.Debug)
        public static final OptionValue<Boolean> CanonicalGraphStringsRemoveIdentities = new OptionValue<>(true);

        @Option(help = "Enable per method metrics that are collected across all compilations of a method." +
                       "Pattern for scope(s) in which method metering is enabled (see DebugFilter and Debug.metric).", type = OptionType.Debug)
        public static final OptionValue<String> MethodMeter = new OptionValue<>(null);
        @Option(help = "If a global metric (DebugTimer, DebugCounter or DebugMemUseTracker) is enabled in the same scope as a method metric, " +
                       "use the global metric to update the method metric for the current compilation. " +
                       "This option enables the re-use of global metrics on per-compilation basis. " +
                       "Whenever a value is added to a global metric, the value is also added to a MethodMetric under the same name " +
                       "as the global metric. " +
                       "This option incurs a small but constant overhead due to the context method lookup at each metric update. " +
                       "Format to specify GlobalMetric interception:(Timers|Counters|MemUseTrackers)(,Timers|,Counters|,MemUseTrackers)*", type = OptionType.Debug)
        public static final OptionValue<String> GlobalMetricsInterceptedByMethodMetrics = new OptionValue<>(null);
        @Option(help = "Force-enable debug code paths", type = OptionType.Debug)
        public static final OptionValue<Boolean> ForceDebugEnable = new OptionValue<>(false);
        @Option(help = "Clear the debug metrics after bootstrap.", type = OptionType.Debug)
        public static final OptionValue<Boolean> ClearMetricsAfterBootstrap = new OptionValue<>(false);
        @Option(help = "Do not compile anything on bootstrap but just initialize the compiler.", type = OptionType.Debug)
        public static final OptionValue<Boolean> BootstrapInitializeOnly = new OptionValue<>(false);
        // @formatter:on
    }

    public static boolean isNotEmpty(OptionValue<String> option) {
        return option.getValue() != null && !option.getValue().isEmpty();
    }

    public static boolean areDebugScopePatternsEnabled() {
        return Options.DumpOnError.getValue() || Options.Dump.getValue() != null || Options.Log.getValue() != null || areScopedGlobalMetricsEnabled();
    }

    public static boolean isGlobalMetricsInterceptedByMethodMetricsEnabled() {
        return isNotEmpty(Options.GlobalMetricsInterceptedByMethodMetrics);
    }

    /**
     * Determines if any of {@link Options#Count}, {@link Options#Time} or
     * {@link Options#TrackMemUse} has a non-null, non-empty value.
     */
    public static boolean areScopedGlobalMetricsEnabled() {
        return isNotEmpty(Options.Count) || isNotEmpty(Options.Time) || isNotEmpty(Options.TrackMemUse) || isNotEmpty(Options.MethodMeter);
    }

    private final DebugFilter countFilter;
    private final DebugFilter logFilter;
    private final DebugFilter methodMetricsFilter;
    private final DebugFilter trackMemUseFilter;
    private final DebugFilter timerFilter;
    private final DebugFilter dumpFilter;
    private final DebugFilter verifyFilter;
    private final MethodFilter[] methodFilter;
    private final List<DebugDumpHandler> dumpHandlers;
    private final List<DebugVerifyHandler> verifyHandlers;
    private final PrintStream output;

    // Use an identity set to handle context objects that don't support hashCode().
    private final Set<Object> extraFilters = Collections.newSetFromMap(new IdentityHashMap<>());

    public GraalDebugConfig(String logFilter, String countFilter, String trackMemUseFilter, String timerFilter, String dumpFilter, String verifyFilter, String methodFilter,
                    String methodMetricsFilter, PrintStream output, List<DebugDumpHandler> dumpHandlers, List<DebugVerifyHandler> verifyHandlers) {
        this.logFilter = DebugFilter.parse(logFilter);
        this.countFilter = DebugFilter.parse(countFilter);
        this.trackMemUseFilter = DebugFilter.parse(trackMemUseFilter);
        this.timerFilter = DebugFilter.parse(timerFilter);
        this.dumpFilter = DebugFilter.parse(dumpFilter);
        this.verifyFilter = DebugFilter.parse(verifyFilter);
        this.methodMetricsFilter = DebugFilter.parse(methodMetricsFilter);
        if (methodFilter == null || methodFilter.isEmpty()) {
            this.methodFilter = null;
        } else {
            this.methodFilter = org.graalvm.compiler.debug.MethodFilter.parse(methodFilter);
        }

        // Report the filters that have been configured so the user can verify it's what they expect
        if (logFilter != null || countFilter != null || timerFilter != null || dumpFilter != null || methodFilter != null) {
            // TTY.println(Thread.currentThread().getName() + ": " + toString());
        }
        this.dumpHandlers = dumpHandlers;
        this.verifyHandlers = verifyHandlers;
        this.output = output;
    }

    @Override
    public int getLogLevel() {
        return getLevel(logFilter);
    }

    @Override
    public boolean isLogEnabledForMethod() {
        return isEnabledForMethod(logFilter);
    }

    @Override
    public boolean isCountEnabled() {
        return isEnabled(countFilter);
    }

    @Override
    public boolean isMemUseTrackingEnabled() {
        return isEnabled(trackMemUseFilter);
    }

    @Override
    public int getDumpLevel() {
        return getLevel(dumpFilter);
    }

    @Override
    public boolean isDumpEnabledForMethod() {
        return isEnabledForMethod(dumpFilter);
    }

    @Override
    public boolean isVerifyEnabled() {
        return isEnabled(verifyFilter);
    }

    @Override
    public boolean isVerifyEnabledForMethod() {
        return isEnabledForMethod(verifyFilter);
    }

    @Override
    public boolean isMethodMeterEnabled() {
        return isEnabled(methodMetricsFilter);
    }

    @Override
    public boolean isTimeEnabled() {
        return isEnabled(timerFilter);
    }

    @Override
    public PrintStream output() {
        return output;
    }

    private boolean isEnabled(DebugFilter filter) {
        return getLevel(filter) > 0;
    }

    private int getLevel(DebugFilter filter) {
        int level;
        if (filter == null) {
            level = 0;
        } else {
            level = filter.matchLevel(Debug.currentScope());
        }
        if (level > 0 && !checkMethodFilter()) {
            level = 0;
        }
        return level;
    }

    private boolean isEnabledForMethod(DebugFilter filter) {
        return filter != null && checkMethodFilter();
    }

    /**
     * Extracts a {@link JavaMethod} from an opaque debug context.
     *
     * @return the {@link JavaMethod} represented by {@code context} or null
     */
    public static JavaMethod asJavaMethod(Object context) {
        if (context instanceof JavaMethodContext) {
            return ((JavaMethodContext) context).asJavaMethod();
        }
        if (context instanceof JavaMethod) {
            return (JavaMethod) context;
        }
        return null;
    }

    private boolean checkMethodFilter() {
        if (methodFilter == null && extraFilters.isEmpty()) {
            return true;
        } else {
            JavaMethod lastMethod = null;
            for (Object o : Debug.context()) {
                if (extraFilters.contains(o)) {
                    return true;
                } else if (methodFilter != null) {
                    JavaMethod method = asJavaMethod(o);
                    if (method != null) {
                        if (!Options.MethodFilterRootOnly.getValue()) {
                            if (org.graalvm.compiler.debug.MethodFilter.matches(methodFilter, method)) {
                                return true;
                            }
                        } else {
                            /*
                             * The context values operate as a stack so if we want MethodFilter to
                             * only apply to the root method we have to check only the last method
                             * seen.
                             */
                            lastMethod = method;
                        }
                    }
                }
            }
            if (lastMethod != null && org.graalvm.compiler.debug.MethodFilter.matches(methodFilter, lastMethod)) {
                return true;
            }
            return false;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Debug config:");
        add(sb, "Log", logFilter);
        add(sb, "Count", countFilter);
        add(sb, "MethodMeter", methodMetricsFilter);
        add(sb, "Time", timerFilter);
        add(sb, "Dump", dumpFilter);
        add(sb, "MethodFilter", methodFilter);
        return sb.toString();
    }

    private static void add(StringBuilder sb, String name, Object filter) {
        if (filter != null) {
            sb.append(' ');
            sb.append(name);
            sb.append('=');
            if (filter instanceof Object[]) {
                sb.append(Arrays.toString((Object[]) filter));
            } else {
                sb.append(String.valueOf(filter));
            }
        }
    }

    @Override
    public RuntimeException interceptException(Throwable e) {
        if (e instanceof BailoutException && !Options.InterceptBailout.getValue()) {
            return null;
        }
        Debug.setConfig(Debug.fixedConfig(Debug.BASIC_LOG_LEVEL, Debug.BASIC_LOG_LEVEL, false, false, false, false, false, dumpHandlers, verifyHandlers, output));
        Debug.log("Exception occurred in scope: %s", Debug.currentScope());
        Map<Object, Object> firstSeen = new IdentityHashMap<>();
        for (Object o : Debug.context()) {
            // Only dump a context object once.
            if (!firstSeen.containsKey(o)) {
                firstSeen.put(o, o);
                if (Options.DumpOnError.getValue()) {
                    Debug.dump(Debug.BASIC_LOG_LEVEL, o, "Exception: %s", e);
                } else {
                    Debug.log("Context obj %s", o);
                }
            }
        }
        return null;
    }

    @Override
    public Collection<DebugDumpHandler> dumpHandlers() {
        return dumpHandlers;
    }

    @Override
    public Collection<DebugVerifyHandler> verifyHandlers() {
        return verifyHandlers;
    }

    @Override
    public void addToContext(Object o) {
        extraFilters.add(o);
    }

    @Override
    public void removeFromContext(Object o) {
        extraFilters.remove(o);
    }

}