/*
    * Copyright 2012 The Netty Project
    *
    * The Netty Project 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:
    *
    *   https://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 io.netty.channel;
  
  import io.netty.util.internal.AdaptiveCalculator;
  
  import static io.netty.util.internal.ObjectUtil.checkPositive;
  
  /**
   * The {@link RecvByteBufAllocator} that automatically increases and
   * decreases the predicted buffer size on feed back.
   * <p>
   * It gradually increases the expected number of readable bytes if the previous
   * read fully filled the allocated buffer.  It gradually decreases the expected
   * number of readable bytes if the read operation was not able to fill a certain
   * amount of the allocated buffer two times consecutively.  Otherwise, it keeps
   * returning the same prediction.
   */
  public class AdaptiveRecvByteBufAllocator extends DefaultMaxMessagesRecvByteBufAllocator {
  
      public static final int DEFAULT_MINIMUM = 64;
      // Use an initial value that is bigger than the common MTU of 1500
      public static final int DEFAULT_INITIAL = 2048;
      public static final int DEFAULT_MAXIMUM = 65536;
  
      /**
       * @deprecated There is state for {@link #maxMessagesPerRead()} which is typically based upon channel type.
       */
      @Deprecated
      public static final AdaptiveRecvByteBufAllocator DEFAULT = new AdaptiveRecvByteBufAllocator();
  
      private final class HandleImpl extends MaxMessageHandle {
          private final AdaptiveCalculator calculator;
  
          HandleImpl(int minimum, int initial, int maximum) {
              calculator = new AdaptiveCalculator(minimum, initial, maximum);
          }
  
          @Override
          public void lastBytesRead(int bytes) {
              // If we read as much as we asked for we should check if we need to ramp up the size of our next guess.
              // This helps adjust more quickly when large amounts of data is pending and can avoid going back to
              // the selector to check for more data. Going back to the selector can add significant latency for large
              // data transfers.
              if (bytes == attemptedBytesRead()) {
                  calculator.record(bytes);
              }
              super.lastBytesRead(bytes);
          }
  
          @Override
          public int guess() {
              return calculator.nextSize();
          }
  
          @Override
          public void readComplete() {
              calculator.record(totalBytesRead());
          }
      }
  
      private final int minimum;
      private final int initial;
      private final int maximum;
  
      /**
       * Creates a new predictor with the default parameters.  With the default
       * parameters, the expected buffer size starts from {@code 1024}, does not
       * go down below {@code 64}, and does not go up above {@code 65536}.
       */
      public AdaptiveRecvByteBufAllocator() {
          this(DEFAULT_MINIMUM, DEFAULT_INITIAL, DEFAULT_MAXIMUM);
      }
  
      /**
       * Creates a new predictor with the specified parameters.
       *
       * @param minimum  the inclusive lower bound of the expected buffer size
       * @param initial  the initial buffer size when no feed back was received
       * @param maximum  the inclusive upper bound of the expected buffer size
       */
      public AdaptiveRecvByteBufAllocator(int minimum, int initial, int maximum) {
          checkPositive(minimum, "minimum");
          if (initial < minimum) {
              throw new IllegalArgumentException("initial: " + initial);
          }
         if (maximum < initial) {
             throw new IllegalArgumentException("maximum: " + maximum);
         }
 
         this.minimum = minimum;
         this.initial = initial;
         this.maximum = maximum;
     }
 
     @SuppressWarnings("deprecation")
     @Override
     public Handle newHandle() {
         return new HandleImpl(minimum, initial, maximum);
     }
 
     @Override
     public AdaptiveRecvByteBufAllocator respectMaybeMoreData(boolean respectMaybeMoreData) {
         super.respectMaybeMoreData(respectMaybeMoreData);
         return this;
     }
 }