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

import com.google.gwt.junit.remote.BrowserManagerProcess.ProcessExitCb;

import java.io.IOException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Timer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Manages instances of a web browser as child processes. This class is
 * experimental and unsupported. An instance of this class can create browser
 * windows using one specific shell-level command. It performs process
 * management (baby sitting) on behalf of a remote client. This can be useful
 * for running a GWTTestCase on a browser that cannot be run on the native
 * platform. For example, a GWTTestCase test running on Linux could use a remote
 * call to a Windows machine to test with Internet Explorer.
 * 
 * <p>
 * Calling {@link #main(String[])} can instantiate and register multiple
 * instances of this class at given RMI namespace locations.
 * </p>
 * 
 * <p>
 * This system has been tested on Internet Explorer 6 & 7. Firefox does not work
 * in the general case; if an existing Firefox process is already running, new
 * processes simply delegate to the existing process and terminate, which breaks
 * the model. A shell script that sets MOZNOREMOTE=1 and cleans up
 * locks/sessions is needed. Safari on MacOS requires very special treatment
 * given Safari's poor command line support, but that is beyond the scope of
 * this documentation.
 * </p>
 * 
 * <p>
 * TODO(scottb): We technically need a watchdog thread to slurp up stdout and
 * stderr from the child processes, or they might block. However, most browsers
 * never write to stdout and stderr, so this is low priority. (There is now a
 * thread that is spawned for each task to wait for an exit value - this might
 * be adapted for that purpose one day.)
 * </p>
 * 
 * <p>
 * This class is not actually serializable as-is, because timer is not
 * serializable.
 * </p>
 * 
 * see http://bugs.sun.com/bugdatabase/view_bug.do;:YfiG?bug_id=4062587
 */
public class BrowserManagerServer extends UnicastRemoteObject implements
    BrowserManager {

  /**
   * Implementation notes: <code>processByToken</code> must be locked before
   * performing any state-changing operations.
   */

  /**
   * Entry in the launchCommandQueue to use when tasks are serialized.
   */
  private static class LaunchCommand {
    long keepAliveMsecs;
    int token;
    String url;

    LaunchCommand(int tokenIn) {
      this(tokenIn, null, 0);
    }

    LaunchCommand(int tokenIn, String urlIn, long keepAliveMsecsIn) {
      token = tokenIn;
      url = urlIn;
      keepAliveMsecs = keepAliveMsecsIn;
    }

    @Override
    public boolean equals(Object obj) {
      if (obj instanceof LaunchCommand && ((LaunchCommand) obj).token == token) {
        return true;
      }
      return false;
    }

    @Override
    public int hashCode() {
      return token;
    }
  }

  private static final Logger logger = Logger.getLogger(BrowserManagerServer.class.getName());

  /**
   * Starts up and registers one or more browser servers. Command-line entry
   * point.
   */
  public static void main(String[] args) throws Exception {

    // Startup logic has been delegated to BrowserManagerServerLauncher
    // class to facilitate use of the ToolBase class for
    // argument handling.
    BrowserManagerServerLauncher serverMain = new BrowserManagerServerLauncher();
    if (serverMain.doProcessArgs(args)) {
      serverMain.run();
    }
  }

  /**
   * Receives an event when a child process exits.
   */
  private final ProcessExitCb childExitCallback = new ProcessExitCb() {
    /**
     * Called back from BrowserManagerProcess in a DIFFERENT THREAD than the
     * main thread.
     * 
     * @param token token value of browser that exited.
     * @param exitValue exit status of the browser.
     */
    public void childExited(int token, int exitValue) {
      synchronized (processByToken) {
        processByToken.remove(token);
        // Start up any commands that were delayed.
        launchDelayedCommand();
      }
    }
  };

  /**
   * The shell command to launch when a new browser is requested.
   */
  private final String launchCmd;

  /**
   * A queue of delayed commands. This is used if the serialized option is
   * turned on.
   */
  private Queue<LaunchCommand> launchCommandQueue = new LinkedList<LaunchCommand>();

  /**
   * The next token that will be returned from
   * {@link #launchNewBrowser(String, long)}.
   */
  private int nextToken = 1;

  /**
   * Master map of tokens onto ProcessManagers managing live processes. Also
   * serves as a lock that must be held before any state-changing operations on
   * this class may be performed.
   */
  private final Map<Integer, BrowserManagerProcess> processByToken = new HashMap<Integer, BrowserManagerProcess>();

  /**
   * Flag that is set if the serialized option is turned on.
   */
  private final boolean serializeFlag;

  /**
   * A single shared Timer used by all instances of
   * {@link BrowserManagerProcess}.
   */
  private final Timer timer = new Timer();

  /**
   * Constructs a manager for a particular shell command. The specified launch
   * command should be a path to a browser's executable, suitable for passing to
   * {@link Runtime#exec(java.lang.String)}. It may also include newline
   * delimited arguments to pass to that executable. The invoked process must
   * accept a URL as the final command line argument.
   * 
   * @param launchCmd a command to launch a browser executable
   * @param serializeFlag if <code>true</code>, serialize instance of browser
   *          processes to only run one at a time
   */
  BrowserManagerServer(String launchCmd, boolean serializeFlag)
      throws RemoteException {
    // TODO: It would be nice to test to see if this file exists, but
    // currently this mechanism allows you to pass in command line arguments
    // and it will be a pain to accommodate this.
    this.launchCmd = launchCmd;
    this.serializeFlag = serializeFlag;
  }

  /**
   * @see BrowserManager#keepAlive(int, long)
   */
  public void keepAlive(int token, long keepAliveMs) {

    if (keepAliveMs <= 0) {
      throw new IllegalArgumentException();
    }

    synchronized (processByToken) {
      // Is the token one we've issued?
      if (token < 0 || token >= nextToken) {
        throw new IllegalArgumentException();
      }
      BrowserManagerProcess process = processByToken.get(token);
      if (process != null) {
        if (process.keepAlive(keepAliveMs)) {
          // The process was successfully kept alive.
          return;
        }
      } else if (launchCommandQueue.contains(new LaunchCommand(token))) {
        // Nothing to do, the command hasn't started yet.
        return;
      }

      // The process is already dead. Fall through to failure.
    }

    throw new IllegalStateException("Process " + token + " already dead");
  }

  /**
   * @see BrowserManager#killBrowser(int)
   */
  public void killBrowser(int token) {

    synchronized (processByToken) {
      // Is the token one we've issued?
      if (token < 0 || token >= nextToken) {
        throw new IllegalArgumentException();
      }
      BrowserManagerProcess process = processByToken.get(token);
      if (process != null) {
        logger.info("Client kill for active browser: " + token);
        process.killBrowser();
      } else if (launchCommandQueue.contains(new LaunchCommand(token))) {
        launchCommandQueue.remove(new LaunchCommand(token));
        logger.info("Client kill for waiting browser: " + token);
      } else {
        logger.info("Client kill for inactive browser: " + token);
      }
    }
  }

  /**
   * @see BrowserManager#launchNewBrowser(java.lang.String, long)
   */
  public int launchNewBrowser(String url, long keepAliveMs) {
    logger.info("Launching browser for url: " + url + " keepAliveMs: "
        + keepAliveMs);
    if (url == null || keepAliveMs <= 0) {
      throw new IllegalArgumentException();
    }

    try {
      synchronized (processByToken) {
        int myToken = nextToken++;
        // Adds self to processByToken.

        if (serializeFlag && !processByToken.isEmpty()) {
          // Queue up a launch request if one is already running.
          launchCommandQueue.add(new LaunchCommand(myToken, url, keepAliveMs));
          logger.info("Queuing up request token: " + myToken + " for url: "
              + url + ".  Another launch command is active.");
        } else {
          execChild(myToken, url, keepAliveMs);
        }
        return myToken;
      }
    } catch (IOException e) {
      logger.log(Level.SEVERE, "Error launching browser '" + launchCmd
          + "' for '" + url + "'", e);
      throw new RuntimeException("Error launching browser '" + launchCmd
          + "' for '" + url + "'", e);
    }
  }

  /**
   * This method is mainly in place for writing assertions in the unit test.
   * 
   * @return number of tasks waiting to run if serialized option is enabled
   */
  int numQueued() {
    synchronized (processByToken) {
      return launchCommandQueue.size();
    }
  }

  /**
   * This method is mainly in place for writing assertions in the unit test.
   * 
   * @return number of launch commands running that have not yet exited.
   */
  int numRunning() {
    synchronized (processByToken) {
      return processByToken.size();
    }
  }

  /**
   * Actually create a process and run a browser.
   * 
   * (Assumes that code is already synchronized by processBytoken)
   * 
   * @param token token value of browser that exited.
   * @param url command line arguments to pass to the browser
   * @param keepAliveMs inital keep alive interval in milliseconds
   */
  private void execChild(int token, String url, long keepAliveMs)
      throws IOException {
    // Tokenize the launchCmd by carriage returns (used for unit testing).
    StringTokenizer st = new StringTokenizer(launchCmd, "\n");
    int userTokens = st.countTokens();
    String[] cmdarray = new String[userTokens + 1];
    for (int i = 0; st.hasMoreTokens(); i++) {
      cmdarray[i] = st.nextToken();
    }
    // Append the user-specified URL.
    cmdarray[userTokens] = url;

    // Start the task.
    Process child = Runtime.getRuntime().exec(cmdarray);

    BrowserManagerProcess bmp = new BrowserManagerProcess(childExitCallback,
        timer, token, child, keepAliveMs);
    processByToken.put(token, bmp);
  }

  /**
   * If serialization is enabled on the server, kicks off the next queued
   * command on the delayed command queue.
   * 
   * (Assumes that code is already synchronized by processBytoken)
   */
  private void launchDelayedCommand() {
    if (!serializeFlag || !processByToken.isEmpty()) {
      // No need to launch if serialization is off or
      // something is already running
      return;
    }

    // Loop through the commands until we can launch one
    // successfully.
    while (!launchCommandQueue.isEmpty()) {
      LaunchCommand lc = launchCommandQueue.remove();
      try {
        execChild(lc.token, lc.url, lc.keepAliveMsecs);
        // No exception? Great!
        logger.info("Started delayed browser: " + lc.token);
        return;

      } catch (IOException e) {
        logger.log(Level.SEVERE, "Error launching browser '" + launchCmd
            + "' for '" + lc.url + "'", e);
        throw new RuntimeException("Error launching browser '" + launchCmd
            + "' for '" + lc.url + "'", e);
      }
      // If an exception occurred, keep pulling cmds off the queue.
    }
  }
}