/*
 * 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.rest.server.stats;

import static java.util.Comparator.*;
import static java.util.stream.Collectors.toSet;
import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.ObjectUtils.*;
import static org.apache.juneau.commons.utils.Shorts.*;

import java.time.*;
import java.util.*;
import java.util.concurrent.*;

import org.apache.juneau.commons.inject.*;

/**
 * An in-memory cache of thrown exceptions.
 *
 * <p>
 * Used for preventing duplication of stack traces in log files and replacing them with small hashes.
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/ExecutionStatistics">REST method execution statistics</a>
 * </ul>
 */
public class ThrownStore {

   /**
    * Builder class.
    */
   public static class Builder {

      final BeanStore beanStore;
      ThrownStore parent;
      Class<? extends ThrownStats> statsImplClass;
      Set<Class<?>> ignoreClasses;
      Clock clock;

      private ThrownStore impl;
      private Class<? extends ThrownStore> type;

      /**
       * Constructor.
       *
       * @param beanStore The bean store to use for creating beans.
       */
      protected Builder(BeanStore beanStore) {
         this.beanStore = beanStore;
      }

      /**
       * Returns the bean store.
       *
       * @return The bean store.
       */
      public BeanStore beanStore() {
         return beanStore;
      }

      /**
       * Specifies the clock used to stamp the first and last occurrence times of recorded exceptions.
       *
       * <p>
       * Defaults to the parent store's clock, or {@link Clock#systemUTC()} if there is no parent.  Tests can pass
       * {@link Clock#fixed(Instant, ZoneId)} to make the occurrence times reported by {@link ThrownStats} deterministic.
       *
       * @param value The new value for this setting.  Can be <jk>null</jk> (inherits the default).
       * @return This object.
       */
      public Builder clock(Clock value) {
         clock = value;
         return this;
      }

      /**
       * Specifies the list of classes to ignore when calculating stack traces.
       *
       * <p>
       * Stack trace elements that are the specified class will be ignored.
       *
       * @param value The list of classes to ignore.
       * @return This object.
       */
      public Builder ignoreClasses(Class<?>...value) {
         this.ignoreClasses = set(value);
         return this;
      }

      /**
       * Overrides the bean returned by the {@link #build()} method with a pre-instantiated instance.
       *
       * @param value The setting value. Can be <jk>null</jk> (the {@link #build()} method instantiates the {@link #type(Class) type} instead).
       * @return This object.
       */
      public Builder impl(Object value) {
         impl = (ThrownStore) value;
         return this;
      }

      /**
       * Specifies the parent store of this store.
       *
       * <p>
       * Parent stores are used for aggregating statistics across multiple child stores.
       * <br>The {@link ThrownStore#GLOBAL} store can be used for aggregating all thrown exceptions in a single JVM.
       *
       * @param value The parent store.  Can be <jk>null</jk> for a root store with no parent chain.
       * @return This object.
       */
      public Builder parent(ThrownStore value) {
         parent = value;
         return this;
      }

      /**
       * Specifies a subclass of {@link ThrownStats} to use for individual method statistics.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public Builder statsImplClass(Class<? extends ThrownStats> value) {
         statsImplClass = value;
         return this;
      }

      /**
       * Overrides the bean type produced by the {@link #build()} method.
       *
       * @param value The setting value. Can be <jk>null</jk> (defaults to {@link ThrownStore}).
       * @return This object.
       */
      @SuppressWarnings({
         "unchecked" // Type erasure on reflective/generic cast; element type is verified at call site
      })
      public Builder type(Class<?> value) {
         type = (Class<? extends ThrownStore>) value;
         return this;
      }

      /**
       * Creates the bean.
       *
       * @return A new bean.
       */
      public ThrownStore build() {
         if (nn(impl))
            return impl;
         if (type == null || type == ThrownStore.class)
            return new ThrownStore(this);
         return BeanInstantiator.of(ThrownStore.class, beanStore)
            .type(type)
            .noBuilder()
            .addBean(Builder.class, this)
            .run();
      }
   }

   /** Identifies a single global store for the entire JVM. */
   public static final ThrownStore GLOBAL = new ThrownStore();

   /**
    * Static creator.
    *
    * @return A new builder for this object.
    */
   public static Builder create() {
      return new Builder(BasicBeanStore.INSTANCE);
   }

   /**
    * Static creator.
    *
    * @param beanStore The bean store to use for creating beans.
    * @return A new builder for this object.
    */
   public static Builder create(BeanStore beanStore) {
      return new Builder(beanStore);
   }

   private final ConcurrentHashMap<Long,ThrownStats> db = new ConcurrentHashMap<>();
   private final Optional<ThrownStore> parent;
   private final BeanStore beanStore;
   private final Class<? extends ThrownStats> statsImplClass;
   private final Set<String> ignoreClasses;
   private final Clock clock;

   /**
    * Constructor.
    */
   public ThrownStore() {
      this(create(BasicBeanStore.INSTANCE));
   }

   /**
    * Constructor.
    *
    * @param builder The builder for this object. Must not be <jk>null</jk>.
    */
   public ThrownStore(Builder builder) {
      this.parent = o(builder.parent);
      this.beanStore = builder.beanStore();

      this.statsImplClass = coalesce(builder.statsImplClass, parent.isPresent() ? parent.get().statsImplClass : null, null);
      this.clock = coalesce(builder.clock, parent.isPresent() ? parent.get().clock : null, Clock.systemUTC());

      Set<String> s = null;
      if (nn(builder.ignoreClasses))
         s = builder.ignoreClasses.stream().map(Class::getName).collect(toSet());
      if (s == null && parent.isPresent())
         s = parent.get().ignoreClasses;
      if (s == null)
         s = Collections.emptySet();
      this.ignoreClasses = u(s);
   }

   /**
    * Adds the specified thrown exception to this database.
    *
    * @param e The exception to add.
    * @return This object.
    */
   @SuppressWarnings({
      "javabugs:S2259" // The exception must not be null, per the Javadoc contract; find() returns null only for a null input.
   })
   public ThrownStats add(Throwable e) {
      ThrownStats s = find(e);
      s.increment();
      parent.ifPresent(x -> x.add(e));
      return s;
   }

   /**
    * Returns the list of all stack traces in this database.
    *
    * @return The list of all stack traces in this database, cloned and sorted by count descending.
    */
   public List<ThrownStats> getStats() { return db.values().stream().map(ThrownStats::copyOrNull).sorted(comparingInt(ThrownStats::getCount).reversed()).toList(); }

   /**
    * Retrieves the stack trace information for the exception with the specified hash as calculated by {@link #hash(Throwable)}.
    *
    * @param hash The hash of the exception.
    * @return A clone of the stack trace info, never <jk>null</jk>.
    */
   public Optional<ThrownStats> getStats(long hash) {
      ThrownStats s = db.get(hash);
      return o(ThrownStats.copyOrNull(s));
   }

   /**
    * Retrieves the stats for the specified thrown exception.
    *
    * @param e The exception. Must not be <jk>null</jk>.
    * @return A clone of the stats, never <jk>null</jk>.
    */
   public Optional<ThrownStats> getStats(Throwable e) {
      return getStats(hash(e));
   }

   /**
    * Clears out the stack trace cache.
    */
   public void reset() {
      db.clear();
   }

   private ThrownStats find(Throwable t) {

      if (t == null)
         return null;

      long hash = hash(t);

      ThrownStats stc = db.get(hash);
      if (stc == null) {
         // @formatter:off
         stc = ThrownStats
            .create(beanStore)
            .type(statsImplClass)
            .clock(clock)
            .throwable(t)
            .hash(hash)
            .stackTrace(createStackTrace(t))
            .causedBy(find(t.getCause()))
            .build();
         // @formatter:on

         db.putIfAbsent(hash, stc);
         stc = db.get(hash);
      }

      return stc;
   }

   /**
    * Converts the stack trace for the specified throwable into a simple list of strings.
    *
    * <p>
    * The stack trace elements for the throwable are sent through {@link #normalize(StackTraceElement)} to convert
    * them to simple strings.
    *
    *
    * @param t The throwable to create the stack trace for. Must not be <jk>null</jk>.
    * @return A modifiable list of strings.
    */
   protected List<String> createStackTrace(Throwable t) {
      return l(t.getStackTrace()).stream().filter(this::include).map(this::normalize).toList();
   }

   /**
    * Calculates a 32-bit hash for the specified throwable based on the stack trace generated by {@link #createStackTrace(Throwable)}.
    *
    * <p>
    * Subclasses can override this method to provide their own implementation.
    *
    * @param t The throwable to calculate the stack trace on. Must not be <jk>null</jk>.
    * @return A calculated hash.
    */
   protected long hash(Throwable t) {
      long h = 1125899906842597L; // prime
      for (var s : createStackTrace(t)) {
         var len = s.length();
         for (var i = 0; i < len; i++)
            h = 31 * h + s.charAt(i);
      }
      return h;
   }

   /**
    * Returns <jk>true</jk> if the specified stack trace element should be included in {@link #createStackTrace(Throwable)}.
    *
    * @param e The stack trace element.
    * @return <jk>true</jk> if the specified stack trace element should be included in {@link #createStackTrace(Throwable)}.
    */
   protected boolean include(StackTraceElement e) {
      return true;
   }

   /**
    * Converts the specified stack trace element into a normalized string.
    *
    * <p>
    * The default implementation simply replaces <js>"\\$.*"</js> with <js>"..."</js> which should take care of stuff like stack
    * trace elements of lambda expressions.
    *
    * @param e The stack trace element to convert. Must not be <jk>null</jk>.
    * @return The converted stack trace element.
    */
   protected String normalize(StackTraceElement e) {
      if (ignoreClasses.contains(e.getClassName()))
         return "<ignored>";
      var s = e.toString();
      var i = s.indexOf('$');
      if (i == -1)
         return s;
      var j = s.indexOf('(', i);
      if (j == -1)
         return s;  // Probably can't happen.
      var s2 = s.substring(0, i);
      var s3 = s.substring(j);
      if (ignoreClasses.contains(s2))
         return "<ignored>";
      return s2 + "..." + s3;
   }
}