// 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;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import org.chromium.sdk.internal.InternalContext.ContextDismissedCheckedException;

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

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

import org.chromium.sdk.internal.protocol.data.ObjectValueHandle;

import org.chromium.sdk.internal.protocol.data.SomeHandle;

import org.chromium.sdk.internal.protocol.data.ValueHandle;

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

import org.chromium.sdk.internal.tools.v8.V8BlockingCallback;

import org.chromium.sdk.internal.tools.v8.V8Helper;

import org.chromium.sdk.internal.tools.v8.V8ProtocolUtil;

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

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

import org.json.simple.JSONObject;

/**

 * The elaborate factory for {@link ValueMirror}'s, that loads values from remote and

 * caches them. All the data comes originally in form of JSON strings which may contain

 * less or more fields, so it creates {@link ValueMirror} or {@link PropertyHoldingValueMirror}

 * accordingly.

 */

public class ValueLoader {

  private final ConcurrentMap<Long, ValueMirror> refToMirror =

      new ConcurrentHashMap<Long, ValueMirror>();

  private final InternalContext context;

  ValueLoader(InternalContext context) {

    this.context = context;

  }

  /**

   * Receives {@link ValueMirror} and makes sure it has its properties loaded.

   */

  public PropertyHoldingValueMirror loadSubpropertiesInMirror(ValueMirror mirror) {

    PropertyHoldingValueMirror references = mirror.getProperties();

    if (references == null) {

      // need to look up this value again

      List<PropertyHoldingValueMirror> loadedMirrors =

          loadValuesFromRemote(Collections.singletonList(Long.valueOf(mirror.getRef())));

      references = loadedMirrors.get(0);

    }

    return references;

  }

  /**

   * Looks up data for scope on remote.

   */

  public List<? extends PropertyReference> loadScopeFields(int scopeNumber, int frameNumber) {

    DebuggerMessage message = DebuggerMessageFactory.scope(scopeNumber, frameNumber);

    V8BlockingCallback<List<? extends PropertyReference>> callback =

        new V8BlockingCallback<List<? extends PropertyReference>>() {

      @Override

      protected List<? extends PropertyReference> handleSuccessfulResponse(

          SuccessCommandResponse response) {

        return readFromScopeResponse(response);

      }

    };

    try {

      return V8Helper.callV8Sync(context, message, callback);

    } catch (ContextDismissedCheckedException e) {

      context.getDebugSession().maybeRethrowContextException(e);

      // or

      return Collections.emptyList();

    }

  }

  private List<? extends PropertyReference> readFromScopeResponse(SuccessCommandResponse response) {

    List<SomeHandle> refs = response.getRefs();

    HandleManager handleManager = context.getHandleManager();

    for (int i = 0; i < refs.size(); i++) {

      SomeHandle ref = refs.get(i);

      handleManager.put(ref);

    }

    ScopeBody body;

    try {

      body = response.getBody().asScopeBody();

    } catch (JsonProtocolParseException e) {

      throw new ValueLoadException(e);

    }

    ObjectValueHandle objectRef = body.getObject();

    return V8ProtocolUtil.extractObjectProperties(objectRef);

  }

/**

   * For each PropertyReference from propertyRefs tries to either: 1. read it from PropertyReference

   * (possibly cached value) or 2. lookup value by refId from remote

   */

  public List<ValueMirror> getOrLoadValueFromRefs(List<? extends PropertyReference> propertyRefs) {

    ValueMirror[] result = new ValueMirror[propertyRefs.size()];

    List<Integer> mapForLoadResults = new ArrayList<Integer>();

    List<PropertyReference> needsLoading = new ArrayList<PropertyReference>();

    for (int i = 0; i < propertyRefs.size(); i++) {

      PropertyReference ref = propertyRefs.get(i);

      ValueMirror mirror = readFromPropertyReference(ref);

      if (mirror == null) {

        // We don't have the data (enough) right now. We are requesting them from server.

        // There might be simultaneous request for the same value, which is a normal though

        // undesired case.

        needsLoading.add(ref);

        mapForLoadResults.add(i);

      }

      result[i] = mirror;

    }

    List<Long> refIds = getRefIdFromReferences(needsLoading);

    List<PropertyHoldingValueMirror> loadedMirrors = loadValuesFromRemote(refIds);

    assert refIds.size() == loadedMirrors.size();

    for (int i = 0; i < loadedMirrors.size(); i++) {

      int pos = mapForLoadResults.get(i);

      result[pos] = loadedMirrors.get(i).getValueMirror();

    }

    return Arrays.asList(result);

  }

  private static List<Long> getRefIdFromReferences(final List<PropertyReference> propertyRefs) {

    List<Long> result = new ArrayList<Long>(propertyRefs.size());

    for (PropertyReference ref : propertyRefs) {

      result.add(Long.valueOf(ref.getRef()));

    }

    return result;

  }

  /**

   * Reads data from caches or from JSON from propertyReference. Never accesses remote.

   */

  private ValueMirror readFromPropertyReference(PropertyReference propertyReference) {

    Long refIdObject = propertyReference.getRef();

    ValueMirror mirror = refToMirror.get(refIdObject);

    if (mirror != null) {

      return mirror;

    }

    SomeHandle cachedHandle = context.getHandleManager().getHandle(refIdObject);

    // If we have cached handle, we reads cached handle, not using one from propertyeReference

    // because we expect to find more complete version in cache. Is it ok?

    if (cachedHandle != null) {

      ValueHandle valueHandle;

      try {

        valueHandle = cachedHandle.asValueHandle();

      } catch (JsonProtocolParseException e) {

        throw new RuntimeException(e);

      }

      mirror = V8Helper.createValueMirrorOptional(valueHandle);

    } else {

      DataWithRef handleFromProperty = propertyReference.getValueObject();

      mirror = V8Helper.createValueMirrorOptional(handleFromProperty);

    }

    if (mirror != null) {

      ValueMirror mirror2 = refToMirror.putIfAbsent(refIdObject, mirror);

      if (mirror2 != null) {

        mergeMirrors(mirror2, mirror);

      }

    }

    return mirror;

  }

  /**

   * Requests values from remote via "lookup" command. Automatically caches JSON objects

   * in {@link HandleManager}.

   * @param propertyRefIds list of ref ids we need to look up

   * @return loaded value mirrors in the same order as in propertyRefIds

   */

  public List<PropertyHoldingValueMirror> loadValuesFromRemote(final List<Long> propertyRefIds) {

    if (propertyRefIds.isEmpty()) {

      return Collections.emptyList();

    }

    DebuggerMessage message = DebuggerMessageFactory.lookup(propertyRefIds, false);

    V8BlockingCallback<List<PropertyHoldingValueMirror>> callback =

        new V8BlockingCallback<List<PropertyHoldingValueMirror>>() {

      @Override

      protected List<PropertyHoldingValueMirror> handleSuccessfulResponse(

          SuccessCommandResponse response) {

        return readResponseFromLookup(response, propertyRefIds);

      }

    };

    try {

      return V8Helper.callV8Sync(context, message, callback);

    } catch (ContextDismissedCheckedException e) {

      context.getDebugSession().maybeRethrowContextException(e);

      // or

      throw new ValueLoadException("Invalid context", e);

    }

  }

  private List<PropertyHoldingValueMirror> readResponseFromLookup(

      SuccessCommandResponse successResponse, List<Long> propertyRefIds) {

    List<PropertyHoldingValueMirror> result =

        new ArrayList<PropertyHoldingValueMirror>(propertyRefIds.size());

    JSONObject body;

    try {

      body = successResponse.getBody().asLookupMap();

    } catch (JsonProtocolParseException e) {

      throw new ValueLoadException(e);

    }

    for (int i = 0; i < propertyRefIds.size(); i++) {

      int ref = propertyRefIds.get(i).intValue();

      JSONObject value = JsonUtil.getAsJSON(body, String.valueOf(ref));

      if (value == null) {

        throw new ValueLoadException("Failed to find value for ref=" + ref);

      }

      SomeHandle smthHandle = context.getHandleManager().put((long)ref, value);

      ValueHandle valueHandle;

      try {

        valueHandle = smthHandle.asValueHandle();

      } catch (JsonProtocolParseException e) {

        throw new ValueLoadException(e);

      }

      result.add(readMirrorFromLookup(ref, valueHandle));

    }

    return result;

  }

  /**

   * Constructs a ValueMirror given a V8 debugger object specification and the

   * value name.

   *

   * @param jsonValue containing the object specification from the V8 debugger

   * @param ref

   * @return a ValueMirror instance with the specified name, containing data

   *         from handle, or {@code null} if {@code handle} is not a handle

   */

  private PropertyHoldingValueMirror readMirrorFromLookup(int ref, ValueHandle jsonValue) {

    PropertyHoldingValueMirror propertiesMirror = V8Helper.createMirrorFromLookup(jsonValue);

    ValueMirror newMirror = propertiesMirror.getValueMirror();

    ValueMirror oldMirror = refToMirror.putIfAbsent((long)ref, newMirror);

    if (oldMirror != null) {

      mergeMirrors(oldMirror, newMirror);

    }

    return propertiesMirror;

  }

  private static void mergeMirrors(ValueMirror baseMirror, ValueMirror alternativeMirror) {

    baseMirror.mergeFrom(alternativeMirror);

  }

}