/*
    * The contents of this file are subject to the terms of the Common Development and
    * Distribution License (the License). You may not use this file except in compliance with the
    * License.
    *
    * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
    * specific language governing permission and limitations under the License.
    *
    * When distributing Covered Software, include this CDDL Header Notice in each file and include
   * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
   * Header, with the fields enclosed by brackets [] replaced by your own identifying
   * information: "Portions copyright [year] [name of copyright owner]".
   *
   * Copyright 2014-2016 ForgeRock AS.
   */
  
  package org.forgerock.util.time;
  
  import static java.lang.String.format;
  import static java.util.Arrays.asList;
  import static java.util.concurrent.TimeUnit.DAYS;
  import static java.util.concurrent.TimeUnit.HOURS;
  import static java.util.concurrent.TimeUnit.MICROSECONDS;
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  import static java.util.concurrent.TimeUnit.MINUTES;
  import static java.util.concurrent.TimeUnit.NANOSECONDS;
  import static java.util.concurrent.TimeUnit.SECONDS;
  import static org.forgerock.util.Reject.checkNotNull;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Set;
  import java.util.TreeSet;
  import java.util.concurrent.TimeUnit;
  
  import org.forgerock.util.Reject;
  
  /**
   * Represents a duration in english. Cases is not important, plurals units are accepted.
   * Notice that negative durations are not supported.
   *
   * <code>
   *     6 days
   *     59 minutes and 1 millisecond
   *     1 minute and 10 seconds
   *     42 millis
   *     unlimited
   *     none
   *     zero
   * </code>
   */
  public class Duration implements Comparable<Duration> {
  
      /**
       * Special duration that represents an unlimited duration (or indefinite).
       */
      public static final Duration UNLIMITED = new Duration();
  
      /**
       * Special duration that represents a zero-length duration.
       */
      public static final Duration ZERO = new Duration(0L, SECONDS);
  
      /**
       * Tokens that represents the unlimited duration.
       */
      private static final Set<String> UNLIMITED_TOKENS = new TreeSet<>(
              String.CASE_INSENSITIVE_ORDER);
      static {
          UNLIMITED_TOKENS.addAll(asList("unlimited", "indefinite", "infinity", "undefined", "none"));
      }
  
      /**
       * Tokens that represents the zero duration.
       */
      private static final Set<String> ZERO_TOKENS = new TreeSet<>(
              String.CASE_INSENSITIVE_ORDER);
      static {
          ZERO_TOKENS.addAll(asList("zero", "disabled"));
      }
  
      private long number;
      private TimeUnit unit;
  
      /**
       * Hidden constructor that creates an unlimited duration. The intention is that the only instance representing
       * unlimited is {@link #UNLIMITED}.
       */
      private Duration() {
          this.number = Long.MAX_VALUE;
          this.unit = null;
      }
  
      /**
       * Builds a new {@code Duration}.
      *
      * @param number number of time unit (cannot be {@literal null}).
      * @param unit TimeUnit to express the duration in (cannot be {@literal null}).
      * @deprecated Prefer the use of {@link #duration(long, TimeUnit)}.
      */
     @Deprecated
     public Duration(final Long number, final TimeUnit unit) {
         Reject.ifTrue(number < 0, "Negative durations are not supported");
         this.number = number;
         this.unit = checkNotNull(unit);
     }
 
     /**
      * Provides a {@code Duration}, given a number and time unit.
      *
      * @param number number of time unit.
      * @param unit TimeUnit to express the duration in (cannot be {@literal null}).
      * @return {@code Duration} instance
      */
     public static Duration duration(final long number, final TimeUnit unit) {
         if (number == 0) {
             return ZERO;
         }
         return new Duration(number, unit);
     }
 
     /**
      * Provides a {@code Duration} that represents the given duration expressed in english.
      *
      * @param value
      *         natural speech duration
      * @return {@code Duration} instance
      * @throws IllegalArgumentException
      *         if the input string is incorrectly formatted.
      */
     public static Duration duration(final String value) {
         List<Duration> composite = new ArrayList<>();
 
         // Split around ',' and ' and ' patterns
         String[] fragments = value.split(",| and ");
 
         // If there is only 1 fragment and that it matches the recognized "unlimited" tokens
         if (fragments.length == 1) {
             String trimmed = fragments[0].trim();
             if (UNLIMITED_TOKENS.contains(trimmed)) {
                 // Unlimited Duration
                 return UNLIMITED;
             } else if (ZERO_TOKENS.contains(trimmed)) {
                 // Zero-length Duration
                 return ZERO;
             }
         }
 
         // Build the normal duration
         for (String fragment : fragments) {
             fragment = fragment.trim();
 
             if ("".equals(fragment)) {
                 throw new IllegalArgumentException("Cannot parse empty duration, expecting '<value> <unit>' pattern");
             }
 
             // Parse the number part
             int i = 0;
             StringBuilder numberSB = new StringBuilder();
             while (Character.isDigit(fragment.charAt(i))) {
                 numberSB.append(fragment.charAt(i));
                 i++;
             }
 
             // Ignore whitespace
             while (Character.isWhitespace(fragment.charAt(i))) {
                 i++;
             }
 
             // Parse the time unit part
             StringBuilder unitSB = new StringBuilder();
             while ((i < fragment.length()) && Character.isLetter(fragment.charAt(i))) {
                 unitSB.append(fragment.charAt(i));
                 i++;
             }
             Long number = Long.valueOf(numberSB.toString());
             TimeUnit unit = parseTimeUnit(unitSB.toString());
 
             composite.add(new Duration(number, unit));
         }
 
         // Merge components of the composite together
         Duration duration = new Duration(0L, DAYS);
         for (Duration elements : composite) {
             duration.merge(elements);
         }
 
         // If someone used '0 ms' for example
         if (duration.number == 0L) {
             return ZERO;
         }
 
         return duration;
     }
 
     /**
      * Aggregates this Duration with the given Duration. Littlest {@link TimeUnit} will be used as a common ground.
      *
      * @param duration
      *         other Duration
      */
     private void merge(final Duration duration) {
         if (!isUnlimited() && !duration.isUnlimited()) {
             // find littlest unit
             // conversion will happen on the littlest unit otherwise we loose details
             if (unit.ordinal() > duration.unit.ordinal()) {
                 // Other duration is smaller than me
                 number = duration.unit.convert(number, unit) + duration.number;
                 unit = duration.unit;
             } else {
                 // Other duration is greater than me
                 number = unit.convert(duration.number, duration.unit) + number;
             }
         }
     }
 
     private static final Map<String, TimeUnit> TIME_UNITS = new HashMap<>();
     static {
         for (String days : asList("days", "day", "d")) {
             TIME_UNITS.put(days, DAYS);
         }
         for (String hours : asList("hours", "hour", "h")) {
             TIME_UNITS.put(hours, HOURS);
         }
         for (String minutes : asList("minutes", "minute", "min", "m")) {
             TIME_UNITS.put(minutes, MINUTES);
         }
         for (String seconds : asList("seconds", "second", "sec", "s")) {
             TIME_UNITS.put(seconds, SECONDS);
         }
         for (String ms : asList("milliseconds", "millisecond", "millisec", "millis", "milli", "ms")) {
             TIME_UNITS.put(ms, MILLISECONDS);
         }
         for (String us : asList("microseconds", "microsecond", "microsec", "micros", "micro", "us", "\u03BCs",
                 "\u00B5s")) { // the last two support 'mu' and 'micro sign' abbreviations
             TIME_UNITS.put(us, MICROSECONDS);
         }
         for (String ns : asList("nanoseconds", "nanosecond", "nanosec", "nanos", "nano", "ns")) {
             TIME_UNITS.put(ns, NANOSECONDS);
         }
     }
 
     /**
      * Parse the given input string as a {@link TimeUnit}.
      */
     private static TimeUnit parseTimeUnit(final String unit) {
         final String lowercase = unit.toLowerCase(Locale.ENGLISH);
         final TimeUnit timeUnit = TIME_UNITS.get(lowercase);
         if (timeUnit != null) {
             return timeUnit;
         }
         throw new IllegalArgumentException(format("TimeUnit %s is not recognized", unit));
     }
 
     /**
      * Returns the number of {@link TimeUnit} this duration represents.
      *
      * @return the number of {@link TimeUnit} this duration represents.
      */
     public long getValue() {
         return number;
     }
 
     /**
      * Returns the {@link TimeUnit} this duration is expressed in.
      *
      * @return the {@link TimeUnit} this duration is expressed in.
      */
     public TimeUnit getUnit() {
         if (isUnlimited()) {
             // UNLIMITED originally had TimeUnit.DAYS, so preserve API semantics
             return TimeUnit.DAYS;
         }
         return unit;
     }
 
     /**
      * Convert the current duration to a given {@link TimeUnit}.
      * Conversions from finer to coarser granularities truncate, so loose precision.
      *
      * @param targetUnit
      *         target unit of the conversion.
      * @return converted duration
      * @see TimeUnit#convert(long, TimeUnit)
      */
     public Duration convertTo(TimeUnit targetUnit) {
         if (isUnlimited() || isZero()) {
             return this;
         }
         return new Duration(to(targetUnit), targetUnit);
     }
 
     /**
      * Convert the current duration to a number of given {@link TimeUnit}.
      * Conversions from finer to coarser granularities truncate, so loose precision.
      *
      * @param targetUnit
      *         target unit of the conversion.
      * @return converted duration value
      * @see TimeUnit#convert(long, TimeUnit)
      */
     public long to(TimeUnit targetUnit) {
         if (isUnlimited()) {
             return number;
         }
         return targetUnit.convert(number, unit);
     }
 
     /**
      * Returns {@literal true} if this Duration represents an unlimited (or indefinite) duration.
      *
      * @return {@literal true} if this Duration represents an unlimited duration.
      */
     public boolean isUnlimited() {
         return this == UNLIMITED;
     }
 
     /**
      * Returns {@literal true} if this Duration represents a zero-length duration.
      *
      * @return {@literal true} if this Duration represents a zero-length duration.
      */
     public boolean isZero() {
         return number == 0;
     }
 
     @Override
     public String toString() {
         if (isUnlimited()) {
             return "UNLIMITED";
         }
         if (isZero()) {
             return "ZERO";
         }
         return number + " " + unit;
     }
 
     @Override
     public int compareTo(Duration that) {
         if (this.isUnlimited()) {
             if (that.isUnlimited()) {
                 // unlimited == unlimited
                 return 0;
             } else {
                 // unlimited > any value
                 return 1;
             }
         }
         if (that.isUnlimited()) {
             // any value > unlimited
             return -1;
         }
         if (this.isZero()) {
             if (that.isZero()) {
                 // 0 == 0
                 return 0;
             } else {
                 // 0 > any value
                 return -1;
             }
         }
         if (that.isZero()) {
             // any value > 0
             return 1;
         }
 
         // No special case so let's convert using the smallest unit and check if the biggest duration overflowed
         // or not during the conversion.
         final int unitCompare = this.getUnit().compareTo(that.getUnit());
         final boolean biggestOverflowed;
         final long thisConverted, thatConverted;
         if (unitCompare > 0) {
             thisConverted = this.convertTo(that.getUnit()).getValue();
             thatConverted = that.getValue();
             biggestOverflowed = thisConverted == Long.MAX_VALUE;
         } else if (unitCompare < 0) {
             thisConverted = this.getValue();
             thatConverted = that.convertTo(this.getUnit()).getValue();
             biggestOverflowed = thatConverted == Long.MAX_VALUE;
         } else {
             // unitCompare == 0 : both durations are in the same units
             // No conversion was done so the biggest can't have been overflowed.
             biggestOverflowed = false;
             thisConverted = this.getValue();
             thatConverted = that.getValue();
         }
 
 
         return !biggestOverflowed ? Long.compare(thisConverted, thatConverted) : unitCompare;
     }
 
     @Override
     public boolean equals(Object other) {
         if (this == other) {
             return true;
         }
 
         if (!(other instanceof Duration)) {
             return false;
         }
 
         Duration duration = (Duration) other;
         return number == duration.number && unit == duration.unit;
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(number, unit);
     }
 
 }