/*
 * 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.beam.sdk.util;

import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThan;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;

import java.io.IOException;
import org.joda.time.Duration;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Tests for {@link FluentBackoff}.
 */
@RunWith(JUnit4.class)
public class FluentBackoffTest {

  @Rule
  public ExpectedException thrown = ExpectedException.none();
  private final FluentBackoff defaultBackoff = FluentBackoff.DEFAULT;

  @Test
  public void testInvalidExponent() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("exponent -2.0 must be greater than 0");
    defaultBackoff.withExponent(-2.0);
  }

  @Test
  public void testInvalidInitialBackoff() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("initialBackoff PT0S must be at least 1 millisecond");
    defaultBackoff.withInitialBackoff(Duration.ZERO);
  }

  @Test
  public void testInvalidMaxBackoff() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("maxBackoff PT0S must be at least 1 millisecond");
    defaultBackoff.withMaxBackoff(Duration.ZERO);
  }

  @Test
  public void testInvalidMaxRetries() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("maxRetries -1 cannot be negative");
    defaultBackoff.withMaxRetries(-1);
  }

  @Test
  public void testInvalidCumulativeBackoff() {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("maxCumulativeBackoff PT-0.002S must be at least 1 millisecond");
    defaultBackoff.withMaxCumulativeBackoff(Duration.millis(-2));
  }

  /**
   * Tests with bounded interval, custom exponent, and unlimited retries.
   */
  @Test
  public void testBoundedIntervalWithReset() throws Exception {
    BackOff backOff =
        FluentBackoff.DEFAULT
            .withInitialBackoff(Duration.millis(500))
            .withMaxBackoff(Duration.standardSeconds(1)).backoff();
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(249L), lessThan(751L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(374L), lessThan(1126L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));

    // Reset, should go back to short times.
    backOff.reset();
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(249L), lessThan(751L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(374L), lessThan(1126L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(500L),
        lessThanOrEqualTo(1500L)));

  }

  /**
   * Tests with bounded interval, custom exponent, limited retries, and a reset.
   */
  @Test
  public void testMaxRetriesWithReset() throws Exception {
    BackOff backOff =
        FluentBackoff.DEFAULT
            .withInitialBackoff(Duration.millis(500))
            .withMaxRetries(1)
            .backoff();
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(249L), lessThan(751L)));
    assertThat(backOff.nextBackOffMillis(), equalTo(BackOff.STOP));
    assertThat(backOff.nextBackOffMillis(), equalTo(BackOff.STOP));
    assertThat(backOff.nextBackOffMillis(), equalTo(BackOff.STOP));
    assertThat(backOff.nextBackOffMillis(), equalTo(BackOff.STOP));

    backOff.reset();
    assertThat(backOff.nextBackOffMillis(), allOf(greaterThanOrEqualTo(249L), lessThan(751L)));
    assertThat(backOff.nextBackOffMillis(), equalTo(BackOff.STOP));
  }

  private static long countMaximumBackoff(BackOff backOff) throws IOException {
    long cumulativeBackoffMillis = 0;
    long currentBackoffMillis = backOff.nextBackOffMillis();
    while (currentBackoffMillis != BackOff.STOP) {
      cumulativeBackoffMillis += currentBackoffMillis;
      currentBackoffMillis = backOff.nextBackOffMillis();
    }
    return cumulativeBackoffMillis;
  }

  /**
   * Tests with bounded interval, custom exponent, limited cumulative time, and a reset.
   */
  @Test
  public void testBoundedIntervalAndCumTimeWithReset() throws Exception {
    BackOff backOff =
        FluentBackoff.DEFAULT
            .withInitialBackoff(Duration.millis(500))
            .withMaxBackoff(Duration.standardSeconds(1))
            .withMaxCumulativeBackoff(Duration.standardMinutes(1)).backoff();

    assertThat(countMaximumBackoff(backOff), equalTo(Duration.standardMinutes(1).getMillis()));

    backOff.reset();
    assertThat(countMaximumBackoff(backOff), equalTo(Duration.standardMinutes(1).getMillis()));
    // sanity check: should get 0 if we don't reset
    assertThat(countMaximumBackoff(backOff), equalTo(0L));

    backOff.reset();
    assertThat(countMaximumBackoff(backOff), equalTo(Duration.standardMinutes(1).getMillis()));
  }

  /**
   * Tests with bounded interval, custom exponent, limited cumulative time and retries.
   */
  @Test
  public void testBoundedIntervalAndCumTimeAndRetriesWithReset() throws Exception {
    BackOff backOff =
        FluentBackoff.DEFAULT
            .withInitialBackoff(Duration.millis(500))
            .withMaxBackoff(Duration.standardSeconds(1))
            .withMaxCumulativeBackoff(Duration.standardMinutes(1))
            .backoff();

    long cumulativeBackoffMillis = 0;
    long currentBackoffMillis = backOff.nextBackOffMillis();
    while (currentBackoffMillis != BackOff.STOP) {
      cumulativeBackoffMillis += currentBackoffMillis;
      currentBackoffMillis = backOff.nextBackOffMillis();
    }
    assertThat(cumulativeBackoffMillis, equalTo(Duration.standardMinutes(1).getMillis()));
  }

  @Test
  public void testFluentBackoffToString() throws IOException {
    FluentBackoff config = FluentBackoff.DEFAULT
        .withExponent(3.4)
        .withMaxRetries(4)
        .withInitialBackoff(Duration.standardSeconds(3))
        .withMaxBackoff(Duration.standardHours(1))
        .withMaxCumulativeBackoff(Duration.standardDays(1));

    assertEquals(
        "FluentBackoff{exponent=3.4, initialBackoff=PT3S, maxBackoff=PT3600S,"
            + " maxRetries=4, maxCumulativeBackoff=PT86400S}",
        config.toString());
  }
  @Test
  public void testBackoffImplToString() throws IOException {
    FluentBackoff config = FluentBackoff.DEFAULT
        .withExponent(3.4)
        .withMaxRetries(4)
        .withInitialBackoff(Duration.standardSeconds(3))
        .withMaxBackoff(Duration.standardHours(1))
        .withMaxCumulativeBackoff(Duration.standardDays(1));
    BackOff backOff = config.backoff();

    assertEquals(
        "BackoffImpl{backoffConfig=" + config.toString() + ","
            + " currentRetry=0, currentCumulativeBackoff=PT0S}",
        backOff.toString());

    // backoff once, ignoring result
    backOff.nextBackOffMillis();

    // currentRetry is exact, we can test it.
    assertThat(backOff.toString(), containsString("currentRetry=1"));
    // currentCumulativeBackoff is not exact; we cannot even check that it's non-zero (randomness).
  }
}
