/*

 * Copyright (c) 1999, 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 com.sun.tools.javac.util;

import java.io.*;

import java.util.Arrays;

import java.util.EnumMap;

import java.util.EnumSet;

import java.util.HashSet;

import java.util.Map;

import java.util.Queue;

import java.util.Set;

import javax.tools.DiagnosticListener;

import javax.tools.JavaFileObject;

import com.sun.tools.javac.api.DiagnosticFormatter;

import com.sun.tools.javac.main.Main;

import com.sun.tools.javac.main.Option;

import com.sun.tools.javac.tree.EndPosTable;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticInfo;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticType;

import static com.sun.tools.javac.main.Option.*;

/** A class for error logs. Reports errors and warnings, and

 *  keeps track of error numbers and positions.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class Log extends AbstractLog {

    /** The context key for the log. */

    public static final Context.Key<Log> logKey = new Context.Key<>();

    /** The context key for the standard output PrintWriter. */

    public static final Context.Key<PrintWriter> outKey = new Context.Key<>();

    /** The context key for the diagnostic PrintWriter. */

    public static final Context.Key<PrintWriter> errKey = new Context.Key<>();

    /* TODO: Should unify this with prefix handling in JCDiagnostic.Factory. */

    public enum PrefixKind {

        JAVAC("javac."),

        COMPILER_MISC("compiler.misc.");

        PrefixKind(String v) {

            value = v;

        }

        public String key(String k) {

            return value + k;

        }

        final String value;

    }

    /**

     * DiagnosticHandler's provide the initial handling for diagnostics.

     * When a diagnostic handler is created and has been initialized, it

     * should install itself as the current diagnostic handler. When a

     * client has finished using a handler, the client should call

     * {@code log.removeDiagnosticHandler();}

     *

     * Note that javax.tools.DiagnosticListener (if set) is called later in the

     * diagnostic pipeline.

     */

    public static abstract class DiagnosticHandler {

        /**

         * The previously installed diagnostic handler.

         */

        protected DiagnosticHandler prev;

        /**

         * Install this diagnostic handler as the current one,

         * recording the previous one.

         */

        protected void install(Log log) {

            prev = log.diagnosticHandler;

            log.diagnosticHandler = this;

        }

        /**

         * Handle a diagnostic.

         */

        public abstract void report(JCDiagnostic diag);

    }

    /**

     * A DiagnosticHandler that discards all diagnostics.

     */

    public static class DiscardDiagnosticHandler extends DiagnosticHandler {

        public DiscardDiagnosticHandler(Log log) {

            install(log);

        }

        @Override

        public void report(JCDiagnostic diag) { }

    }

    /**

     * A DiagnosticHandler that can defer some or all diagnostics,

     * by buffering them for later examination and/or reporting.

     * If a diagnostic is not deferred, or is subsequently reported

     * with reportAllDiagnostics(), it will be reported to the previously

     * active diagnostic handler.

     */

    public static class DeferredDiagnosticHandler extends DiagnosticHandler {

        private Queue<JCDiagnostic> deferred = new ListBuffer<>();

        private final Filter<JCDiagnostic> filter;

        public DeferredDiagnosticHandler(Log log) {

            this(log, null);

        }

        public DeferredDiagnosticHandler(Log log, Filter<JCDiagnostic> filter) {

            this.filter = filter;

            install(log);

        }

        @Override

        public void report(JCDiagnostic diag) {

            if (!diag.isFlagSet(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE) &&

                (filter == null || filter.accepts(diag))) {

                deferred.add(diag);

            } else {

                prev.report(diag);

            }

        }

        public Queue<JCDiagnostic> getDiagnostics() {

            return deferred;

        }

        /** Report all deferred diagnostics. */

        public void reportDeferredDiagnostics() {

        }

        /** Report selected deferred diagnostics. */

            JCDiagnostic d;

            while ((d = deferred.poll()) != null) {

                    prev.report(d);

            }

            deferred = null; // prevent accidental ongoing use

        }

    }

    public enum WriterKind { NOTICE, WARNING, ERROR, STDOUT, STDERR }

    private final Map<WriterKind, PrintWriter> writers;

    /** The maximum number of errors/warnings that are reported.

     */

    protected int MaxErrors;

    protected int MaxWarnings;

    /** Switch: prompt user on each error.

     */

    public boolean promptOnError;

    /** Switch: emit warning messages.

     */

    public boolean emitWarnings;

    /** Switch: suppress note messages.

     */

    public boolean suppressNotes;

    /** Print stack trace on errors?

     */

    public boolean dumpOnError;

    /**

     * Diagnostic listener, if provided through programmatic

     * interface to javac (JSR 199).

     */

    protected DiagnosticListener<? super JavaFileObject> diagListener;

    /**

     * Formatter for diagnostics.

     */

    private DiagnosticFormatter<JCDiagnostic> diagFormatter;

    /**

     * Keys for expected diagnostics.

     */

    public Set<String> expectDiagKeys;

    /**

     * Set to true if a compressed diagnostic is reported

     */

    public boolean compressedOutput;

    /**

     * JavacMessages object used for localization.

     */

    private JavacMessages messages;

    /**

     * Handler for initial dispatch of diagnostics.

     */

    private DiagnosticHandler diagnosticHandler;

    /** Get the Log instance for this context. */

    public static Log instance(Context context) {

        Log instance = context.get(logKey);

        if (instance == null)

            instance = new Log(context);

        return instance;

    }

    /**

     * Register a Context.Factory to create a Log.

     */

    public static void preRegister(Context context, PrintWriter w) {

        context.put(Log.class, (Context.Factory<Log>) (c -> new Log(c, w)));

    }

    /**

     * Construct a log with default settings.

     * If no streams are set in the context, the log will be initialized to use

     * System.out for normal output, and System.err for all diagnostic output.

     * If one stream is set in the context, with either Log.outKey or Log.errKey,

     * it will be used for all output.

     * Otherwise, the log will be initialized to use both streams found in the context.

     */

    protected Log(Context context) {

        this(context, initWriters(context));

    }

    /**

     * Initialize a map of writers based on values found in the context

     * @param context the context in which to find writers to use

     * @return a map of writers

     */

    private static Map<WriterKind, PrintWriter> initWriters(Context context) {

        PrintWriter out = context.get(outKey);

        PrintWriter err = context.get(errKey);

        if (out == null && err == null) {

            out = new PrintWriter(System.out, true);

            err = new PrintWriter(System.err, true);

            return initWriters(out, err);

        } else if (out == null || err == null) {

            PrintWriter pw = (out != null) ? out : err;

            return initWriters(pw, pw);

        } else {

            return initWriters(out, err);

        }

    }

    /**

     * Construct a log with all output sent to a single output stream.

     */

    protected Log(Context context, PrintWriter writer) {

        this(context, initWriters(writer, writer));

    }

    /**

     * Construct a log.

     * The log will be initialized to use stdOut for normal output, and stdErr

     * for all diagnostic output.

     */

    protected Log(Context context, PrintWriter out, PrintWriter err) {

        this(context, initWriters(out, err));

    }

    /**

     * Initialize a writer map for a stream for normal output, and a stream for diagnostics.

     * @param out a stream to be used for normal output

     * @param err a stream to be used for diagnostic messages, such as errors, warnings, etc

     * @return a map of writers

     */

    private static Map<WriterKind, PrintWriter> initWriters(PrintWriter out, PrintWriter err) {

        Map<WriterKind, PrintWriter> writers = new EnumMap<>(WriterKind.class);

        writers.put(WriterKind.ERROR, err);

        writers.put(WriterKind.WARNING, err);

        writers.put(WriterKind.NOTICE, err);

        writers.put(WriterKind.STDOUT, out);

        writers.put(WriterKind.STDERR, err);

        return writers;

    }

    /**

     * Construct a log with given I/O redirections.

     * @deprecated

     * This constructor is provided to support the supported but now-deprecated javadoc entry point

     *      com.sun.tools.javadoc.Main.execute(String programName,

     *          PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter,

     *          String defaultDocletClassName, String... args)

     */

    @Deprecated

    protected Log(Context context, PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter) {

        this(context, initWriters(errWriter, warnWriter, noticeWriter));

    }

    /**

     * Initialize a writer map with different streams for different types of diagnostics.

     * @param errWriter a stream for writing error messages

     * @param warnWriter a stream for writing warning messages

     * @param noticeWriter a stream for writing notice messages

     * @return a map of writers

     * @deprecated This method exists to support a supported but now deprecated javadoc entry point.

     */

    @Deprecated

    private static Map<WriterKind, PrintWriter>  initWriters(PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter) {

        Map<WriterKind, PrintWriter> writers = new EnumMap<>(WriterKind.class);

        writers.put(WriterKind.ERROR, errWriter);

        writers.put(WriterKind.WARNING, warnWriter);

        writers.put(WriterKind.NOTICE, noticeWriter);

        writers.put(WriterKind.STDOUT, noticeWriter);

        writers.put(WriterKind.STDERR, errWriter);

        return writers;

    }

    /**

     * Creates a log.

     * @param context the context in which the log should be registered

     * @param writers a map of writers that can be accessed by the kind of writer required

     */

    private Log(Context context, Map<WriterKind, PrintWriter> writers) {

        super(JCDiagnostic.Factory.instance(context));

        context.put(logKey, this);

        this.writers = writers;

        @SuppressWarnings("unchecked") // FIXME

        DiagnosticListener<? super JavaFileObject> dl =

            context.get(DiagnosticListener.class);

        this.diagListener = dl;

        diagnosticHandler = new DefaultDiagnosticHandler();

        messages = JavacMessages.instance(context);

        messages.add(Main.javacBundleName);

        final Options options = Options.instance(context);

        initOptions(options);

        options.addListener(() -> initOptions(options));

    }

    // where

        private void initOptions(Options options) {

            this.dumpOnError = options.isSet(DOE);

            this.promptOnError = options.isSet(PROMPT);

            this.emitWarnings = options.isUnset(XLINT_CUSTOM, "none");

            this.suppressNotes = options.isSet("suppressNotes");

            this.MaxErrors = getIntOption(options, XMAXERRS, getDefaultMaxErrors());

            this.MaxWarnings = getIntOption(options, XMAXWARNS, getDefaultMaxWarnings());

            boolean rawDiagnostics = options.isSet("rawDiagnostics");

            this.diagFormatter = rawDiagnostics ? new RawDiagnosticFormatter(options) :

                                                  new BasicDiagnosticFormatter(options, messages);

            String ek = options.get("expectKeys");

            if (ek != null)

                expectDiagKeys = new HashSet<>(Arrays.asList(ek.split(", *")));

        }

        private int getIntOption(Options options, Option option, int defaultValue) {

            String s = options.get(option);

            try {

                if (s != null) {

                    int n = Integer.parseInt(s);

                    return (n <= 0 ? Integer.MAX_VALUE : n);

                }

            } catch (NumberFormatException e) {

                // silently ignore ill-formed numbers

            }

            return defaultValue;

        }

        /** Default value for -Xmaxerrs.

         */

        protected int getDefaultMaxErrors() {

            return 100;

        }

        /** Default value for -Xmaxwarns.

         */

        protected int getDefaultMaxWarnings() {

            return 100;

        }

    /** The number of errors encountered so far.

     */

    public int nerrors = 0;

    /** The number of warnings encountered so far.

     */

    public int nwarnings = 0;

    /** A set of all errors generated so far. This is used to avoid printing an

     *  error message more than once. For each error, a pair consisting of the

     *  source file name and source code position of the error is added to the set.

     */

    protected Set<Pair<JavaFileObject, Integer>> recorded = new HashSet<>();

    /** A set of "not-supported-in-source-X" errors produced so far. This is used to only generate

     *  one such error per file.

     */

    protected Set<Pair<JavaFileObject, List<String>>>  recordedSourceLevelErrors = new HashSet<>();

    public boolean hasDiagnosticListener() {

        return diagListener != null;

    }

    public void setEndPosTable(JavaFileObject name, EndPosTable endPosTable) {

        Assert.checkNonNull(name);

        getSource(name).setEndPosTable(endPosTable);

    }

    /** Return current sourcefile.

     */

    public JavaFileObject currentSourceFile() {

        return source == null ? null : source.getFile();

    }

    /** Get the current diagnostic formatter.

     */

    public DiagnosticFormatter<JCDiagnostic> getDiagnosticFormatter() {

        return diagFormatter;

    }

    /** Set the current diagnostic formatter.

     */

    public void setDiagnosticFormatter(DiagnosticFormatter<JCDiagnostic> diagFormatter) {

        this.diagFormatter = diagFormatter;

    }

    public PrintWriter getWriter(WriterKind kind) {

        return writers.get(kind);

    }

    public void setWriter(WriterKind kind, PrintWriter pw) {

        Assert.checkNonNull(pw);

        writers.put(kind, pw);

    }

    public void setWriters(PrintWriter pw) {

        Assert.checkNonNull(pw);

        for (WriterKind k: WriterKind.values())

            writers.put(k, pw);

    }

    /**

     * Replace the specified diagnostic handler with the

     * handler that was current at the time this handler was created.

     * The given handler must be the currently installed handler;

     * it must be specified explicitly for clarity and consistency checking.

     */

    public void popDiagnosticHandler(DiagnosticHandler h) {

        Assert.check(diagnosticHandler == h);

        diagnosticHandler = h.prev;

    }

    /** Flush the logs

     */

    public void flush() {

        for (PrintWriter pw: writers.values()) {

            pw.flush();

        }

    }