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

import static org.apache.juneau.commons.utils.Shorts.*;

import java.io.*;
import java.nio.charset.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;

import org.apache.juneau.microservice.logging.*;

/**
 * Utility class for reading log files.
 *
 * <p>
 * Provides the capability of returning splices of log files based on dates and filtering based on thread and logger
 * names.
 */
@SuppressWarnings({
   "java:S3776", // Cognitive complexity acceptable for log line parsing state machine
   "resource" // br is closed via this class's close() method
})
public class LogParser implements Iterable<LogParser.Entry>, Closeable {

   /**
    * Represents a single line from the log file.
    */
   @SuppressWarnings({
      "java:S1104" // Public fields accessed externally (e.g., le.severity)
   })
   public class Entry {
      /** Log entry timestamp. */
      public Date date;
      /** Log level (SEVERE, WARNING, INFO, etc.). */
      public String severity;
      /** Logger name (simple class name). */
      public String logger;
      protected String line;
      protected String text;
      protected String thread;
      protected List<String> additionalText;
      protected boolean isRecord;

      /**
       * Constructor.
       *
       * @param line The raw log line.
       * @throws IOException If parsing fails.
       */
      Entry(String line) throws IOException {
         try {
            this.line = line;
            Matcher m = formatter.getLogEntryPattern().matcher(line);
            if (m.matches()) {
               isRecord = true;
               String s = formatter.getField("date", m);
               if (nn(s))
                  date = formatter.getDateFormat().parse(s);
               thread = formatter.getField("thread", m);
               severity = formatter.getField("level", m);
               logger = formatter.getField("logger", m);
               text = formatter.getField("msg", m);
               if (nn(logger) && logger.indexOf('.') > -1)
                  logger = logger.substring(logger.lastIndexOf('.') + 1);
            }
         } catch (ParseException e) {
            throw ioex(e);
         }
      }

      /**
       * Appends HTML-escaped log entry to the writer.
       *
       * @param w The writer.
       * @return The writer for chaining.
       * @throws IOException If writing fails.
       */
      public Writer appendHtml(Writer w) throws IOException {
         w.append(toHtml(line)).append("<br>");
         if (nn(additionalText))
            for (var t : additionalText)
               w.append(toHtml(t)).append("<br>");
         return w;
      }

      /**
       * Returns the full log message text, including additional stacked lines.
       *
       * @return The message text.
       */
      public String getText() {
         if (additionalText == null)
            return text;
         int i = text.length();
         for (var s : additionalText)
            i += s.length() + 1;
         var sb = new StringBuilder(i);
         sb.append(text);
         for (var s : additionalText)
            sb.append('\n').append(s);
         return sb.toString();
      }

      /**
       * Returns the thread name.
       *
       * @return The thread name.
       */
      public String getThread() { return thread; }

      protected Writer append(Writer w) throws IOException {
         w.append(line).append('\n');
         if (nn(additionalText))
            for (var t : additionalText)
               w.append(t).append('\n');
         return w;
      }

      void addText(String t) {
         if (additionalText == null)
            additionalText = ll();
         additionalText.add(t);
      }

      boolean matches() {
         return isRecord
            && !(nn(start) && nn(date) && date.before(start))
            && !(nn(end) && nn(date) && date.after(end))
            && !(nn(threadFilter) && neq(threadFilter, thread))
            && !(nn(loggerFilter) && ! loggerFilter.contains(logger))
            && !(nn(severityFilter) && ! severityFilter.contains(severity));
      }
   }

   static String toHtml(String s) {
      if (s.indexOf('<') != -1)
         return s.replace("<", "&lt;");//$NON-NLS-2$
      return s;
   }

   private BufferedReader br;
   LogEntryFormatter formatter;
   Date start;
   Date end;
   Set<String> loggerFilter;
   Set<String> severityFilter;

   String threadFilter;

   private List<Entry> entries;

   /**
    * Constructor.
    *
    * @param formatter The log entry formatter.
    * @param f The log file.
    * @param start Don't return rows before this date.  If <jk>null</jk>, start from the beginning of the file.
    * @param end Don't return rows after this date.  If <jk>null</jk>, go to the end of the file.
    * @param thread Only return log entries with this thread name.
    * @param loggers Only return log entries produced by these loggers (simple class names).
    * @param severity Only return log entries with the specified severity.
    * @throws IOException Thrown by underlying stream.
    */
   public LogParser(LogEntryFormatter formatter, File f, Date start, Date end, String thread, String[] loggers, String[] severity) throws IOException {
      this.formatter = formatter;
      this.start = start;
      this.end = end;
      this.threadFilter = thread;
      if (nn(loggers))
         this.loggerFilter = st(loggers);
      if (nn(severity))
         this.severityFilter = st(severity);

      // Buffer all matching entries to support multiple traversal.
      // Close the reader in a finally so a parse failure mid-loop doesn't leak the file descriptor.
      br = new BufferedReader(new InputStreamReader(new FileInputStream(f), Charset.defaultCharset()));
      try {
         List<Entry> allEntries = l();
         Entry prev = null;
         String line;
         while (nn(line = br.readLine())) {
            var e = new Entry(line);
            if (e.isRecord) {
               if (nn(prev))
                  allEntries.add(prev);
               prev = e.matches() ? e : null;
            } else {
               if (prev != null)
                  prev.addText(e.line);
            }
         }
         if (nn(prev))
            allEntries.add(prev);
         this.entries = allEntries;
      } finally {
         br.close();
         br = null;
      }
   }

   @Override /* Overridden from Closeable */
   public void close() throws IOException {
      if (nn(br)) {
         br.close();
         br = null;
      }
   }

   /**
    * Returns whether any entries are available.
    *
    * @return <jk>true</jk> if entries are available, <jk>false</jk> otherwise.
    */
   public boolean hasNext() {
      return !entries.isEmpty();
   }

   @Override /* Overridden from Iterable */
   public Iterator<Entry> iterator() {
      return entries.iterator();
   }

   /**
    * Serializes the contents of the parsed log file to the specified writer and then closes the underlying reader.
    *
    * @param w The writer to write the log file to.
    * @throws IOException Thrown by underlying stream.
    */
   public void writeTo(Writer w) throws IOException {
      try {
         if (! hasNext())
            w.append("[EMPTY]");
         else
            for (var le : this)
               le.append(w);
      } finally {
         close();
      }
   }
}