/**
 * 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.test;

import junit.framework.Assert;
import org.junit.Rule;
import org.junit.rules.MethodRule;

import java.text.MessageFormat;

public abstract class HTestCase {

  public static final String TEST_WAITFOR_RATIO_PROP = "test.waitfor.ratio";

  static {
    SysPropsForTestsLoader.init();
  }

  private static float WAITFOR_RATIO_DEFAULT = Float.parseFloat(System.getProperty(TEST_WAITFOR_RATIO_PROP, "1"));

  private float waitForRatio = WAITFOR_RATIO_DEFAULT;

  @Rule
  public MethodRule testDir = new TestDirHelper();

  @Rule
  public MethodRule jettyTestHelper = new TestJettyHelper();

  @Rule
  public MethodRule exceptionHelper = new TestExceptionHelper();

  /**
   * Sets the 'wait for ratio' used in the {@link #sleep(long)},
   * {@link #waitFor(int, Predicate)} and
   * {@link #waitFor(int, boolean, Predicate)} method for the current
   * test class.
   * <p/>
   * This is useful when running tests in slow machine for tests
   * that are time sensitive.
   *
   * @param ratio the 'wait for ratio' to set.
   */
  protected void setWaitForRatio(float ratio) {
    waitForRatio = ratio;
  }

  /*
   * Returns the 'wait for ratio' used in the {@link #sleep(long)},
   * {@link #waitFor(int, Predicate)} and
   * {@link #waitFor(int, boolean, Predicate)} methods for the current
   * test class.
   * <p/>
   * This is useful when running tests in slow machine for tests
   * that are time sensitive.
   * <p/>
   * The default value is obtained from the Java System property
   * <code>test.wait.for.ratio</code> which defaults to <code>1</code>.
   *
   * @return the 'wait for ratio' for the current test class.
   */
  protected float getWaitForRatio() {
    return waitForRatio;
  }

  /**
   * A predicate 'closure' used by the {@link #waitFor(int, Predicate)} and
   * {@link #waitFor(int, boolean, Predicate)} methods.
   */
  public static interface Predicate {

    /**
     * Perform a predicate evaluation.
     *
     * @return the boolean result of the evaluation.
     *
     * @throws Exception thrown if the predicate evaluation could not evaluate.
     */
    public boolean evaluate() throws Exception;

  }

  /**
   * Makes the current thread sleep for the specified number of milliseconds.
   * <p/>
   * The sleep time is multiplied by the {@link #getWaitForRatio()}.
   *
   * @param time the number of milliseconds to sleep.
   */
  protected void sleep(long time) {
    try {
      Thread.sleep((long) (getWaitForRatio() * time));
    } catch (InterruptedException ex) {
      System.err.println(MessageFormat.format("Sleep interrupted, {0}", ex.toString()));
    }
  }

  /**
   * Waits up to the specified timeout for the given {@link Predicate} to
   * become <code>true</code>, failing the test if the timeout is reached
   * and the Predicate is still <code>false</code>.
   * <p/>
   * The timeout time is multiplied by the {@link #getWaitForRatio()}.
   *
   * @param timeout the timeout in milliseconds to wait for the predicate.
   * @param predicate the predicate ot evaluate.
   *
   * @return the effective wait, in milli-seconds until the predicate become
   *         <code>true</code>.
   */
  protected long waitFor(int timeout, Predicate predicate) {
    return waitFor(timeout, false, predicate);
  }

  /**
   * Waits up to the specified timeout for the given {@link Predicate} to
   * become <code>true</code>.
   * <p/>
   * The timeout time is multiplied by the {@link #getWaitForRatio()}.
   *
   * @param timeout the timeout in milliseconds to wait for the predicate.
   * @param failIfTimeout indicates if the test should be failed if the
   * predicate times out.
   * @param predicate the predicate ot evaluate.
   *
   * @return the effective wait, in milli-seconds until the predicate become
   *         <code>true</code> or <code>-1</code> if the predicate did not evaluate
   *         to <code>true</code>.
   */
  protected long waitFor(int timeout, boolean failIfTimeout, Predicate predicate) {
    long started = System.currentTimeMillis();
    long mustEnd = System.currentTimeMillis() + (long) (getWaitForRatio() * timeout);
    long lastEcho = 0;
    try {
      long waiting = mustEnd - System.currentTimeMillis();
      System.out.println(MessageFormat.format("Waiting up to [{0}] msec", waiting));
      boolean eval;
      while (!(eval = predicate.evaluate()) && System.currentTimeMillis() < mustEnd) {
        if ((System.currentTimeMillis() - lastEcho) > 5000) {
          waiting = mustEnd - System.currentTimeMillis();
          System.out.println(MessageFormat.format("Waiting up to [{0}] msec", waiting));
          lastEcho = System.currentTimeMillis();
        }
        Thread.sleep(100);
      }
      if (!eval) {
        if (failIfTimeout) {
          Assert.fail(MessageFormat.format("Waiting timed out after [{0}] msec", timeout));
        } else {
          System.out.println(MessageFormat.format("Waiting timed out after [{0}] msec", timeout));
        }
      }
      return (eval) ? System.currentTimeMillis() - started : -1;
    } catch (Exception ex) {
      throw new RuntimeException(ex);
    }
  }

}