/* Very basic JNI support for JS
 *
 * Example Usage:
 *   let jni = new JNI();
 *   cls = jni.findClass("org/mozilla/gecko/GeckoAppShell");
 *   method = jni.getStaticMethodID(cls, "getPreferredIconSize", "(I)I");
 *
 *   let val = jni.callStaticIntMethod(cls, method, 3);
 *   // close the jni library when you are done
 *   jni.close();
 *
 * Note: the getters in this file are deleted and replaced with static
 * values once computed, as in, for example
 * http://code.activestate.com/recipes/577310-using-a-getter-for-a-one-time-calculation-of-a-jav/
 */
this.EXPORTED_SYMBOLS = ["JNI"];

Components.utils.import("resource://gre/modules/ctypes.jsm")
Components.utils.import("resource://gre/modules/Services.jsm")

this.JNI = function JNI() { }

JNI.prototype = {
  get lib() {
    delete this.lib;
    return this.lib = ctypes.open("libxul.so");
  },

  getType: function(aType) {
    switch(aType) {
      case "B": return ctypes.char;
      case "C": return ctypes.char;
      case "D": return ctypes.double;
      case "F": return ctypes.float;
      case "I": return ctypes.int32_t;
      case "J": return ctypes.int64_t;
      case "S": return ctypes.int16_t;
      case "V": return ctypes.void_t;
      case "Z": return ctypes.bool;
      default: return this.types.jobject
    }
  },

  getArgs: function(aMethod, aArgs) {
    if (aArgs.length != aMethod.parameters.length)
      throw ("Incorrect number of arguments passed to " + aMethod.name);

    // Convert arguments to an array of jvalue objects
    let modifiedArgs = new ctypes.ArrayType(this.types.jvalue, aMethod.parameters.length)();
    for (let i = 0; i < aMethod.parameters.length; i++) {
      let parameter = aMethod.parameters[i];
      let arg = new this.types.jvalue();

      if (aArgs[i] instanceof Array || parameter[0] == "[")
        throw "No support for array arguments yet";
      else
        ctypes.cast(arg, this.getType(parameter)).value = aArgs[i];

      modifiedArgs[i] = arg;
    }

    return modifiedArgs;
  },

  types: {
    jobject: ctypes.StructType("_jobject").ptr,
    jclass: ctypes.StructType("_jobject").ptr,
    jmethodID: ctypes.StructType("jmethodID").ptr,
    jvalue: ctypes.double
  },

  get _findClass() {
    delete this._findClass;
    return this._findClass = this.lib.declare("jsjni_FindClass",
                                              ctypes.default_abi,
                                              this.types.jclass,
                                              ctypes.char.ptr);
  },

  findClass: function(name) {
    let ret = this._findClass(name);
    if (this.exceptionCheck())
       throw("Can't find class " + name);
    return ret;
  },

  get _getStaticMethodID() {
    delete this._getStaticMethodID;
    return this._getStaticMethodID = this.lib.declare("jsjni_GetStaticMethodID",
                                                      ctypes.default_abi,
                                                      this.types.jmethodID,
                                                      this.types.jclass, // class
                                                      ctypes.char.ptr,   // method name
                                                      ctypes.char.ptr);  // signature
  },

  getStaticMethodID: function(aClass, aName, aSignature) {
    let ret = this._getStaticMethodID(aClass, aName, aSignature);
    if (this.exceptionCheck())
       throw("Can't find method " + aName);
    return new jMethod(aName, ret, aSignature);
  },

  get _exceptionCheck() {
    delete this._exceptionCheck;
    return this._exceptionCheck = this.lib.declare("jsjni_ExceptionCheck",
                                                   ctypes.default_abi,
                                                   ctypes.bool);
  },

  exceptionCheck: function() {
    return this._exceptionCheck();
  },

  get _callStaticVoidMethod() {
    delete this._callStaticVoidMethod;
    return this._callStaticVoidMethod = this.lib.declare("jsjni_CallStaticVoidMethodA",
                                                   ctypes.default_abi,
                                                   ctypes.void_t,
                                                   this.types.jclass,
                                                   this.types.jmethodID,
                                                   this.types.jvalue.ptr);
  },

  callStaticVoidMethod: function(aClass, aMethod) {
    let args = Array.prototype.slice.apply(arguments, [2]);
    this._callStaticVoidMethod(aClass, aMethod.methodId, this.getArgs(aMethod, args));
    if (this.exceptionCheck())
       throw("Error calling static void method");
  },

  get _callStaticIntMethod() {
    delete this._callStaticIntMethod;
    return this._callStaticIntMethod = this.lib.declare("jsjni_CallStaticIntMethodA",
                                                   ctypes.default_abi,
                                                   ctypes.int,
                                                   this.types.jclass,
                                                   this.types.jmethodID,
                                                   this.types.jvalue.ptr);
  },

  callStaticIntMethod: function(aClass, aMethod) {
    let args = Array.prototype.slice.apply(arguments, [2]);
    let ret = this._callStaticIntMethod(aClass, aMethod.methodId, this.getArgs(aMethod, args));
    if (this.exceptionCheck())
       throw("Error calling static int method");
    return ret;
  },

  close: function() {
    this.lib.close();
  },
}

function jMethod(name, jMethodId, signature) {
  this.name = name;
  this.methodId = jMethodId;
  this.signature = signature;
}

jMethod.prototype = {
  parameters: [],
  returnType: null,
  _signature: "",

  // this just splits up the return value from the parameters
  signatureRegExp: /^\(([^\)]*)\)(.*)$/,

  // This splits up the actual parameters
  parameterRegExp: /(\[*)(B|C|D|F|I|J|S|V|Z|L[^;]*;)/y,

  parseSignature: function(aSignature) {
    let [, parameters, returnType] = this.signatureRegExp.exec(aSignature);

    // parse the parameters that should be passed to this method
    if (parameters) {
      let parameter = this.parameterRegExp.exec(parameters);
      while (parameter) {
        this.parameters.push(parameter[0]);
        parameter = this.parameterRegExp.exec(parameters);
      }
    } else {
      this.parameters = [];
    }

    // parse the return type
    this.returnType = returnType;
  },

  _signature: "",
  get signature() { return this._signature; },
  set signature(val) {
    this.parameters = [];
    this.returnType = null;
    this.parseSignature(val);
  }
}