
/*
 * weinre is available under *either* the terms of the modified BSD license *or* the
 * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
 * 
 * Copyright (c) 2010, 2011 IBM Corporation
 */

requireClass ./Ex
requireClass ./Callback

//-----------------------------------------------------------------------------
class IDLTools
    throw new Ex(arguments, "this class is not intended to be instantiated")

//-----------------------------------------------------------------------------
init
    var IDLs = {}
    IDLTools._idls = IDLs

//-----------------------------------------------------------------------------
static method addIDLs(idls)
    idls.forEach(function(idl){
        idl.interfaces.forEach(function(intf){
            IDLs[intf.name] = intf
            intf.module = idl.name
        })
    })

//-----------------------------------------------------------------------------
static method getIDL(name)
    return IDLs[name]

//-----------------------------------------------------------------------------
static method getIDLsMatching(regex)
    var results = []
    
    for (var intfName in IDLs) {
        var intf = IDLs[intfName]
        if (intfName.match(regex)) {
            results.push(intf)
        }
    }
    return results

//-----------------------------------------------------------------------------
static method validateAgainstIDL(klass, interfaceName)
    var intf = IDLTools.getIDL(interfaceName)
    var messagePrefix = "IDL validation for " + interfaceName + ": "
    if (null == intf) throw new Ex(arguments, messagePrefix + "idl not found: '" + interfaceName + "'")
    
    var errors = []
    // check that class implements all the methods
    intf.methods.forEach(function(intfMethod) {
        var classMethod  = klass.prototype[intfMethod.name]
        var printName    = klass.name + "::" + intfMethod.name
        
        if (null == classMethod) {
            errors.push(messagePrefix + "method not implemented: '" + printName + "'")
            return
        }

        if (classMethod.length != intfMethod.parameters.length) {
            if (classMethod.length != intfMethod.parameters.length + 1) {
                errors.push(messagePrefix + "wrong number of parameters: '" + printName + "'")
                return
            }
        }
    })
    
    // check that class doesn't implement extra methods
    for (var propertyName in klass.prototype) {
        if (klass.prototype.hasOwnProperty(propertyName)) continue
        if (propertyName.match(/^_.*/)) continue
        
        var printName = klass.name + "::" + propertyName
        
        if (!intf.methods[propertyName]) {
            errors.push(messagePrefix + "method should not be implemented: '" + printName + "'")
            continue
        }
    }
    
    if (!errors.length) return
    
    errors.forEach(function(error){
        require("./Weinre").logError(error)
    })

//-----------------------------------------------------------------------------
static method buildProxyForIDL(proxyObject, interfaceName)
    var intf = IDLTools.getIDL(interfaceName)
    var messagePrefix = "building proxy for IDL " + interfaceName + ": "
    if (null == intf) throw new Ex(arguments, messagePrefix + "idl not found: '" + interfaceName + "'")
    
    intf.methods.forEach(function(intfMethod) {
        proxyObject[intfMethod.name] = getProxyMethod(intf, intfMethod)
    })

//-----------------------------------------------------------------------------
function getProxyMethod(intf, method)
    var result = function proxyMethod() {
        var callbackId = null
        var args       = [].slice.call(arguments)
        
        if (args.length > 0) {
            if (typeof args[args.length-1] == "function") {
                callbackId   = Callback.register(args[args.length-1])
                args         = args.slice(0, args.length-1)
            }
        }
        
        while (args.length < method.parameters.length) {
            args.push(null)
        }
        
        args.push(callbackId)

        this.__invoke(intf.name, method.name, args)
    }
    
    result.displayName = intf.name + "__" + method.name
    return result