/**
    *
    * 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.hadoop.hbase.util;
  
  import java.util.concurrent.TimeUnit;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.hadoop.hbase.classification.InterfaceAudience;
  
  @InterfaceAudience.Private
  public class RetryCounter {
  
    /**
     *  Configuration for a retry counter
     */
    public static class RetryConfig {
      private int maxAttempts;
      private long sleepInterval;
      private long maxSleepTime;
      private TimeUnit timeUnit;
      private BackoffPolicy backoffPolicy;
  
      private static final BackoffPolicy DEFAULT_BACKOFF_POLICY = new ExponentialBackoffPolicy();
  
      public RetryConfig() {
        maxAttempts    = 1;
        sleepInterval = 1000;
        maxSleepTime  = -1;
        timeUnit = TimeUnit.MILLISECONDS;
        backoffPolicy = DEFAULT_BACKOFF_POLICY;
      }
  
      public RetryConfig(int maxAttempts, long sleepInterval, long maxSleepTime,
          TimeUnit timeUnit, BackoffPolicy backoffPolicy) {
        this.maxAttempts = maxAttempts;
        this.sleepInterval = sleepInterval;
        this.maxSleepTime = maxSleepTime;
        this.timeUnit = timeUnit;
        this.backoffPolicy = backoffPolicy;
      }
  
      public RetryConfig setBackoffPolicy(BackoffPolicy backoffPolicy) {
        this.backoffPolicy = backoffPolicy;
        return this;
      }
  
      public RetryConfig setMaxAttempts(int maxAttempts) {
        this.maxAttempts = maxAttempts;
        return this;
      }
  
      public RetryConfig setMaxSleepTime(long maxSleepTime) {
        this.maxSleepTime = maxSleepTime;
        return this;
      }
  
      public RetryConfig setSleepInterval(long sleepInterval) {
        this.sleepInterval = sleepInterval;
        return this;
      }
  
      public RetryConfig setTimeUnit(TimeUnit timeUnit) {
        this.timeUnit = timeUnit;
        return this;
      }
  
      public int getMaxAttempts() {
        return maxAttempts;
      }
  
      public long getMaxSleepTime() {
        return maxSleepTime;
      }
  
      public long getSleepInterval() {
        return sleepInterval;
      }
  
      public TimeUnit getTimeUnit() {
        return timeUnit;
      }
  
     public BackoffPolicy getBackoffPolicy() {
       return backoffPolicy;
     }
   }
 
   /**
    * Policy for calculating sleeping intervals between retry attempts
    */
   public static class BackoffPolicy {
     public long getBackoffTime(RetryConfig config, int attempts) {
       return config.getSleepInterval();
     }
   }
 
   public static class ExponentialBackoffPolicy extends BackoffPolicy {
     @Override
     public long getBackoffTime(RetryConfig config, int attempts) {
       long backoffTime = (long) (config.getSleepInterval() * Math.pow(2, attempts));
       return backoffTime;
     }
   }
 
   public static class ExponentialBackoffPolicyWithLimit extends ExponentialBackoffPolicy {
     @Override
     public long getBackoffTime(RetryConfig config, int attempts) {
       long backoffTime = super.getBackoffTime(config, attempts);
       return config.getMaxSleepTime() > 0 ? Math.min(backoffTime, config.getMaxSleepTime()) : backoffTime;
     }
   }
 
   private static final Log LOG = LogFactory.getLog(RetryCounter.class);
 
   private RetryConfig retryConfig;
   private int attempts;
 
   public RetryCounter(int maxAttempts, long sleepInterval, TimeUnit timeUnit) {
     this(new RetryConfig(maxAttempts, sleepInterval, -1, timeUnit, new ExponentialBackoffPolicy()));
   }
 
   public RetryCounter(RetryConfig retryConfig) {
     this.attempts = 0;
     this.retryConfig = retryConfig;
   }
 
   public int getMaxAttempts() {
     return retryConfig.getMaxAttempts();
   }
 
   /**
    * Sleep for a back off time as supplied by the backoff policy, and increases the attempts
    * @throws InterruptedException
    */
   public void sleepUntilNextRetry() throws InterruptedException {
     int attempts = getAttemptTimes();
     long sleepTime = retryConfig.backoffPolicy.getBackoffTime(retryConfig, attempts);
     if (LOG.isTraceEnabled()) {
       LOG.trace("Sleeping " + sleepTime + "ms before retry #" + attempts + "...");
     }
     retryConfig.getTimeUnit().sleep(sleepTime);
     useRetry();
   }
 
   public boolean shouldRetry() {
     return attempts < retryConfig.getMaxAttempts();
   }
 
   public void useRetry() {
     attempts++;
   }
 
   public boolean isRetry() {
     return attempts > 0;
   }
 
   public int getAttemptTimes() {
     return attempts;
   }
 }