// Copyright (c) 2009 The Chromium Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

package org.chromium.sdk.internal.tools.v8;

import java.util.Collection;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.chromium.sdk.SyncCallback;

import org.chromium.sdk.internal.CloseableMap;

import org.chromium.sdk.internal.protocol.CommandResponse;

import org.chromium.sdk.internal.protocol.IncomingMessage;

import org.chromium.sdk.internal.protocolparser.JsonProtocolParseException;

import org.chromium.sdk.internal.tools.v8.request.DebuggerMessage;

import org.json.simple.JSONObject;

/**

 * Sends JSON commands to V8 VM and handles responses. Command is sent

 * via {@code V8CommandOutput}. Response is passed back to callback if it was provided.

 * Also all responses and events are dispatched to group of dedicated processors.

 */

public class V8CommandProcessor implements V8CommandSender<DebuggerMessage, RuntimeException> {

  /**

   * A callback to handle V8 debugger responses.

   */

  public interface V8HandlerCallback {

    /**

     * This method is invoked when a debugger command result has become

     * available.

     *

     * @param response from the V8 debugger

     */

    void messageReceived(CommandResponse response);

    /**

     * This method is invoked when a debugger command has failed.

     *

     * @param message containing the failure reason

     */

    void failure(String message);

    /** A no-op callback implementation. */

    V8HandlerCallback NULL_CALLBACK = new V8HandlerCallback() {

      public void failure(String message) {

      }

      public void messageReceived(CommandResponse response) {

      }

    };

  }

  /** The class logger. */

  static final Logger LOGGER = Logger.getLogger(V8CommandProcessor.class.getName());

  private final CloseableMap<Integer, CallbackEntry> callbackMap = CloseableMap.newLinkedMap();

  private final V8CommandOutput messageOutput;

  private final DefaultResponseHandler defaultResponseHandler;

  public V8CommandProcessor(V8CommandOutput messageOutput,

      DefaultResponseHandler defaultResponseHandler) {

    this.messageOutput = messageOutput;

    this.defaultResponseHandler = defaultResponseHandler;

  }

  public void sendV8CommandAsync(DebuggerMessage message, boolean isImmediate,

      V8HandlerCallback v8HandlerCallback, SyncCallback syncCallback) {

    if (v8HandlerCallback != null) {

      // TODO(peter.rybin): should we handle IllegalStateException better than rethrowing it?

      try {

        callbackMap.put(message.getSeq(), new CallbackEntry(v8HandlerCallback,

            syncCallback));

      } catch (IllegalStateException e) {

        throw new IllegalStateException("Connection is closed", e);

      }

    }

    try {

      messageOutput.send(message, isImmediate);

    } catch (RuntimeException e) {

      if (v8HandlerCallback != null) {

        callbackMap.remove(message.getSeq());

      }

      throw e;

    }

  }

  public void processIncomingJson(final JSONObject v8Json) {

    IncomingMessage response;

    try {

      response = V8ProtocolUtil.getV8Parser().parse(v8Json, IncomingMessage.class);

    } catch (JsonProtocolParseException e) {

      LOGGER.log(Level.SEVERE, "JSON message does not conform to the protocol", e);

      return;

    }

    final CommandResponse commandResponse = response.asCommandResponse();

    if (commandResponse != null) {

      int requestSeqInt = (int) commandResponse.getRequestSeq();

      CallbackEntry callbackEntry = callbackMap.removeIfContains(requestSeqInt);

      if (callbackEntry != null) {

        LOGGER.log(

            Level.INFO,

            "Request-response roundtrip: {0}ms",

            getCurrentMillis() - callbackEntry.commitMillis);

        CallbackCaller caller = new CallbackCaller() {

          @Override

          void call(V8HandlerCallback handlerCallback) {

            handlerCallback.messageReceived(commandResponse);

          }

        };

        try {

          callThemBack(callbackEntry, caller, requestSeqInt);

        } catch (RuntimeException e) {

          LOGGER.log(Level.SEVERE, "Failed to dispatch response to callback", e);

        }

      }

    }

    defaultResponseHandler.handleResponseWithHandler(response);

  }

  public void processEos() {

    // We should call them in the order they have been submitted.

    Collection<CallbackEntry> entries = callbackMap.close().values();

    for (CallbackEntry entry : entries) {

      callThemBack(entry, failureCaller, -1);

    }

  }

  private static abstract class CallbackCaller {

    abstract void call(V8HandlerCallback handlerCallback);

  }

  private final static CallbackCaller failureCaller = new CallbackCaller() {

    @Override

    void call(V8HandlerCallback handlerCallback) {

      handlerCallback.failure("Detach");

    }

  };

  private void callThemBack(CallbackEntry callbackEntry, CallbackCaller callbackCaller,

      int requestSeq) {

    RuntimeException callbackException = null;

    try {

      if (callbackEntry.v8HandlerCallback != null) {

        LOGGER.log(

            Level.INFO, "Notified debugger command callback, request_seq={0}", requestSeq);

        callbackCaller.call(callbackEntry.v8HandlerCallback);

      }

    } catch (RuntimeException e) {

      callbackException = e;

      throw e;

    } finally {

      if (callbackEntry.syncCallback != null) {

        callbackEntry.syncCallback.callbackDone(callbackException);

      }

    }

  }

  /**

   * @return milliseconds since the epoch

   */

  private static long getCurrentMillis() {

    return System.currentTimeMillis();

  }

  static void checkNull(Object object, String message) {

    if (object == null) {

      throw new IllegalArgumentException(message);

    }

  }

  private static class CallbackEntry {

    final V8HandlerCallback v8HandlerCallback;

    final SyncCallback syncCallback;

    final long commitMillis;

    CallbackEntry(V8HandlerCallback v8HandlerCallback, SyncCallback syncCallback) {

      this.v8HandlerCallback = v8HandlerCallback;

      this.commitMillis = getCurrentMillis();

      this.syncCallback = syncCallback;

    }

  }

  public void removeAllCallbacks() {

    // TODO(peter.rybin): get rid of this method

  }

}