/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.juneau.microservice.logging;

import static org.apache.juneau.commons.lang.StateEnum.*;
import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.commons.utils.ThrowableUtils.*;

import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
import java.util.logging.Formatter;
import java.util.regex.*;

/**
 * Log entry formatter.
 *
 * <p>
 * Uses three simple parameter for configuring log entry formats:
 * <ul class='spaced-list'>
 *    <li>
 *       <c>dateFormat</c> - A {@link SimpleDateFormat} string describing the format for dates.
 *    <li>
 *       <c>format</c> - A string with <c>{...}</c> replacement variables representing predefined fields.
 *    <li>
 *       <c>useStackTraceHashes</c> - A setting that causes duplicate stack traces to be replaced with 8-character
 *        hash strings.
 * </ul>
 *
 * <p>
 * This class converts the format strings into a regular expression that can be used to parse the resulting log file.
 */
@SuppressWarnings({
   "java:S2143" // Public API built on SimpleDateFormat/Date for Formatter compatibility; getDateFormat() returns DateFormat as a contract.
})
public class LogEntryFormatter extends Formatter {

   private static String hashCode(Throwable t) {
      int i = 0;
      while (nn(t)) {
         for (var e : t.getStackTrace())
            i ^= e.hashCode();
         t = t.getCause();
      }
      return Integer.toHexString(i);
   }

   // Appends a single character to the log-parsing regex as a literal, escaping it when it is a regex
   // metacharacter.  The format and date-format strings are caller-supplied configuration, so their
   // literal characters must be escaped to keep them matched verbatim and prevent regex-injection.
   private static void appendLiteral(StringBuilder re, char c) {
      if (! (Character.isLetterOrDigit(c) || Character.isWhitespace(c)))
         re.append('\\');
      re.append(c);
   }

   // Appends each character of a string to the log-parsing regex as a literal (see {@link #appendLiteral(StringBuilder, char)}).
   private static void appendLiteral(StringBuilder re, String s) {
      for (var i = 0; i < s.length(); i++)
         appendLiteral(re, s.charAt(i));
   }

   // Converts a SimpleDateFormat pattern into a regex fragment that matches formatted dates: date/time pattern
   // letters become "\d" matchers and all other characters are treated as regex literals.  Escaping the
   // non-letter characters (rather than only ".") prevents regex-injection from a caller-supplied date format.
   private static String dateFormatToRegex(String dateFormat) {
      var re = new StringBuilder();
      for (var i = 0; i < dateFormat.length(); i++) {
         var c = dateFormat.charAt(i);
         if ("mHhsSdMy".indexOf(c) >= 0)
            re.append("\\d");
         else
            appendLiteral(re, c);
      }
      return re.toString();
   }

   private ConcurrentHashMap<String,AtomicInteger> hashes;
   private final DateFormat df;
   private final String format;
   private final Pattern rePattern;

   private Map<String,Integer> fieldIndexes;

   /**
    * Create a new formatter.
    *
    * @param format
    *    The log entry format.  e.g. <js>"[{date} {level}] {msg}%n"</js>
    *    The string can contain any of the following variables:
    *    <ol>
    *       <li><js>"{date}"</js> - The date, formatted per <js>"Logging/dateFormat"</js>.
    *       <li><js>"{class}"</js> - The class name.
    *       <li><js>"{method}"</js> - The method name.
    *       <li><js>"{logger}"</js> - The logger name.
    *       <li><js>"{level}"</js> - The log level name.
    *       <li><js>"{msg}"</js> - The log message.
    *       <li><js>"{threadid}"</js> - The thread ID.
    *       <li><js>"{exception}"</js> - The localized exception message.
    *       <li><js>"{traceId}"</js> - The active OpenTelemetry trace ID (empty when OTel is absent or no span is active).
    *       <li><js>"{spanId}"</js> - The active OpenTelemetry span ID (empty when OTel is absent or no span is active).
    *    </ol>
    *    Must not be <jk>null</jk>.
    * @param dateFormat
    *    The {@link SimpleDateFormat} format to use for dates.  e.g. <js>"yyyy.MM.dd hh:mm:ss"</js>.
    *    <br>Must not be <jk>null</jk>.
    * @param useStackTraceHashes
    *    If <jk>true</jk>, only print unique stack traces once and then refer to them by a simple 8 character hash
    *    identifier.
    */
   @SuppressWarnings({
      "java:S3776" // Cognitive complexity acceptable for console command logic
   })
   public LogEntryFormatter(String format, String dateFormat, boolean useStackTraceHashes) {
      this.df = new SimpleDateFormat(dateFormat);
      if (useStackTraceHashes)
         hashes = new ConcurrentHashMap<>();

      fieldIndexes = m();

      // @formatter:off
      format = format
         .replace("{date}", "%1$s")
         .replace("{class}", "%2$s")
         .replace("{method}", "%3$s")
         .replace("{logger}", "%4$s")
         .replace("{level}", "%5$s")
         .replace("{msg}", "%6$s")
         .replace("{threadid}", "%7$s")
         .replace("{exception}", "%8$s")
         .replace("{traceId}", "%9$s")
         .replace("{spanId}", "%10$s");
      // @formatter:on

      this.format = format;

      // Construct a regular expression to match this log entry.
      int index = 1;
      var re = new StringBuilder();

      // The parser state machine uses four states while scanning for format placeholders.
      // In state S1 we are looking for a percent sign.
      // In state S2 we have found a percent sign and are looking for a number.
      // In state S3 we have found a number and are looking for a dollar sign.
      // In state S4 we have found a dollar sign and are looking for an 's'.
      var state = S1;
      int i1 = 0;
      for (var i = 0; i < format.length(); i++) {
         var c = format.charAt(i);
         if (state == S1) {
            if (c == '%')
               state = S2;
            else
               appendLiteral(re, c);
         } else if (state == S2) {
            if (Character.isDigit(c)) {
               i1 = i;
               state = S3;
            } else {
               re.append("\\%");
               appendLiteral(re, c);
               state = S1;
            }
         } else if (state == S3) {  // NOSONAR - State check necessary for state machine
            if (c == '$') {
               state = S4;
            } else if (Character.isDigit(c)) {
               // Stay in S3: group numbers may be multi-digit (e.g. %10$s for {spanId}).
               state = S3;  // NOSONAR - explicit self-transition documents the multi-digit case
            } else {
               re.append("\\%");
               appendLiteral(re, format.substring(i1, i)); // HTT - requires %digit followed by non-$ which can't come from standard format placeholders
               state = S1;
            }
         } else if (state == S4) {
            if (c == 's') {
               int group = Integer.parseInt(format.substring(i1, i - 1));
               switch (group) {
                  case 1:
                     fieldIndexes.put("date", index++);
                     re.append("(").append(dateFormatToRegex(dateFormat)).append(")");
                     break;
                  case 2:
                     fieldIndexes.put("class", index++);
                     re.append("([\\p{javaJavaIdentifierPart}\\.]+)");
                     break;
                  case 3:
                     fieldIndexes.put("method", index++);
                     re.append("([\\p{javaJavaIdentifierPart}\\.]+)");
                     break;
                  case 4:
                     fieldIndexes.put("logger", index++);
                     re.append("([\\w\\d\\.\\_]+)");
                     break;
                  case 5:
                     fieldIndexes.put("level", index++);
                     re.append("(SEVERE|WARNING|INFO|CONFIG|FINE|FINER|FINEST)");
                     break;
                  case 6:
                     fieldIndexes.put("msg", index++);
                     re.append("(.*)");
                     break;
                  case 7:
                     fieldIndexes.put("threadid", index++);
                     re.append("(\\\\d+)");
                     break;
                  case 8:
                     fieldIndexes.put("exception", index++);
                     re.append("(.*)");
                     break;
                  case 9:
                     fieldIndexes.put("traceId", index++);
                     re.append("([0-9a-f]*)");
                     break;
                  case 10:
                     fieldIndexes.put("spanId", index++);
                     re.append("([0-9a-f]*)");
                     break;
                  default: // HTT - group numbers > 10 would require a format placeholder beyond {spanId} // NOSONAR
               }
            } else {
               re.append("\\%");
               appendLiteral(re, format.substring(i1, i)); // HTT - requires %digit$ followed by non-s which can't come from standard format placeholders
            }
            state = S1;
         }
      }

      // The log parser
      var sre = re.toString();
      if (sre.endsWith("\\%n"))
         sre = sre.substring(0, sre.length() - 3);

      // Replace instances of %n.
      sre = sre.replace("\\\\%n", "\\\\n");

      rePattern = Pattern.compile(sre);
      fieldIndexes = cp(fieldIndexes);
   }

   @SuppressWarnings({
      "deprecation" // Uses deprecated API for compatibility
   })
   @Override /* Overridden from Formatter */
   public String format(LogRecord r) {
      String msg = formatMessage(r);
      Throwable t = r.getThrown();
      String hash = null;
      int c = 0;
      if (nn(hashes) && nn(t)) {
         hash = hashCode(t);
         hashes.putIfAbsent(hash, new AtomicInteger(0));
         c = hashes.get(hash).incrementAndGet();
         if (c == 1) {
            msg = '[' + hash + '.' + c + "] " + msg;
         } else {
            msg = '[' + hash + '.' + c + "] " + msg + ", " + localizedMessage(t);
            t = null;
         }
      }
      // SimpleDateFormat is not thread-safe; guard the shared instance so concurrent log records don't corrupt formatting.
      String date;
      synchronized (df) {
         date = df.format(new Date(r.getMillis()));
      }
      var s = String.format(Locale.ROOT, format, date, r.getSourceClassName(), r.getSourceMethodName(), r.getLoggerName(), r.getLevel(), msg, r.getThreadID(),
         r.getThrown() == null ? "" : r.getThrown().getMessage(), TraceContext.currentTraceId(), TraceContext.currentSpanId());
      if (nn(t))
         s += String.format(Locale.ROOT, "%n%s", getStackTrace(r.getThrown()));
      return s;
   }

   /**
    * Returns the {@link DateFormat} used for matching dates.
    *
    * <p>
    * Returns a defensive {@link DateFormat#clone() clone} because {@link SimpleDateFormat} is mutable and not
    * thread-safe; each caller gets its own instance and cannot corrupt the formatter's shared internal state.
    *
    * @return A clone of the {@link DateFormat} used for matching dates.
    */
   public DateFormat getDateFormat() {
      synchronized (df) {
         return (DateFormat) df.clone();
      }
   }

   /**
    * Given a matcher that has matched the pattern specified by {@link #getLogEntryPattern()}, returns the field value
    * from the match.
    *
    * @param fieldName
    *    The field name.
    *    Possible values are:
    *    <ul>
    *       <li><js>"date"</js>
    *       <li><js>"class"</js>
    *       <li><js>"method"</js>
    *       <li><js>"logger"</js>
    *       <li><js>"level"</js>
    *       <li><js>"msg"</js>
    *       <li><js>"threadid"</js>
    *       <li><js>"exception"</js>
    *       <li><js>"traceId"</js>
    *       <li><js>"spanId"</js>
    *    </ul>
    * @param m The matcher.  Must not be <jk>null</jk>.
    * @return The field value, or <jk>null</jk> if the specified field does not exist.
    */
   public String getField(String fieldName, Matcher m) {
      Integer i = fieldIndexes.get(fieldName);
      return (i == null ? null : m.group(i));
   }

   /**
    * Returns the regular expression pattern used for matching log entries.
    *
    * @return The regular expression pattern used for matching log entries.
    */
   public Pattern getLogEntryPattern() { return rePattern; }
}