/*
 * Copyright 2011 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.core.client.debug;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;

/**
 * This class provides an API for IDEs to inspect JavaScript objects and is not
 * intended to be used in GWT applications. IDEs that allow custom value
 * renderers for debugging can use it to box JavaScript objects into suitable
 * Java types.
 * 
 * TODO: provide a way to test whether a node has children (to be used as an
 * optimization in IntelliJ).
 * 
 * TODO: implement and return concrete JsoProperty subtypes (Integer, Float,
 * etc.) to get more descriptive labels in IntelliJ.
 */
public class JsoInspector {

  /**
   * A simple Java object to hold a key and value pair.
   */
  public static class JsoProperty implements Comparable<JsoProperty> {
    public final String key;
    public final Object value;
    public final boolean isOwnProperty;

    private JsoProperty(String key, Object value, boolean isOwnProperty) {
      this.key = key;
      this.value = value;
      this.isOwnProperty = isOwnProperty;
    }

    @Override
    public int compareTo(JsoProperty o) {
      int keyComparison = key.compareTo(o.key);

      /*
       * The hash code comparison is so this class's natural ordering is
       * consistent (see Comparable interface javadoc). Ideally, we would have
       * done value.compareTo(o.value), but value may not implement Comparable.
       */
      return keyComparison != 0 ? keyComparison : value.hashCode()
          - o.value.hashCode();
    }

    @Override
    public String toString() {
      StringBuilder s = new StringBuilder();

      if (isOwnProperty) {
        s.append('*');
      }

      s.append(key).append(": ");

      if (value instanceof String) {
        s.append('"').append(value).append('"');
      } else {
        s.append(value);
      }

      return s.toString();
    }
  }

  private static class JsoBoxer extends JavaScriptObject {

    protected JsoBoxer() {
    }

    /**
     * Returns a Java object that represents this JavaScriptObject instance. The
     * returned Java object may still contain other JavaScriptObjects. Eclipse
     * will attempt to lazily fetch the logical structure for those children
     * JavaScriptObjects when the user clicks on one of them.
     */
    public final native Object box() /*-{

      // Returns a Java object for simpler JavaScript values
      // (primitives, functions, null, undefined), or the given value
      // if it is not a "simple" type
      var asJavaObjectForSimpleValue = function(value) {
        var valueType = typeof(value);

        // Earlier, I had function types printing their function contents,
        // but pure Java classes in GWT get converted to function prototypes
        // in Javascript, so there were issues
        if (valueType == "number") {
          // Differentiate int from float
          if (/[.]/.test(value + '')) {
            return @java.lang.Float::new(F)(value);
          } else {
            return @java.lang.Integer::new(I)(value);
          }
        } else if (valueType == "boolean") {
          return @java.lang.Boolean::new(Z)(value);
        } else if (valueType == "string") {
          return value;
        } else if (valueType == "undefined" || valueType == "null") {
          // Return the corresponding string
          return valueType;
        } else {
          return value;
        }
      }

      var asJavaObject = function(value) {
        var valueType = typeof(value);

        if (valueType == "object") {
          if (value instanceof Array) {
            var list = @java.util.ArrayList::new()();
            for (i in value) {
              list.@java.util.ArrayList::add(Ljava/lang/Object;)(asJavaObjectForSimpleValue(value[i]));
            }

            // If we return a List, Eclipse's Variables view will show one
            // extra level unnecessarily. It does not do this for Java arrays.
            return list.@java.util.ArrayList::toArray()();

          } else {
            var properties = @java.util.ArrayList::new()();

            for (var name in value) {
              var propertyValue;
              try {
                var origPropertyValue = value[name];
                if (typeof(origPropertyValue) == "function"
                    && !value.hasOwnProperty(name)) {
                  // Prevent every JavaScriptObject method from appearing
                  continue;
                }

                // Sometimes, we don't have permission to see the value
                // and an exception is thrown
                propertyValue = asJavaObjectForSimpleValue(origPropertyValue);
              } catch (e) {
                propertyValue = "ERROR: " + e.name + " - " + e.message;
              }

              // Wrap the (key, value) in our JsoProperty class
              var jsoProperty = @com.google.gwt.core.client.debug.JsoInspector.JsoProperty::new(Ljava/lang/String;Ljava/lang/Object;Z)(name, propertyValue, value.hasOwnProperty(name));
              properties.@java.util.ArrayList::add(Ljava/lang/Object;)(jsoProperty);
            }

            // Sort the properties
            @java.util.Collections::sort(Ljava/util/List;)(properties);

            // If we return a List, Eclipse's Variables view will show one
            // extra level unnecessarily. It does not do this for Java arrays.
            var propertiesAsArray = properties.@java.util.ArrayList::toArray()();

            return propertiesAsArray;
          }
        } else {
          return asJavaObjectForSimpleValue(value);
        }
      };

      return asJavaObject(this);
    }-*/;
  }

  /**
   * Wraps a JavaScript object into a suitable inspectable type.
   */
  public static Object convertToInspectableObject(Object jso) {
    try {
      JsoBoxer boxer = (JsoBoxer) jso;
      return boxer.box();
    } catch (Throwable t) {
      GWT.log("GWT could not inspect the JavaScriptObject.", t);
      return "ERROR: Could not inspect the JavaScriptObject, see GWT log for details.";
    }
  }
}