// 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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

import org.chromium.sdk.CallbackSemaphore;
import org.chromium.sdk.SyncCallback;
import org.chromium.sdk.JsValue.Type;
import org.chromium.sdk.internal.DataWithRef;
import org.chromium.sdk.internal.DebugSession;
import org.chromium.sdk.internal.FunctionAdditionalProperties;
import org.chromium.sdk.internal.JsDataTypeUtil;
import org.chromium.sdk.internal.PropertyHoldingValueMirror;
import org.chromium.sdk.internal.PropertyReference;
import org.chromium.sdk.internal.ScopeMirror;
import org.chromium.sdk.internal.ScriptManager;
import org.chromium.sdk.internal.SubpropertiesMirror;
import org.chromium.sdk.internal.ValueLoadException;
import org.chromium.sdk.internal.ValueMirror;
import org.chromium.sdk.internal.protocol.CommandResponse;
import org.chromium.sdk.internal.protocol.FrameObject;
import org.chromium.sdk.internal.protocol.ScopeRef;
import org.chromium.sdk.internal.protocol.SuccessCommandResponse;
import org.chromium.sdk.internal.protocol.data.FunctionValueHandle;
import org.chromium.sdk.internal.protocol.data.ObjectValueHandle;
import org.chromium.sdk.internal.protocol.data.PropertyObject;
import org.chromium.sdk.internal.protocol.data.RefWithDisplayData;
import org.chromium.sdk.internal.protocol.data.ScriptHandle;
import org.chromium.sdk.internal.protocol.data.ValueHandle;
import org.chromium.sdk.internal.protocolparser.JsonProtocolParseException;
import org.chromium.sdk.internal.tools.v8.request.DebuggerMessageFactory;
import org.chromium.sdk.internal.tools.v8.request.ScriptsMessage;

/**
 * A helper class for performing complex V8-related operations.
 */
public class V8Helper {

  /**
   * The debug context in which the operations are performed.
   */
  private final DebugSession debugSession;

  /**
   * A semaphore that prevents concurrent script reloading (which may effectively
   * double the efforts.)
   */
  private final Semaphore scriptsReloadSemaphore = new Semaphore(1);

  public V8Helper(DebugSession debugSession) {
    this.debugSession = debugSession;
  }

  /**
   * Reloads all normal scripts found in the page. First, all scripts without
   * their sources are retrieved to save bandwidth (script list change during a
   * page lifetime is a relatively rare event.) If at least one script has been
   * added, the script cache is dropped and re-populated with new scripts that
   * are re-requested together with their sources.
   *
   * @param callback to invoke when the script reloading has completed
   */
  public void reloadAllScriptsAsync(V8CommandProcessor.V8HandlerCallback callback,
      SyncCallback syncCallback) {
    final V8CommandProcessor.V8HandlerCallback finalCallback = callback != null
        ? callback
        : V8CommandProcessor.V8HandlerCallback.NULL_CALLBACK;
    lock();
    debugSession.sendMessageAsync(
        DebuggerMessageFactory.scripts(ScriptsMessage.SCRIPTS_NORMAL, true),
        true,
        new V8CommandProcessor.V8HandlerCallback() {
          public void failure(String message) {
            unlock();
            finalCallback.failure(message);
          }

          public void messageReceived(CommandResponse response) {
            SuccessCommandResponse successResponse = response.asSuccess();

            // TODO(peter.rybin): add try/finally for unlock, with some error reporting probably.
            List<ScriptHandle> body;
            try {
              body = successResponse.getBody().asScripts();
            } catch (JsonProtocolParseException e) {
              throw new RuntimeException(e);
            }
            ScriptManager scriptManager = debugSession.getScriptManager();
            for (int i = 0; i < body.size(); ++i) {
              ScriptHandle scriptHandle = body.get(i);
              Long id = V8ProtocolUtil.getScriptIdFromResponse(scriptHandle);
              if (scriptManager.findById(id) == null &&
                  !ChromeDevToolSessionManager.JAVASCRIPT_VOID.equals(scriptHandle.source())) {
                scriptManager.addScript(
                    scriptHandle,
                    successResponse.getRefs());
              }
            }
            unlock();
            finalCallback.messageReceived(response);
          }
        },
        syncCallback);
  }

  protected void lock() {
    try {
      scriptsReloadSemaphore.acquire();
    } catch (InterruptedException e) {
      // consider it a successful acquisition
    }
  }

  protected void unlock() {
    scriptsReloadSemaphore.release();
  }

  /**
   * Gets all resolved locals for the call frame, caches scripts and objects in
   * the scriptManager and handleManager.
   *
   * @param frame to get the data for
   * @return the mirrors corresponding to the frame locals
   */
  public static List<PropertyReference> computeLocals(FrameObject frame) {
    List<PropertyObject> args = frame.getArguments();
    List<PropertyObject> locals = frame.getLocals();

    int maxLookups = args.size() + locals.size() + 1 /* "this" */;

    List<PropertyReference> localRefs = new ArrayList<PropertyReference>(maxLookups);

    {
      // Receiver ("this")
      RefWithDisplayData receiverObject = frame.getReceiver().asWithDisplayData();
      V8ProtocolUtil.putMirror(localRefs, receiverObject,
          V8ProtocolUtil.PropertyNameGetter.THIS);
    }

    // Arguments
    for (int i = 0; i < args.size(); i++) {
      PropertyObject arg = args.get(i);
      V8ProtocolUtil.putMirror(localRefs, arg, V8ProtocolUtil.PropertyNameGetter.SUBPROPERTY);
    }

    // Locals
    for (int i = 0; i < locals.size(); i++) {
      PropertyObject local = locals.get(i);
      V8ProtocolUtil.putMirror(localRefs, local, V8ProtocolUtil.PropertyNameGetter.SUBPROPERTY);
    }

    return localRefs;
  }

  public static List<ScopeMirror> computeScopes(FrameObject frame) {
    List<ScopeRef> scopes = frame.getScopes();

    final List<ScopeMirror> result = new ArrayList<ScopeMirror>(scopes.size());

    for (int i = 0; i < scopes.size(); i++) {
      ScopeRef scope = scopes.get(i);
      int type = (int) scope.type();
      int index = (int) scope.index();

      result.add(new ScopeMirror(type, index));
    }

    return result;
  }

  public static PropertyReference computeReceiverRef(FrameObject frame) {
    RefWithDisplayData receiverObject = frame.getReceiver().asWithDisplayData();
    return V8ProtocolUtil.extractProperty(receiverObject,
        V8ProtocolUtil.PropertyNameGetter.THIS);
  }

  /**
   * Constructs a ValueMirror given a V8 debugger object specification.
   *
   * @param jsonValue containing the object specification from the V8 debugger
   * @return a {@link PropertyHoldingValueMirror} instance, containing data
   *         from jsonValue; not null
   */
  public static PropertyHoldingValueMirror createMirrorFromLookup(ValueHandle valueHandle) {
    String text = valueHandle.text();
    if (text == null) {
      throw new ValueLoadException("Bad lookup result");
    }
    String typeString = valueHandle.type();
    String className = valueHandle.className();
    Type type = JsDataTypeUtil.fromJsonTypeAndClassName(typeString, className);
    if (type == null) {
      throw new ValueLoadException("Bad lookup result: type field not recognized: " + typeString);
    }
    return createMirrorFromLookup(valueHandle, type);
  }

  /**
   * Constructs a {@link ValueMirror} given a V8 debugger object specification if it's possible.
   * @return a {@link ValueMirror} instance, containing data
   *         from {@code jsonValue}; or {@code null} if {@code jsonValue} is not a handle
   */
  public static ValueMirror createValueMirrorOptional(DataWithRef handleFromProperty) {
    RefWithDisplayData withData = handleFromProperty.getWithDisplayData();
    if (withData == null) {
      return null;
    }
    return createValueMirror(withData);
  }
  public static ValueMirror createValueMirrorOptional(ValueHandle valueHandle) {
    return createValueMirror(valueHandle);
  }

  private static ValueMirror createValueMirror(ValueHandle valueHandle) {
    String className = valueHandle.className();
    Type type = JsDataTypeUtil.fromJsonTypeAndClassName(valueHandle.type(), className);
    if (type == null) {
      throw new ValueLoadException("Bad value object");
    }
    String text = valueHandle.text();
    return createMirrorFromLookup(valueHandle, type).getValueMirror();
  }

  private static ValueMirror createValueMirror(RefWithDisplayData jsonValue) {
    String className = jsonValue.className();
    Type type = JsDataTypeUtil.fromJsonTypeAndClassName(jsonValue.type(), className);
    if (type == null) {
      throw new ValueLoadException("Bad value object");
    }
    { // try another format
      if (Type.isObjectType(type)) {
        int refId = (int) jsonValue.ref();
        return ValueMirror.createObjectUnknownProperties(refId, type, className);
      } else {
        // try another format
        Object valueObj = jsonValue.value();
        String valueStr;
        if (valueObj == null) {
          valueStr = jsonValue.type(); // e.g. "undefined"
        } else {
          valueStr = valueObj.toString();
        }
        return ValueMirror.createScalar(valueStr, type, className).getValueMirror();
      }
    }
  }

  private static PropertyHoldingValueMirror createMirrorFromLookup(ValueHandle valueHandle,
      Type type) {
    if (Type.isObjectType(type)) {
      ObjectValueHandle objectValueHandle = valueHandle.asObject();
      int refId = (int) valueHandle.handle();
      SubpropertiesMirror subpropertiesMirror;
      if (type == Type.TYPE_FUNCTION) {
        FunctionValueHandle functionValueHandle = objectValueHandle.asFunction();
        subpropertiesMirror = new SubpropertiesMirror.FunctionValueBased(functionValueHandle,
            FUNCTION_PROPERTY_FACTORY2);
      } else {
        subpropertiesMirror =
          new SubpropertiesMirror.ObjectValueBased(objectValueHandle, null);
      }
      return ValueMirror.createObject(refId, subpropertiesMirror, type, valueHandle.className());
    } else {
      return ValueMirror.createScalar(valueHandle.text(), type, valueHandle.className());
    }
  }

  // TODO(peter.rybin): Get rid of this monstrosity once we switched to type JSON interfaces.
  private static final
      SubpropertiesMirror.JsonBased.AdditionalPropertyFactory<FunctionValueHandle>
      FUNCTION_PROPERTY_FACTORY2 =
      new SubpropertiesMirror.JsonBased.AdditionalPropertyFactory<FunctionValueHandle>() {
    public Object createAdditionalProperties(FunctionValueHandle jsonWithProperties) {
      Long pos = jsonWithProperties.position();
      if (pos == null) {
        pos = Long.valueOf(FunctionAdditionalProperties.NO_POSITION);
      }
      Long scriptId = jsonWithProperties.scriptId();
      if (scriptId == null) {
        scriptId = Long.valueOf(FunctionAdditionalProperties.NO_SCRIPT_ID);
      }
      return new FunctionAdditionalProperties(pos.intValue(), scriptId.intValue());
    }
  };

  public static <MESSAGE, RES, EX extends Exception> RES callV8Sync(
      V8CommandSender<MESSAGE, EX> commandSender, MESSAGE message,
      V8BlockingCallback<RES> callback) throws EX {
    return callV8Sync(commandSender, message, callback,
        CallbackSemaphore.OPERATION_TIMEOUT_MS);
  }

  public static <MESSAGE, RES, EX extends Exception> RES callV8Sync(
      V8CommandSender<MESSAGE, EX> commandSender,
      MESSAGE message, final V8BlockingCallback<RES> callback, long timeoutMs) throws EX {
    CallbackSemaphore syncCallback = new CallbackSemaphore();
    final Exception [] exBuff = { null };
    // A long way of creating buffer for generic type without warnings.
    final List<RES> resBuff = new ArrayList<RES>(Collections.nCopies(1, (RES)null));
    V8CommandProcessor.V8HandlerCallback callbackWrapper =
        new V8CommandProcessor.V8HandlerCallback() {
      public void failure(String message) {
        exBuff[0] = new Exception("Failure: " + message);
      }

      public void messageReceived(CommandResponse response) {
        RES result = callback.messageReceived(response);
        resBuff.set(0, result);
      }
    };
    commandSender.sendV8CommandAsync(message, true, callbackWrapper, syncCallback);

    boolean waitRes;
    try {
      waitRes = syncCallback.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS);
    } catch (RuntimeException e) {
      throw new CallbackException(e);
    }

    if (!waitRes) {
      throw new CallbackException("Timeout");
    }

    if (exBuff[0] != null) {
      throw new CallbackException(exBuff[0]);
    }

    return resBuff.get(0);
  }

  /**
   * Special kind of exceptions for problems in receiving or waiting for the answer.
   * Clients may try to catch it.
   */
  public static class CallbackException extends RuntimeException {
    CallbackException() {
    }
    CallbackException(String message, Throwable cause) {
      super(message, cause);
    }
    CallbackException(String message) {
      super(message);
    }
    CallbackException(Throwable cause) {
      super(cause);
    }
  }
}