/*
 * 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 org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.Shorts.*;

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

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

/**
 * Represents an entry in {@link ThrownStore}.
 *
 * <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>
 */
@SuppressWarnings({
   "java:S1192" // Duplicated literals (argument/property names) read more clearly inline than as constants
})
public class ThrownStats {

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

      final BeanStore beanStore;
      Throwable throwable;
      long hash;
      List<String> stackTrace;
      ThrownStats causedBy;
      Clock clock = Clock.systemUTC();

      private Class<? extends ThrownStats> implType;

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

      /**
       * Create a new {@link ThrownStats} using this builder.
       *
       * @return A new {@link ThrownStats}
       */
      public ThrownStats build() {
         var t = or(implType, ThrownStats.class);
         return BeanInstantiator.of(ThrownStats.class, beanStore)
            .type(t)
            .noBuilder()
            .addBean(Builder.class, this)
            .run();
      }

      /**
       * Specifies the caused-by exception.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public Builder causedBy(ThrownStats value) {
         causedBy = value;
         return this;
      }

      /**
       * Specifies the clock used to stamp the first and last occurrence times.
       *
       * <p>
       * Defaults to {@link Clock#systemUTC()}.  Tests can pass {@link Clock#fixed(Instant, ZoneId)} to make the
       * reported occurrence times deterministic.
       *
       * @param value The new value for this setting.  Must not be <jk>null</jk>.
       * @return This object.
       */
      public Builder clock(Clock value) {
         clock = reqnn("value", value);
         return this;
      }

      /**
       * Specifies the calculated hash.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public Builder hash(long value) {
         hash = value;
         return this;
      }

      /**
       * Specifies the normalized stacktrace.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public Builder stackTrace(List<String> value) {
         stackTrace = value;
         return this;
      }

      /**
       * Specifies the thrown exception.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public Builder throwable(Throwable value) {
         throwable = value;
         return this;
      }

      /**
       * Specifies a subclass of {@link ThrownStats} to create when the {@link #build()} method is called.
       *
       * @param value The new value for this setting. Can be <jk>null</jk> (defaults to {@link ThrownStats}).
       * @return This object.
       */
      public Builder type(Class<? extends ThrownStats> value) {
         implType = o(value).isPresent() ? value : ThrownStats.class;
         return this;
      }
   }

   /**
    * 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 long guid;
   private final long hash;
   private final Class<?> thrownClass;
   private final String firstMessage;
   private final List<String> stackTrace;
   private final Optional<ThrownStats> causedBy;

   private final Clock clock;
   private final AtomicInteger count;
   private final AtomicLong firstOccurrence;
   private final AtomicLong lastOccurrence;

   /**
    * Copy constructor.
    */
   private ThrownStats(ThrownStats x) {
      this.guid = x.guid;
      this.thrownClass = x.thrownClass;
      this.firstMessage = x.firstMessage;
      this.stackTrace = u(cp(x.stackTrace));
      this.causedBy = o(ThrownStats.copyOrNull(x.causedBy.orElse(null)));
      this.hash = x.hash;
      this.clock = x.clock;
      this.count = new AtomicInteger(x.count.get());
      this.firstOccurrence = new AtomicLong(x.firstOccurrence.get());
      this.lastOccurrence = new AtomicLong(x.lastOccurrence.get());
   }

   /**
    * Null-safe copy: returns a deep copy of the specified value, or <jk>null</jk> if the value is <jk>null</jk>.
    *
    * @param value The value to copy.  Can be <jk>null</jk>, in which case <jk>null</jk> is returned.
    * @return A copy of the value, or <jk>null</jk> if the value was <jk>null</jk>.
    */
   public static ThrownStats copyOrNull(ThrownStats value) {
      return value == null ? null : new ThrownStats(value);
   }

   /**
    * Constructor.
    *
    * @param builder The builder for this object. Must not be <jk>null</jk>.
    */
   protected ThrownStats(Builder builder) {
      this.guid = new Random().nextLong();
      this.thrownClass = builder.throwable.getClass();
      this.firstMessage = builder.throwable.getMessage();
      this.stackTrace = u(cp(builder.stackTrace));
      this.causedBy = o(builder.causedBy);
      this.hash = builder.hash;
      this.clock = builder.clock;
      this.count = new AtomicInteger(0);
      long ct = clock.millis();
      this.firstOccurrence = new AtomicLong(ct);
      this.lastOccurrence = new AtomicLong(ct);
   }


   /**
    * Returns the stats on the caused-by exception.
    *
    * @return The stats on the caused-by exception, never <jk>null</jk>.
    */
   public Optional<ThrownStats> getCausedBy() { return causedBy; }

   /**
    * Returns the number of times this exception occurred at a specific location in code.
    *
    * @return The number of times this exception occurred at a specific location in code.
    */
   public int getCount() { return count.intValue(); }

   /**
    * Returns the message of the first exception at a specific location in code.
    *
    * @return The message of the first exception at a specific location in code, or <jk>null</jk> if the exception had no message.
    */
   public String getFirstMessage() { return firstMessage; }

   /**
    * Returns the UTC time of the first occurrence of this exception at a specific location in code.
    *
    * @return The UTC time of the first occurrence of this exception at a specific location in code.
    */
   public long getFirstOccurrence() { return firstOccurrence.longValue(); }

   /**
    * Returns a globally unique ID for this object.
    *
    * <p>
    * A random long generated during the creation of this object.
    * Allows this object to be differentiated from other similar objects in multi-node environments so that
    * statistics can be reliably stored in a centralized location.
    *
    * @return The globally unique ID for this object.
    */
   public long getGuid() { return guid; }

   /**
    * Returns a hash of this exception that can typically be used to uniquely identify it.
    *
    * @return A hash of this exception.
    */
   public long getHash() { return hash; }

   /**
    * Returns the UTC time of the last occurrence of this exception at a specific location in code.
    *
    * @return The UTC time of the last occurrence of this exception at a specific location in code.
    */
   public long getLastOccurrence() { return lastOccurrence.longValue(); }

   /**
    * Returns the stack trace of the first exception at a specific location in code.
    *
    * @return The stack trace of the first exception at a specific location in code.
    */
   public List<String> getStackTrace() { return stackTrace; }

   /**
    * Returns the exception class.
    *
    * @return The exception class.
    */
   public Class<?> getThrownClass() { return thrownClass; }

   /**
    * Increments the occurrence count of this exception.
    *
    * @return This object.
    */
   public ThrownStats increment() {
      count.incrementAndGet();
      lastOccurrence.set(clock.millis());
      causedBy.ifPresent(ThrownStats::increment);
      return this;
   }

   protected FluentMap<String,Object> properties() {
      // @formatter:off
      return filteredBeanPropertyMap()
         .a("causedBy", causedBy.orElse(null))
         .a("count", getCount())
         .a("firstMessage", firstMessage)
         .a("firstOccurrence", getFirstOccurrence())
         .a("guid", guid)
         .a("hash", hash)
         .a("lastOccurrence", getLastOccurrence())
         .a("stackTrace", stackTrace)
         .a("thrownClass", thrownClass);
      // @formatter:on
   }

   @Override /* Overridden from Object */
   public String toString() {
      return r(properties());
   }
}