/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed 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 com.google.gwt.junit.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.GWT.UncaughtExceptionHandler;
import com.google.gwt.junit.client.impl.GWTRunner;
import com.google.gwt.junit.client.impl.JUnitResult;
import com.google.gwt.user.client.Timer;

import junit.framework.TestCase;

/**
 * The translatable implementation of {@link GWTTestCase}.
 */
@SuppressWarnings("unused")
public abstract class GWTTestCase extends TestCase {

  /**
   * A watchdog class for use with asynchronous mode. On construction,
   * immediately schedules itself for the specified timeout. If the timeout
   * expires before this timer is canceled, causes the enclosing test case to
   * fail with {@link TimeoutException}.
   */
  private final class KillTimer extends Timer {

    /**
     * Stashed so the timeout can be reported via {@link TimeoutException}.
     */
    private final int timeoutMillis;

    public KillTimer(int timeoutMillis) {
      this.timeoutMillis = timeoutMillis;
      schedule(timeoutMillis);
    }

    public void run() {
      if (timer == this) {
        // The test has failed due to timeout
        reportResultsAndRunNextMethod(new TimeoutException(timeoutMillis));
      } else {
        // Something happened so that we are no longer the active timer.
        // Just do nothing.
      }
    }
  }

  /**
   * UncaughtExceptionHandler used to catch exceptions thrown out of Javascript
   * event handlers.
   */
  private final class TestCaseUncaughtExceptionHandler implements
      UncaughtExceptionHandler {

    // Holds the first exception that's throws "synchronously", meaning "before
    // the test method returns".
    private Throwable synchronousException = null;

    /**
     * An uncaught exception escaped to the browser; what we should do depends
     * on what state we're in.
     */
    public void onUncaughtException(Throwable ex) {
      if (mainTestHasRun && timer != null) {
        // Asynchronous mode; uncaught exceptions cause an immediate failure.
        assert (!testIsFinished);
        reportResultsAndRunNextMethod(ex);
      } else {
        // Synchronous mode: hang on to it for after the test method returns.
        // We can't call reportResultsAndRunNextMethod() yet, as it will cause
        // a race condition that often causes the same test to be run again.
        if (synchronousException == null) {
          synchronousException = ex;
        }
      }
    }
  };

  /**
   * Tracks whether the main test body has run (for asynchronous mode).
   */
  private boolean mainTestHasRun = false;

  /**
   * Test result.
   */
  private JUnitResult result;

  /**
   * Tracks whether this test is completely done.
   */
  private boolean testIsFinished = false;

  /**
   * If non-null, a timer to kill the current test case (for asynchronous mode).
   */
  private KillTimer timer;

  /**
   * The UncaughtExceptionHandler that will be used to catch exceptions thrown
   * from event handlers. We will create a new one for each test method.
   */
  private TestCaseUncaughtExceptionHandler uncaughtHandler;

  // CHECKSTYLE_OFF
  /**
   * Actually run the user's test. Called from {@link GWTRunner}.
   */
  public void __doRunTest() {
    Throwable caught = null;

    if (shouldCatchExceptions()) {
      // Make sure no exceptions escape
      GWT.setUncaughtExceptionHandler(uncaughtHandler = new TestCaseUncaughtExceptionHandler());
      try {
        runBare();
      } catch (Throwable e) {
        caught = e;
      }
    } else {
      // Special; make sure all exceptions escape to the browser (for debugging)
      GWT.setUncaughtExceptionHandler(null);
      runBareTestCaseAvoidingExceptionDecl();
    }

    // Mark that the main test body has now run. From this point, if
    // timer != null we are in true asynchronous mode.
    mainTestHasRun = true;

    // See if any synchronous exceptions got picked up by the UncaughtExceptionHandler.
    if ((uncaughtHandler != null) && (uncaughtHandler.synchronousException != null)) {
      // If an exception was caught in an event handler, it must have happened
      // before the exception was thrown from the test method.
      caught = uncaughtHandler.synchronousException;
    }

    if (caught != null) {
      // Test failed; finish test no matter what state we're in.
      reportResultsAndRunNextMethod(caught);
    } else if (timer != null) {
      // Test is still running; wait for asynchronous completion.
    } else {
      // Test is really done; report success.
      reportResultsAndRunNextMethod(null);
    }
  }
  // CHECKSTYLE_ON

  @Deprecated
  public void addCheckpoint(String msg) {
  }

  public boolean catchExceptions() {
    return true;
  }

  @Deprecated
  public void clearCheckpoints() {
  }

  @Deprecated
  public String[] getCheckpoints() {
    return new String[0];
  }

  public abstract String getModuleName();

  public boolean isPureJava() {
    return false;
  }

  @Override
  public void runBare() throws Throwable {
    setUp();
    runTest();
    // No tearDown call here; we do it from reportResults.
  }

  public void setForcePureJava(boolean forcePureJava) {
    // Ignore completely. The test is being run in GWT mode,
    // hence assumed not to be pure Java.
  }

  // CHECKSTYLE_OFF
  protected JUnitResult __getOrCreateTestResult() {
    if (result == null) {
      result = new JUnitResult();
    }
    return result;
  }
  // CHECKSTYLE_ON

  protected final void delayTestFinish(int timeoutMillis) {
    if (supportsAsync()) {
      if (timer != null) {
        // Cancel the pending timer
        timer.cancel();
      }

      // Set a new timer for the specified new timeout
      timer = new KillTimer(timeoutMillis);
    } else {
      throw new UnsupportedOperationException(
          "This test case does not support asynchronous mode.");
    }
  }

  protected final void finishTest() {
    if (supportsAsync()) {
      if (testIsFinished) {
        // This test is totally done already, just ignore the call.
        return;
      }

      if (timer == null) {
        throw new IllegalStateException(
            "This test is not in asynchronous mode; call delayTestFinish() first");
      }

      if (mainTestHasRun) {
        // This is a correct, successful async finish.
        reportResultsAndRunNextMethod(null);
      } else {
        // The user tried to finish the test before the main body returned!
        // Just let the test continue running normally.
        resetAsyncState();
      }
    } else {
      throw new UnsupportedOperationException(
          "This test case does not support asynchronous mode.");
    }
  }

  protected void gwtSetUp() throws Exception {
  }

  protected void gwtTearDown() throws Exception {
  }

  @Override
  protected final void setUp() throws Exception {
    gwtSetUp();
  }

  protected boolean supportsAsync() {
    return true;
  }

  @Override
  protected final void tearDown() throws Exception {
    gwtTearDown();
  }

  /**
   * Cleans up any outstanding state, reports ex to the remote runner, and kicks
   * off the next test.
   * 
   * @param ex The results of this test.
   */
  private void reportResultsAndRunNextMethod(Throwable ex) {
    try {
      tearDown();
    } catch (Throwable e) {
      // ignore any exceptions thrown from tearDown
    }

    // Remove the UncaughtExceptionHandler we may have installed in __doRunTest.
    GWT.setUncaughtExceptionHandler(null);
    uncaughtHandler = null;

    JUnitResult myResult = __getOrCreateTestResult();
    if (ex != null) {
      myResult.setException(ex);
    }

    testIsFinished = true;
    resetAsyncState();
    GWTRunner.get().reportResultsAndGetNextMethod(myResult);
  }

  /**
   * Cleans up any asynchronous mode state.
   */
  private void resetAsyncState() {
    // clear our timer if there is one
    if (timer != null) {
      timer.cancel();
      timer = null;
    }
  }

  /**
   * In the mode where we need to let uncaught exceptions escape to the browser,
   * this method serves as a hack to avoid "throws" clause problems.
   */
  private native void runBareTestCaseAvoidingExceptionDecl() /*-{
    this.@junit.framework.TestCase::runBare()();
  }-*/;

  /**
   * A helper method to determine if we should catch exceptions. Wraps the call
   * into user code with a try/catch; if the user's code throws an exception, we
   * just ignore the exception and use the default behavior.
   * 
   * @return <code>true</code> if exceptions should be handled normally,
   *         <code>false</code> if they should be allowed to escape.
   */
  private boolean shouldCatchExceptions() {
    try {
      return catchExceptions();
    } catch (Throwable e) {
      return true;
    }
  }
}