/*
 * Copyright (C) 2019 Intel Corporation.  All rights reserved.
 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */

#ifdef ENABLE_JEFF

#include "module_jeff.h"
#include "jeff_export.h"
#include "../vmcore_jeff/jeff-runtime.h"
#include "../vmcore_jeff/jeff-thread.h"
#include "../vmcore_jeff/jeff-buffer.h"
#include "../vmcore_jeff/jeff-tool.h"
#include "../vmcore_jeff/jeff-tool-priv.h"
#include "app_manager-host.h"
#include "bh_queue.h"
#include "attr-container.h"
#include "attr-container-util.h"
#include "bh_thread.h"
#include "ems_gc.h"
#include "coap_ext.h"
#include "libcore.h"
#include "event.h"
#include "watchdog.h"

#define DEFAULT_APPLET_TIMEOUT (3 * 60 * 1000)
#define DEFAULT_APPLET_HEAP_SIZE (48 * 1024)
#define MIN_APPLET_HEAP_SIZE (2 * 1024)
#define MAX_APPLET_HEAP_SIZE (1024 * 1024)

typedef struct jeff_applet_data {
    /* Java Applet Object */
    JeffObjectRef applet_obj;

#if BEIHAI_ENABLE_TOOL_AGENT != 0
    /* Whether the applet is in debug mode */
    bool debug_mode;
    /* Queue of the tool agent */
    bh_queue *tool_agent_queue;
#endif

    /* VM instance */
    JeffInstanceLocalRoot *vm_instance;
    /* Applet Main file */
    JeffFileHeaderLinked *main_file;
    /* Permissions of the Java Applet */
    char *perms;
}jeff_applet_data;

/* Jeff class com.intel.aee.AEEApplet */
static JeffClassHeaderLinked *class_AEEApplet;
/* Jeff class com.intel.aee.Request */
static JeffClassHeaderLinked *class_AEERequest;
/* Jeff class com.intel.aee.Timer */
static JeffClassHeaderLinked *class_Timer;
/* Jeff class com.intel.aee.Sensor */
static JeffClassHeaderLinked *class_Sensor;
/* Jeff class com.intel.aee.ble.BLEManager */
static JeffClassHeaderLinked *class_BLEManager;
/* Jeff class com.intel.aee.ble.BLEDevice */
static JeffClassHeaderLinked *class_BLEDevice;
/* Jeff class com.intel.aee.ble.BLEGattService */
JeffClassHeaderLinked *class_BLEGattService;
/* Jeff class com.intel.aee.ble.BLEGattCharacteristic */
JeffClassHeaderLinked *class_BLEGattCharacteristic;
/* Jeff class com.intel.aee.ble.BLEGattDescriptor */
JeffClassHeaderLinked *class_BLEGattDescriptor;
/* Jeff class com.intel.aee.gpio.GPIOChannel */
static JeffClassHeaderLinked *class_GPIOChannel;
/* Jeff method void com.intel.aee.AEEApplet.onInit() */
static JeffMethodLinked *method_AEEApplet_onInit;
/* Jeff method void com.intel.aee.AEEApplet.onDestroy() */
static JeffMethodLinked *method_AEEApplet_onDestroy;
/* Jeff method void com.intel.aee.AEEApplet.callOnRequest(Request request) */
static JeffMethodLinked *method_AEEApplet_callOnRequest;
/* Jeff method void com.intel.aee.Timer.callOnTimer() */
static JeffMethodLinked *method_callOnTimer;
/* Jeff method void com.intel.aee.Sensor.callOnSensorEvent() */
static JeffMethodLinked *method_callOnSensorEvent;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLEStartDiscovery() */
static JeffMethodLinked *method_callOnBLEStartDiscovery;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLEConnected() */
static JeffMethodLinked *method_callOnBLEConnected;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLEDisonnected() */
static JeffMethodLinked *method_callOnBLEDisconnected;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLENotification() */
static JeffMethodLinked *method_callOnBLENotification;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLEIndication() */
static JeffMethodLinked *method_callOnBLEIndication;
/* Jeff method void com.intel.aee.ble.BLEManager.callOnBLEPasskeyEntry() */
static JeffMethodLinked *method_callOnBLEPasskeyEntry;
/* Jeff method void com.intel.aee.gpio.GPIOChannel.callOnGPIOInterrupt() */
static JeffMethodLinked *method_callOnGPIOInterrupt;
/* Jeff method void com.intel.aee.ble.BLEManager.getBLEDevice() */
static JeffMethodLinked *method_callOnBLEManagerGetBLEDevice;

static jeff_applet_data *
app_manager_get_jeff_applet_data()
{
    module_data *m_data = app_manager_get_module_data(Module_Jeff);
    return (jeff_applet_data *)m_data->internal_data;
}

#if BEIHAI_ENABLE_TOOL_AGENT != 0
void *
app_manager_get_tool_agent_queue()
{
    return app_manager_get_jeff_applet_data()->tool_agent_queue;
}
#endif

#if BEIHAI_ENABLE_TOOL_AGENT != 0
static bool
is_tool_agent_running(module_data *m_data)
{
    jeff_applet_data *applet_data = (jeff_applet_data*)m_data->internal_data;
    return (applet_data->debug_mode
            && applet_data->tool_agent_queue
            && applet_data->vm_instance->tool_agent);
}
#endif

static char *
get_class_qname(const JeffString *pname, const JeffString *cname)
{
    unsigned int length = pname->length ? pname->length + 2 + cname->length
    : cname->length + 1;
    char *buf = APP_MGR_MALLOC(length), *p;

    if (!buf)
    return NULL;

    p = buf;
    if (pname->length) {
        bh_memcpy_s(p, pname->length, pname->value, pname->length);
        p += pname->length;
        *p++ = '.';
    }

    bh_memcpy_s(p, cname->length, cname->value, cname->length);
    p += cname->length;
    *p = '\0';

    return buf;
}

static void
send_exception_event_to_host(const char *applet_name, const char *exc_name)
{
    attr_container_t *payload;
    bh_request_msg_t msg;
    char *url;
    int url_len;

    payload = attr_container_create("exception detail");
    if (!payload) {
        app_manager_printf("Send exception to host fail: allocate memory");
        return;
    }

    if (!attr_container_set_string(&payload, "exception name", exc_name)
            || !attr_container_set_string(&payload, "stack trace", "TODO")
            || !attr_container_set_string(&payload, "applet name", applet_name)) {
        app_manager_printf("Send exception to host fail: set attr");
        goto fail;
    }

    url_len = strlen("/exception/") + strlen(applet_name);
    url = APP_MGR_MALLOC(url_len + 1);
    if (!url) {
        app_manager_printf("Send exception to host fail: allocate memory");
        goto fail;
    }
    memset(url, 0, url_len + 1);
    bh_strcpy_s(url, url_len + 1, "/exception/");
    bh_strcat_s(url, url_len + 1, applet_name);

    memset(&msg, 0, sizeof(msg));
    msg.url = url;
    msg.action = COAP_PUT;
    msg.payload = (char *)payload;

    app_send_request_msg_to_host(&msg);

    APP_MGR_FREE(url);

    fail:
    attr_container_destroy(payload);
}

static bool
check_exception()
{
    if (jeff_runtime_get_exception()) {
        jeff_printf("V1.Exception thrown when running applet '%s':\n",
                app_manager_get_module_name(Module_Jeff));
        jeff_runtime_print_exception();
        jeff_printf("\n");
        jeff_printf(NULL);

        if (!app_manager_is_interrupting_module(Module_Jeff)) {
            attr_container_t *payload;
            int payload_len;
            JeffClassHeaderLinked *exc_class = jeff_object_class_pointer(jeff_runtime_get_exception());
            char *qname_buf = get_class_qname(jeff_get_class_pname(exc_class),
                    jeff_get_class_cname(exc_class));

            /* Send exception event to host */
            if (qname_buf) {
                send_exception_event_to_host(app_manager_get_module_name(Module_Jeff), qname_buf);
                APP_MGR_FREE(qname_buf);
            }

            /* Uninstall the applet */
            if ((payload = attr_container_create("uninstall myself"))) {
                if (attr_container_set_string(&payload, "name", app_manager_get_module_name(Module_Jeff))
                        /* Set special flag to prevent app manager making response since this is an internal message */
                        && attr_container_set_bool(&payload, "do not reply me", true)) {
                    request_t request = {0};
                    payload_len = attr_container_get_serialize_length(payload);

                    init_request(request, "/applet", COAP_DELETE, (char *)payload, payload_len));
                    app_mgr_lookup_resource(&request);

                    // TODO: confirm this is right
                    attr_container_destroy(payload);
                }
            }

            jeff_runtime_set_exception(NULL);
            return true;
        }

        return false;
    }

    static bool
    app_manager_initialize_class(JeffClassHeaderLinked *c)
    {
        jeff_runtime_initialize_class(c);
        return !check_exception();
    }

    static bool
    app_manager_initialize_object(JeffObjectRef obj)
    {
        jeff_runtime_initialize_object(obj);
        return !check_exception();
    }

    static bool
    app_manager_call_java(JeffMethodLinked *method,
    unsigned int argc, uint32 argv[], uint8 argt[])
    {
        module_data *m_data = app_manager_get_module_data(Module_Jeff);
        watchdog_timer *wd_timer = &m_data->wd_timer;
        bool is_wd_started = false;

#if BEIHAI_ENABLE_TOOL_AGENT != 0
        /* Only start watchdog when debugger is not running */
        if (!is_tool_agent_running(m_data)) {
#endif
            watchdog_timer_start(wd_timer);
            is_wd_started = true;
#if BEIHAI_ENABLE_TOOL_AGENT != 0
        }
#endif

        jeff_runtime_call_java(method, argc, argv, argt);

        if (is_wd_started) {
            os_mutex_lock(&wd_timer->lock);
            if (!wd_timer->is_interrupting) {
                wd_timer->is_stopped = true;
                watchdog_timer_stop(wd_timer);
            }
            os_mutex_unlock(&wd_timer->lock);
        }

        return !check_exception();
    }

    static AEEBLEDevice
    create_object_BLEDevice(ble_device_info *dev_info)
    {
        JeffLocalObjectRef ref;
        AEEBLEDevice dev_struct;

        jeff_runtime_push_local_object_ref(&ref);

        ref.val = jeff_runtime_new_object(class_BLEDevice);

        if (!ref.val) {
            jeff_runtime_pop_local_object_ref(1);
            return NULL;
        }

        dev_struct = (AEEBLEDevice) (ref.val);
        dev_struct->rssi = dev_info->rssi;
        dev_struct->mac = (jbyteArray) jeff_runtime_create_byte_array((int8 *)dev_info->mac, 6);

        app_manager_printf("adv_data_len:%d,scan_response_len:%d\n", dev_info->adv_data_len, dev_info->scan_response_len);

        dev_struct->advData = (jbyteArray) jeff_runtime_create_byte_array((int8 *)dev_info->adv_data, dev_info->adv_data_len);
        dev_struct->scanResponse = (jbyteArray) jeff_runtime_create_byte_array((int8 *)dev_info->scan_response, dev_info->scan_response_len);
        dev_struct->addressType = dev_info->address_type;
        jeff_runtime_initialize_object(ref.val);
        jeff_runtime_pop_local_object_ref(1);
        if ((dev_struct->mac == NULL) || (dev_struct->advData == NULL) || (dev_struct->scanResponse == NULL)) {
            return NULL;
        }
        return (AEEBLEDevice) ref.val;
    }

    static void
    app_instance_process_ble_msg(char *msg)
    {
        bh_queue_ble_sub_msg_t *ble_msg = (bh_queue_ble_sub_msg_t *)msg;
        unsigned int argv[5];
        uint8 argt[5];

        ble_device_info *dev_info;

        dev_info = (ble_device_info *) ble_msg->payload;
        AEEBLEDevice ble_dev;

        argv[0] = (unsigned int) (jbyteArray) jeff_runtime_create_byte_array((int8 *)dev_info->mac, 6);
        argt[0] = 1;
        if (!app_manager_call_java(method_callOnBLEManagerGetBLEDevice, 1, argv, argt)) {
            app_manager_printf("app_manager_call_java BLEManagerGetBLEDevice fail error\n");
            goto fail;
        }
        ble_dev = (AEEBLEDevice) argv[0];
        if (ble_dev == NULL) {
            ble_dev = create_object_BLEDevice(dev_info);
            if (ble_dev == NULL) {
                goto fail;
            }
        }

        switch (ble_msg->type) {
            case BLE_SUB_EVENT_DISCOVERY:
            {
                argv[0] = (unsigned int) ble_dev;
                argt[0] = 1;
                ble_dev->rssi = dev_info->rssi;
                if (!app_manager_call_java(method_callOnBLEStartDiscovery, 1, argv, argt)) {
                    app_manager_printf("app_manager_call_java method_callOnBLEStartDiscovery fail error\n");
                    goto fail;
                }
            }
            break;

            case BLE_SUB_EVENT_CONNECTED:
            {
                if (ble_dev) {
                    argv[0] = (unsigned int) ble_dev;
                    argv[1] = 0;
                    argt[0] = 1;
                    argt[1] = 1;
                    if (!app_manager_call_java(method_callOnBLEConnected, 2, argv, argt)) {
                        app_manager_printf("app_manager_call_java method_callOnBLEConnected fail error\n");
                        goto fail;
                    }
                }
            }
            break;

            case BLE_SUB_EVENT_DISCONNECTED:
            {
                app_manager_printf("app instance received disconnected\n");

                if (ble_dev) {
                    argv[0] = (unsigned int) ble_dev;
                    argv[1] = 0;
                    argt[0] = 1;
                    argt[1] = 1;
                    ble_dev->rssi = dev_info->rssi;
                    if (!app_manager_call_java(method_callOnBLEDisconnected, 2, argv, argt)) {
                        app_manager_printf("app_manager_call_java method_callOnBLEDisconnected fail error\n");
                        goto fail;
                    }
                }
            }
            break;

            case BLE_SUB_EVENT_NOTIFICATION:
            {
                if (ble_dev) {
                    argv[0] = (unsigned int) ble_dev;
                    argv[1] = (unsigned int) (jbyteArray) jeff_runtime_create_byte_array(
                    (int8 *)dev_info->private_data, dev_info->private_data_length);
                    argv[2] = dev_info->value_handle;
                    argv[3] = dev_info->ccc_handle;
                    argt[1] = 1;
                    argt[2] = 0;
                    argt[3] = 0;
                    ble_dev->rssi = dev_info->rssi;
                    if (!app_manager_call_java(method_callOnBLENotification, 4, argv, argt)) {
                        app_manager_printf("app_manager_call_java method_callOnBLENotification fail error\n");
                        goto fail;
                    }
                }
            }
            break;

            case BLE_SUB_EVENT_INDICATION:
            {
                if (ble_dev) {
                    argv[0] = (unsigned int) ble_dev;
                    argv[1] = (unsigned int) (jbyteArray) jeff_runtime_create_byte_array(
                    (int8 *)dev_info->private_data, dev_info->private_data_length);
                    argv[2] = dev_info->value_handle;
                    argv[3] = dev_info->ccc_handle;
                    argt[0] = 1;
                    argt[1] = 1;
                    argt[2] = 0;
                    argt[3] = 0;
                    ble_dev->rssi = dev_info->rssi;
                    if (!app_manager_call_java(method_callOnBLEIndication, 4, argv, argt)) {
                        app_manager_printf("app_manager_call_java method_callOnBLEIndication fail error\n");
                        goto fail;
                    }
                }
            }
            break;

            case BLE_SUB_EVENT_PASSKEYENTRY:
            {

                if (ble_dev) {
                    argv[0] = (unsigned int) ble_dev;
                    argt[0] = 1;
                    argt[1] = 1;
                    ble_dev->rssi = dev_info->rssi;
                    if (!app_manager_call_java(method_callOnBLEPasskeyEntry, 1, argv, argt)) {
                        app_manager_printf("app_manager_call_java method_callOnBLEPasskeyEntry fail error\n");
                        goto fail;
                    }
                }
            }
            break;

            case BLE_SUB_EVENT_SECURITY_LEVEL_CHANGE:
            {
                if (ble_dev) {
                    ble_dev->securityLevel = dev_info->security_level;
                }
            }
            break;

            default:
            break;
        }

        fail:
        if (dev_info->scan_response != NULL) {
            APP_MGR_FREE(dev_info->scan_response);
        }
        if (dev_info->private_data != NULL) {
            APP_MGR_FREE(dev_info->private_data);
        }

        if (dev_info->adv_data != NULL) {
            APP_MGR_FREE(dev_info->adv_data);
        }
        if (dev_info != NULL) {
            APP_MGR_FREE(dev_info);
        }

    }

    static void
    app_instance_free_ble_msg(char *msg)
    {
        bh_queue_ble_sub_msg_t *ble_msg = (bh_queue_ble_sub_msg_t *)msg;
        ble_device_info *dev_info;

        dev_info = (ble_device_info *) ble_msg->payload;

        if (dev_info->scan_response != NULL)
        APP_MGR_FREE(dev_info->scan_response);

        if (dev_info->private_data != NULL)
        APP_MGR_FREE(dev_info->private_data);

        if (dev_info->adv_data != NULL)
        APP_MGR_FREE(dev_info->adv_data);

        if (dev_info != NULL)
        APP_MGR_FREE(dev_info);
    }

    static void
    app_instance_queue_free_callback(void *queue_msg)
    {
        bh_queue_msg_t *msg = (bh_queue_msg_t *)queue_msg;

        switch (msg->message_type) {
            case APPLET_REQUEST:
            {
                bh_request_msg_t *req_msg = (bh_request_msg_t *)msg->payload;
                APP_MGR_FREE(req_msg);
                break;
            }

            case TIMER_EVENT:
            {
                break;
            }

            case SENSOR_EVENT:
            {
                if (msg->payload) {
                    bh_sensor_event_t *sensor_event = (bh_sensor_event_t *)msg->payload;
                    attr_container_t *event = sensor_event->event;

                    attr_container_destroy(event);
                    APP_MGR_FREE(sensor_event);
                }
                break;
            }

            case BLE_EVENT:
            {
                if (msg->payload) {
                    app_instance_free_ble_msg(msg->payload);
                    APP_MGR_FREE(msg->payload);
                }
                break;
            }

            case GPIO_INTERRUPT_EVENT:
            {
                break;
            }

            default:
            {
                break;
            }
        }

        APP_MGR_FREE(msg);
    }

    static void
    app_instance_queue_callback(void *queue_msg)
    {
        bh_queue_msg_t *msg = (bh_queue_msg_t *)queue_msg;
        unsigned int argv[5];
        uint8 argt[5];

        if (app_manager_is_interrupting_module(Module_Jeff)) {
            app_instance_queue_free_callback(queue_msg);
            return;
        }

        switch (msg->message_type) {
            case APPLET_REQUEST:
            {
                JeffLocalObjectRef ref;
                AEERequest req_obj;
                bh_request_msg_t *req_msg = (bh_request_msg_t *)msg->payload;
                attr_container_t *attr_cont = (attr_container_t *)req_msg->payload;
                module_data *m_data = app_manager_get_module_data(Module_Jeff);
                jeff_applet_data *applet_data = (jeff_applet_data*)m_data->internal_data;

                app_manager_printf("Applet %s got request, url %s, action %d\n",
                m_data->module_name, req_msg->url, req_msg->action);

                /* Create Request object */
                req_obj = (AEERequest)jeff_object_new(m_data->heap, class_AEERequest);
                if (!req_obj) {
                    app_manager_printf("Applet process request failed: create request obj failed.\n");
                    goto fail1;
                }

                jeff_runtime_push_local_object_ref(&ref);
                ref.val = (JeffObjectRef)req_obj;

                req_obj->mid = req_msg->mid;
                req_obj->action = req_msg->action;
                req_obj->fmt = req_msg->fmt;

                /* Create Java url string */
                if (req_msg->url) {
                    req_obj->url = (jstring)jeff_runtime_create_java_string(req_msg->url);
                    if (!req_obj->url) {
                        app_manager_printf("Applet process request failed: create url string failed.\n");
                        goto fail2;
                    }
                }

                /* Create Java AttributeObject payload */
                if (attr_cont
                && !attr_container_to_attr_obj(attr_cont, &req_obj->payload)) {
                    app_manager_printf("Applet process request failed: convert payload failed.\n");
                    goto fail2;
                }

                /* Call AEEApplet.callOnRequest(Request request) method  */
                argv[0] = (unsigned int)applet_data->applet_obj;
                argv[1] = (unsigned int)req_obj;
                argt[0] = argt[1] = 1;
                app_manager_call_java(method_AEEApplet_callOnRequest, 2, argv, argt);
                app_manager_printf("Applet process request success.\n");

                fail2:
                jeff_runtime_pop_local_object_ref(1);
                fail1:
                APP_MGR_FREE(req_msg);
                break;
            }

            case TIMER_EVENT:
            {
                if (msg->payload) {
                    /* Call Timer.callOnTimer() method */
                    argv[0] = (unsigned int)msg->payload;
                    argt[0] = 1;
                    app_manager_call_java(method_callOnTimer, 1, argv, argt);
                }
                break;
            }

            case SENSOR_EVENT:
            {
                if (msg->payload) {
                    bh_sensor_event_t *sensor_event = (bh_sensor_event_t *)msg->payload;
                    AEESensor sensor = sensor_event->sensor;
                    attr_container_t *event = sensor_event->event;
                    bool ret = attr_container_to_attr_obj(event, &sensor->event);

                    attr_container_destroy(event);
                    APP_MGR_FREE(sensor_event);

                    if (ret) {
                        /* Call Sensor.callOnSensorEvent() method */
                        argv[0] = (unsigned int)sensor;
                        argt[0] = 1;
                        app_manager_call_java(method_callOnSensorEvent, 1, argv, argt);
                    }
                }
                break;
            }

            case BLE_EVENT:
            {
                if (msg->payload) {
                    app_instance_process_ble_msg(msg->payload);
                    APP_MGR_FREE(msg->payload);
                }
                break;
            }

            case GPIO_INTERRUPT_EVENT:
            {
                AEEGPIOChannel gpio_ch = (AEEGPIOChannel)msg->payload;

                if ((gpio_ch == NULL) || (gpio_ch->callback == 0) || (gpio_ch->listener == NULL)) {
                    break;
                }
                argv[0] = (unsigned int) gpio_ch;
                argt[0] = 1;
                bool ret_value = app_manager_call_java(method_callOnGPIOInterrupt, 1, argv, argt);

                if (!ret_value) {
                    app_manager_printf("app_manager_call_java method_method_callOnGPIOInterrupt return false\n");
                }
                break;
            }

            default:
            {
                app_manager_printf("Invalid message type of applet queue message.\n");
                break;
            }
        }

        APP_MGR_FREE(msg);
    }

    static JeffClassHeaderLinked*
    find_main_class(JeffFileHeaderLinked *main_file)
    {
        JeffClassHeaderLinked *c = NULL, *ci;
        unsigned int i;

        for (i = 0; i < main_file->internal_class_count; i++) {
            ci = main_file->class_header[i];

            if (jeff_is_super_class(class_AEEApplet, ci)
            && (ci->access_flag & JEFF_ACC_PUBLIC)) {
                if (c) {
                    jeff_printe_more_than_one_main_class();
                    return NULL;
                }

                c = ci;
            }
        }

        if (!c)
        jeff_printe_no_main_class();

        return c;
    }

    /* Java applet thread main routine */
    static void*
    app_instance_main(void *arg)
    {
        module_data *m_data = (module_data *)arg;
        jeff_applet_data *applet_data = (jeff_applet_data*)m_data->internal_data;
        JeffClassHeaderLinked *object_class;
        JeffMethodLinked *m;
        unsigned int argv[1];
        uint8 argt[1];

        app_manager_printf("Java Applet '%s' started\n", m_data->module_name);

#if BEIHAI_ENABLE_TOOL_AGENT != 0
        if (applet_data->debug_mode)
        jeff_tool_suspend_self();
#endif

        applet_data->vm_instance->applet_object = applet_data->applet_obj;
        object_class = jeff_object_class_pointer(applet_data->applet_obj);
        m = jeff_select_method_virtual(object_class, method_AEEApplet_onInit);
        bh_assert(m != NULL);
        /* Initialize applet class which call <clinit> */
        if (!app_manager_initialize_class(object_class)) {
            app_manager_printf("Call <clinit> fail\n");
            goto fail;
        }

        /* Initialize applet object which call <init> */
        if (!app_manager_initialize_object(applet_data->applet_obj)) {
            app_manager_printf("Call <init> fail\n");
            goto fail;
        }

        /* Call applet's onInit() method */
        argv[0] = (unsigned int)applet_data->applet_obj;
        argt[0] = 1;
        if (app_manager_call_java(m, 1, argv, argt))
        /* Enter queue loop run to receive and process applet queue message */
        bh_queue_enter_loop_run(m_data->queue, app_instance_queue_callback);

        fail:
        applet_data->vm_instance->applet_object = applet_data->applet_obj;
        object_class = jeff_object_class_pointer(applet_data->applet_obj);
        m = jeff_select_method_virtual(object_class, method_AEEApplet_onDestroy);
        bh_assert(m != NULL);
        /* Call User Applet or AEEApplet onDestroy() method */
        app_manager_call_java(m, 1, argv, argt);
        if (m != method_AEEApplet_onDestroy) {
            /*If 'm' is user onDestroy, then Call AEEApplet.onDestroy() method*/
            app_manager_call_java(method_AEEApplet_onDestroy, 1, argv, argt);
        }
        app_manager_printf("Applet instance main thread exit.\n");
        return NULL;
    }

    static bool
    verify_signature(JeffFileHeader *file, unsigned size)
    {
        uint8 *sig;
        unsigned sig_size;

#if BEIHAI_ENABLE_NO_SIGNATURE != 0
        /* no signature */
        if (file->file_signature == 0)
        return true;
#endif

        if (file->file_length != size
#if BEIHAI_ENABLE_NO_SIGNATURE == 0
        || file->file_signature == 0
#endif
        || file->file_signature >= file->file_length)
        return false;

        sig = (uint8 *)file + file->file_signature;
        sig_size = file->file_length - file->file_signature;

        if (0 == app_manager_signature_verify((uint8_t *)file, file->file_signature,
                sig, sig_size))
        return false;

        return true;
    }

    /* Install Java Applet */
    static bool
    jeff_module_install(bh_request_msg_t *msg)
    {
        unsigned int size, bpk_file_len, main_file_len, heap_size, timeout;
        uint8 *bpk_file;
        JeffFileHeaderLinked *main_file;
        JeffClassHeaderLinked *main_class;
        module_data *m_data;
        jeff_applet_data *applet_data;
        char *applet_name, *applet_perm;
        attr_container_t *attr_cont;
        bool debug = false;

        /* Check url */
        if (!msg->url
        || strcmp(msg->url, "/applet") != 0) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: invalid url.");
            return false;
        }

        /* Check payload */
        attr_cont = (attr_container_t *)msg->payload;
        if (!attr_cont
        || !(bpk_file = (uint8 *)
                attr_container_get_as_bytearray(attr_cont, "bpk", &bpk_file_len))) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: invalid bpk file.");
            return false;
        }

        /* Check applet name */
        applet_name = attr_container_get_as_string(attr_cont, "name");

        if (!applet_name || strlen(applet_name) == 0) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: invalid applet name.");
            return false;
        }

        if (app_manager_lookup_module_data(applet_name)) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: applet already installed.");
            return false;
        }

        /* TODO: convert bpk file to Jeff file */
        main_file_len = bpk_file_len;
        main_file = APP_MGR_MALLOC(main_file_len);
        if (!main_file) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed.");
            return false;
        }
        bh_memcpy_s(main_file, main_file_len, bpk_file, main_file_len);

        /* Verify signature */
        if (!verify_signature((JeffFileHeader *)main_file, main_file_len)) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: verify Jeff file signature failed.");
            goto fail1;
        }

        /* Load Jeff main file */
        if (!jeff_runtime_load(main_file, main_file_len, false, NULL, NULL)) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: load Jeff file failed.");
            goto fail1;
        }

        /* Find main class */
        main_class = find_main_class(main_file);
        if (!main_class) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: find applet class failed.");
            goto fail2;
        }

        /* Create module data */
        size = offsetof(module_data, module_name) + strlen(applet_name) + 1;
        size = align_uint(size, 4);
        m_data = APP_MGR_MALLOC(size + sizeof(jeff_applet_data));
        if (!m_data) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed.");
            goto fail2;
        }

        memset(m_data, 0, size + sizeof(jeff_applet_data));
        m_data->module_type = Module_Jeff;
        m_data->internal_data = (uint8*)m_data + size;
        applet_data = (jeff_applet_data*)m_data->internal_data;
        bh_strcpy_s(m_data->module_name, strlen(applet_name) + 1, applet_name);
        applet_data->main_file = main_file;

        /* Set applet execution timeout */
        timeout = DEFAULT_APPLET_TIMEOUT;
        if (attr_container_contain_key(attr_cont, "execution timeout"))
        timeout = attr_container_get_as_int(attr_cont, "execution timeout");
        m_data->timeout = timeout;

        /* Create applet permissions */
        applet_perm = attr_container_get_as_string(attr_cont, "perm");
        if (applet_perm != NULL) {
            applet_data->perms = APP_MGR_MALLOC(strlen(applet_perm) + 1);
            if (!applet_data->perms) {
                SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory for applet permissions failed.");
                goto fail3;
            }

            bh_strcpy_s(applet_data->perms, strlen(applet_perm) + 1, applet_perm);
        }

        /* Create applet queue */
        m_data->queue = bh_queue_create();
        if (!m_data->queue) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create applet queue failed.");
            goto fail3_1;
        }

        /* Set heap size */
        heap_size = DEFAULT_APPLET_HEAP_SIZE;
        if (attr_container_contain_key(attr_cont, "heap size")) {
            heap_size = attr_container_get_as_int(attr_cont, "heap size");
            if (heap_size < MIN_APPLET_HEAP_SIZE)
            heap_size = MIN_APPLET_HEAP_SIZE;
            else if (heap_size > MAX_APPLET_HEAP_SIZE)
            heap_size = MAX_APPLET_HEAP_SIZE;
        }

        m_data->heap_size = heap_size;

        /* Create applet heap */
        m_data->heap = gc_init_for_instance(heap_size);
        if (!m_data->heap) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create heap failed.");
            goto fail4;
        }

        /* Create applet object */
        applet_data->applet_obj = jeff_object_new(m_data->heap, main_class);
        if (!applet_data->applet_obj) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create applet object failed.");
            goto fail5;
        }

        /* Initialize watchdog timer */
        if (!watchdog_timer_init(m_data)) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create applet watchdog timer failed.");
            goto fail5;
        }

#if BEIHAI_ENABLE_TOOL_AGENT != 0
        /* Check whether applet is debuggable */
        if (attr_container_contain_key(attr_cont, "debug"))
        debug = attr_container_get_as_bool(attr_cont, "debug");

        applet_data->debug_mode = debug;

        /* Create tool agent queue */
        if (debug && !(applet_data->tool_agent_queue = bh_queue_create())) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create tool agent queue failed.");
            goto fail5_1;
        }
#endif

        /* Create applet instance */
        applet_data->vm_instance =
        jeff_runtime_create_instance(main_file, m_data->heap, 16,
        app_instance_main, m_data,
        NULL);
        if (!applet_data->vm_instance) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: create Java VM failed");
            goto fail6;
        }

        /* Add applet data to applet data list */
        applet_data->vm_instance->applet_object = applet_data->applet_obj;
        app_manager_add_module_data(m_data);
        app_manager_post_applets_update_event();

#if BEIHAI_ENABLE_TOOL_AGENT != 0
        /* Start tool agent thread */
        if (debug && !jeff_tool_start_agent(applet_data->vm_instance, applet_data->tool_agent_queue)) {
            SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: start tool agent failed");
            goto fail6;
        }
#endif

        app_manager_printf("Install Applet success!\n");
        app_send_response_to_host(msg->mid, CREATED_2_01, NULL); /* CREATED */
        return true;

        fail6:
#if BEIHAI_ENABLE_TOOL_AGENT != 0
        if (debug)
        bh_queue_destroy(applet_data->tool_agent_queue);
#endif

        fail5_1:
        watchdog_timer_destroy(&m_data->wd_timer);

        fail5:
        gc_destroy_for_instance(m_data->heap);

        fail4:
        bh_queue_destroy(m_data->queue, NULL);

        fail3_1:
        APP_MGR_FREE(applet_data->perms);

        fail3:
        APP_MGR_FREE(applet_data);

        fail2:
        jeff_runtime_unload(main_file);

        fail1:
        APP_MGR_FREE(main_file);

        return false;
    }

    static void
    cleanup_applet_resource(module_data *m_data)
    {
        jeff_applet_data *applet_data = (jeff_applet_data*)m_data->internal_data;

        /* Unload Jeff main file and free it */
        jeff_runtime_unload(applet_data->main_file);
        APP_MGR_FREE(applet_data->main_file);

        /* Destroy queue */
        bh_queue_destroy(m_data->queue, app_instance_queue_free_callback);

        /* Destroy heap */
        gc_destroy_for_instance(m_data->heap);

        /* Destroy watchdog timer */
        watchdog_timer_destroy(&m_data->wd_timer);

        /* Remove module data from module data list and free it */
        app_manager_del_module_data(m_data);
        APP_MGR_FREE(applet_data->perms);
        APP_MGR_FREE(m_data);
    }

    /* Uninstall Java Applet */
    static bool
    jeff_module_uninstall(bh_request_msg_t *msg)
    {
        module_data *m_data;
        jeff_applet_data *applet_data;
        attr_container_t *attr_cont;
        char *applet_name;
        bool do_not_reply = false;

        /* Check payload and applet name*/
        attr_cont = (attr_container_t *)msg->payload;

        /* Check whether need to reply this request */
        if (attr_container_contain_key(attr_cont, "do not reply me"))
        do_not_reply = attr_container_get_as_bool(attr_cont, "do not reply me");

        /* Check url */
        if (!msg->url
        || strcmp(msg->url, "/applet") != 0) {
            if (!do_not_reply)
            SEND_ERR_RESPONSE(msg->mid, "Uninstall Applet failed: invalid url.");
            else
            app_manager_printf("Uninstall Applet failed: invalid url.");
            return false;
        }

        if (!attr_cont
        || !(applet_name = attr_container_get_as_string(attr_cont, "name"))
        || strlen(applet_name) == 0) {
            if (!do_not_reply)
            SEND_ERR_RESPONSE(msg->mid, "Uninstall Applet failed: invalid applet name.");
            else
            app_manager_printf("Uninstall Applet failed: invalid applet name.");
            return false;
        }

        m_data = app_manager_lookup_module_data(applet_name);
        if (!m_data) {
            if (!do_not_reply)
            SEND_ERR_RESPONSE(msg->mid, "Uninstall Applet failed: no applet found.");
            else
            app_manager_printf("Uninstall Applet failed: no applet found.");
            return false;
        }

        if (m_data->module_type != Module_Jeff) {
            if (!do_not_reply)
            SEND_ERR_RESPONSE(msg->mid, "Uninstall Applet failed: invlaid module type.");
            else
            app_manager_printf("Uninstall Applet failed: invalid module type.");
            return false;
        }

        if (m_data->wd_timer.is_interrupting) {
            if (!do_not_reply)
            SEND_ERR_RESPONSE(msg->mid, "Uninstall Applet failed: applet is being interrupted by watchdog.");
            else
            app_manager_printf("Uninstall Applet failed: applet is being interrupted by watchdog.");
            return false;
        }

        /* Exit applet queue loop run */
        bh_queue_exit_loop_run(m_data->queue);

        applet_data = (jeff_applet_data*)m_data->internal_data;
#if BEIHAI_ENABLE_TOOL_AGENT != 0
        /* Exit tool agent queue loop run */
        if (is_tool_agent_running(m_data)) {
            bh_queue_exit_loop_run(applet_data->tool_agent_queue);
        }
#endif

        /* Wait the end of the applet instance and then destroy it */
        if (applet_data->vm_instance->main_file)
        jeff_runtime_wait_for_instance(applet_data->vm_instance, -1);
        jeff_runtime_destroy_instance(applet_data->vm_instance);

        cleanup_applet_resource(m_data);
        app_manager_post_applets_update_event();

        app_manager_printf("Uninstall Applet success!\n");

        if (!do_not_reply)
        app_send_response_to_host(msg->mid, DELETED_2_02, NULL); /* DELETED */
        return true;
    }

#define PERM_PREFIX "AEE.permission."

    static bool
    check_permission_format(const char *perm)
    {
        const char *prefix = PERM_PREFIX;
        const char *p;

        if (perm == NULL || strncmp(perm, prefix, strlen(prefix)) != 0
        || *(p = perm + strlen(prefix)) == '\0')
        return false;

        do {
            if (!(*p == '.' || ('A' <= *p && *p <= 'Z') || ('a' <= *p && *p <= 'z')))
            return false;
        }while (*++p != '\0');

        return true;
    }

    static bool
    match(const char *haystack, const char *needle, char delim)
    {
        const char *p = needle;

        if (haystack == NULL || *haystack == '\0'
        || needle == NULL || *needle == '\0')
        return false;

        while (true) {
            while (true) {
                if ((*haystack == '\0' || *haystack == delim) && *p == '\0') {
                    return true;
                } else if (*p == *haystack) {
                    ++p;
                    ++haystack;
                } else {
                    break;
                }
            }
            while (*haystack != '\0' && *haystack != delim) {
                ++haystack;
            }
            if (*haystack == '\0') {
                return false;
            } else {
                ++haystack;
                p = needle;
            }
        }
    }

    bool
    bh_applet_check_permission(const char *perm)
    {
        return check_permission_format(perm)
        && match(app_manager_get_jeff_applet_data()->perms,
        perm + strlen(PERM_PREFIX), ' ');
    }

    static bool
    jeff_module_init()
    {
        JeffDescriptorFull d[] = { {JEFF_TYPE_VOID, 0, NULL}};
        JeffDescriptorFull d1[] = {
            {   JEFF_TYPE_OBJECT | JEFF_TYPE_REF, 0, NULL},
            {   JEFF_TYPE_VOID, 0, NULL}
        };

        /* Resolve class com.intel.aee.AEEApplet */
        class_AEEApplet = jeff_runtime_resolve_class_full_name("com.intel.aee.AEEApplet");
        if (!class_AEEApplet) {
            app_manager_printf("App Manager start failed: resolve class AEEApplet failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.Request */
        class_AEERequest = jeff_runtime_resolve_class_full_name("com.intel.aee.Request");
        if (!class_AEERequest) {
            app_manager_printf("App Manager start failed: resolve class Request failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.Timer */
        class_Timer = jeff_runtime_resolve_class_full_name("com.intel.aee.Timer");
        if (!class_Timer) {
            app_manager_printf("App Manager start failed: resolve class Timer failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.Sensor */
        class_Sensor = jeff_runtime_resolve_class_full_name("com.intel.aee.Sensor");
        if (!class_Sensor) {
            app_manager_printf("App Manager start failed: resolve class Sensor failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.ble.BLEManager */
        class_BLEManager = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.ble.BLEManager");
        if (!class_BLEManager) {
            app_manager_printf(
            "App Manager start failed: resolve class BLEManager failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.ble.BLEDevice */
        class_BLEDevice = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.ble.BLEDevice");
        if (!class_BLEDevice) {
            app_manager_printf(
            "App Manager start failed: resolve class BLEDevice failed.\n");
            return false;
        }
        /* Resolve class com.intel.aee.ble.BLEDevice */
        class_BLEGattService = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.ble.BLEGattService");
        if (!class_BLEGattService) {
            app_manager_printf(
            "App Manager start failed: resolve class BLEGattService failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.ble.BLEDevice */
        class_BLEGattCharacteristic = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.ble.BLEGattCharacteristic");
        if (!class_BLEGattCharacteristic) {
            app_manager_printf(
            "App Manager start failed: resolve class BLEGattCharacteristic failed.\n");
            return false;
        }

        /* Resolve class com.intel.aee.ble.BLEDevice */
        class_BLEGattDescriptor = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.ble.BLEGattDescriptor");
        if (!class_BLEGattDescriptor) {
            app_manager_printf(
            "App Manager start failed: resolve class BLEGattDescriptor failed.\n");
            return false;
        }
        /* Resolve class com.intel.aee.gpio.GPIOChannel */
        class_GPIOChannel = jeff_runtime_resolve_class_full_name(
        "com.intel.aee.gpio.GPIOChannel");
        if (!class_GPIOChannel) {
            app_manager_printf(
            "App Manager start failed: resolve class GPIOChannel failed.\n");
            return false;
        }

        /* Resolve method com.intel.aee.AEEApplet.onInit() */
        method_AEEApplet_onInit = jeff_lookup_method(class_AEEApplet, "onInit", 0, d);
        if (!method_AEEApplet_onInit) {
            app_manager_printf("App Manager start failed: resolve method Applet.onInit() failed.\n");
            return false;
        }

        /* Resolve method com.intel.aee.AEEApplet.onDestroy() */
        method_AEEApplet_onDestroy = jeff_lookup_method(class_AEEApplet, "onDestroy", 0, d);
        if (!method_AEEApplet_onDestroy) {
            app_manager_printf("App Manager start failed: resolve method AEEApplet.onDestroy() failed.\n");
            return false;
        }

        /* Resolve method com.intel.aee.AEEApplet.callOnRequest(Request) */
        d1[0].class_header = class_AEERequest;
        method_AEEApplet_callOnRequest = jeff_lookup_method(class_AEEApplet, "callOnRequest", 1, d1);
        if (!method_AEEApplet_callOnRequest) {
            app_manager_printf("App Manager start failed: resolve method AEEApplet.callOnRequest() failed.\n");
            return false;
        }

        /* Resolve method com.intel.aee.Timer.callOnTimer() */
        method_callOnTimer = jeff_lookup_method(class_Timer, "callOnTimer", 0, d);
        if (!method_callOnTimer) {
            app_manager_printf("App Manager start failed: resolve method Timer.callOnTimer() failed.\n");
            return false;
        }

        /* Resolve method com.intel.aee.Sensor.callOnSensorEvent() */
        method_callOnSensorEvent = jeff_lookup_method(class_Sensor, "callOnSensorEvent", 0, d);
        if (!method_callOnSensorEvent) {
            app_manager_printf("App Manager start failed: resolve method Sensor.callOnSensorEvent() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.callOnBLEStartDiscovery(BLEDevice) */
        d1[0].class_header = class_BLEDevice;
        method_callOnBLEStartDiscovery = jeff_lookup_method(class_BLEManager, "callOnBLEStartDiscovery", 1, d1);
        if (!method_callOnBLEStartDiscovery) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLEStartDiscovery() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.callOnBLEConnected(BLEDevice) */
        JeffDescriptorFull d2_1[] = { {JEFF_TYPE_OBJECT | JEFF_TYPE_REF, 0, class_BLEDevice},
            {   JEFF_TYPE_INT, 0, NULL},
            {   JEFF_TYPE_VOID, 0, NULL}};
        method_callOnBLEConnected = jeff_lookup_method(class_BLEManager, "callOnBLEConnected", 2, d2_1);
        if (!method_callOnBLEConnected) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLEConnected() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.method_callOnBLENotification(BLEDevice,byte[]) */
        JeffDescriptorFull d2_2[] = { {JEFF_TYPE_OBJECT | JEFF_TYPE_REF, 0, class_BLEDevice},
            {   JEFF_TYPE_BYTE | JEFF_TYPE_REF | JEFF_TYPE_MONO, 1, NULL},
            {   JEFF_TYPE_INT, 0, NULL},
            {   JEFF_TYPE_INT, 0, NULL},
            {   JEFF_TYPE_VOID, 0, NULL}};
        method_callOnBLENotification = jeff_lookup_method(class_BLEManager, "callOnBLENotification", 4, d2_2);
        if (!method_callOnBLENotification) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLENotification() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.callOnBLEConnected(BLEDevice,byte[]) */
        method_callOnBLEIndication = jeff_lookup_method(class_BLEManager, "callOnBLEIndication", 4, d2_2);
        if (!method_callOnBLEIndication) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLEIndication() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.callOnBLEConnected(BLEDevice) */
        d1[0].class_header = class_BLEDevice;
        method_callOnBLEDisconnected = jeff_lookup_method(class_BLEManager, "callOnBLEDisconnected", 1, d1);
        if (!method_callOnBLEDisconnected) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLEDisconnected() failed.\n");
            return false;
        }

        /* Resovle method com.intel.aee.ble.BLEManager.callOnBLEConnected(BLEDevice) */
        method_callOnBLEPasskeyEntry = jeff_lookup_method(class_BLEManager, "callOnBLEPasskeyEntry", 1, d1);
        if (!method_callOnBLEPasskeyEntry) {
            app_manager_printf("App Manager start failed: resolve method BLEManager.callOnBLEPasskeyEntry() failed.\n");
            return false;
        }
        /* Resovle  method void com.intel.aee.gpio.GPIOChannel.callOnGPIOInterrupt()  */
        method_callOnGPIOInterrupt = jeff_lookup_method(class_GPIOChannel, "callOnGPIOInterrupt", 0, d);
        if (!method_callOnGPIOInterrupt) {
            app_manager_printf("App Manager start failed: resolve method GPIOChannel.callOnGPIOInterrupt() failed.\n");
            return false;
        }

        JeffDescriptorFull d2[] = { {JEFF_TYPE_BYTE | JEFF_TYPE_REF | JEFF_TYPE_MONO, 1, NULL},
            {   JEFF_TYPE_OBJECT | JEFF_TYPE_REF, 0, class_BLEDevice}};
        /* Resovle method com.intel.aee.ble.BLEManager.getBLEDevice(byte []) */
        method_callOnBLEManagerGetBLEDevice = jeff_lookup_method(class_BLEManager,
        "getBLEDevice", 1, d2);
        if (!method_callOnBLEManagerGetBLEDevice) {
            app_manager_printf(
            "App Manager start failed: resolve method BLEManager.getBLEDevice() failed.\n");
            return false;
        }

        return true;
    }

    static void
    jeff_module_watchdog_kill(module_data *m_data)
    {
        jeff_applet_data *applet_data = (jeff_applet_data*)m_data->internal_data;

        app_manager_printf("Watchdog interrupt the applet %s\n", m_data->module_name);

        jeff_runtime_interrupt_instance(applet_data->vm_instance, true);

        /* Exit applet queue loop run */
        bh_queue_exit_loop_run(m_data->queue);

        /* Wait the end of the applet instance. If timeout, it means applet
         * is busy executing native code, then try to cancle the main thread. */
        if (applet_data->vm_instance->main_file)
        jeff_runtime_wait_for_instance(applet_data->vm_instance, 3000);

        if (applet_data->vm_instance->main_file) {
            app_manager_printf("Watchdog cancel applet main thread.\n");
            os_thread_cancel(applet_data->vm_instance->main_tlr.handle);
            /* k_thread_abort(applet_data->vm_instance->main_tlr.handle); */
        }

        send_exception_event_to_host(m_data->module_name, "java.lang.InterruptedException");
        cleanup_applet_resource(m_data);
        app_manager_printf("Watchdog interrupt Jeff applet done.\n");
    }

    static bool
    jeff_module_handle_host_url(void *queue_msg)
    {
#if BEIHAI_ENABLE_TOOL_AGENT != 0
        bh_queue_msg_t *msg = (bh_queue_msg_t *)queue_msg;

        if (msg->message_type == COAP_PARSED) {
            coap_packet_t *packet = (coap_packet_t *)msg->payload;
            attr_container_t *attr_cont = (attr_container_t *)packet->payload;
            const char *url = NULL;
            int url_len = 0, mid;

            bh_memcpy_s(&mid, sizeof(uint32), packet->token, sizeof(uint32));
            url_len = coap_get_header_uri_path(packet, &url);

            /* Send request to tool agent */
            if (url_len >= 12 && memcmp(url, "/tool_agent/", 12) == 0) {
                module_data *m_data;
                jeff_applet_data *applet_data;
                unsigned attr_cont_len = 0, req_msg_len;
                bh_queue_msg_t *tool_agent_msg;
                bh_request_msg_t *req_msg;
                char url_buf[256] = {0}, *p = url_buf;
                char applet_name[128] = {0};

                /* Resolve applet name */
                bh_memcpy_s(url_buf, sizeof(url_buf), url + 12, url_len - 12);
                while (*p != '/' && *p != '\0')
                p++;

                bh_memcpy_s(applet_name, sizeof(applet_name), url_buf, p - url_buf);
                app_manager_printf("Send request to tool agent of applet: %s\n", applet_name);

                /* Check applet name */
                if (!(m_data = app_manager_lookup_module_data(applet_name))) {
                    SEND_ERR_RESPONSE(mid, "Send request to tool agent failed: invalid applet name");
                    return false;
                }

                applet_data = (jeff_applet_data*)m_data->internal_data;
                /* Attach debug: start the tool agent firstly */
                if (packet->code == COAP_PUT) {
                    if (is_tool_agent_running(m_data)) {
                        SEND_ERR_RESPONSE(mid, "Attach debug failed: tool agent is already exist.");
                        return false;
                    }

                    applet_data->debug_mode = true;

                    /* Create tool agent queue */
                    if (!(applet_data->tool_agent_queue = bh_queue_create())) {
                        SEND_ERR_RESPONSE(mid, "Attach debug failed: create tool agent queue failed.");
                        return false;
                    }

                    /* Start tool agent thread */
                    if (!jeff_tool_start_agent(applet_data->vm_instance, applet_data->tool_agent_queue)) {
                        bh_queue_destroy(applet_data->tool_agent_queue, NULL);
                        SEND_ERR_RESPONSE(mid, "Attach debug failed: start tool agent failed");
                        return false;
                    }

                    app_manager_printf("Attach debug: start tool agent of applet %s success.\n", applet_name);
                    app_send_response_to_host(mid, CREATED_2_01, NULL); /* OK */
                } else {
                    /* Check tool agent running */
                    if (!is_tool_agent_running(m_data)) {
                        SEND_ERR_RESPONSE(mid, "Send request to tool agent failed: tool agent is not running");
                        return false;
                    }

                    /* Create queue message for tool agent */
                    if (!(tool_agent_msg = APP_MGR_MALLOC(sizeof(bh_queue_msg_t)))) {
                        SEND_ERR_RESPONSE(mid, "Send request to tool agent failed: allocate memory failed");
                        return false;
                    }

                    if (attr_cont)
                    attr_cont_len = attr_container_get_serialize_length(attr_cont);

                    req_msg_len = sizeof(bh_request_msg_t) + strlen(p) + 1 + attr_cont_len;

                    /* Create request message */
                    if (!(req_msg = APP_MGR_MALLOC(req_msg_len))) {
                        SEND_ERR_RESPONSE(mid, "Send request to applet failed: allocate memory failed");
                        APP_MGR_FREE(tool_agent_msg);
                        return false;
                    }

                    /* Set request message */
                    memset(req_msg, 0, req_msg_len);
                    req_msg->mid = mid;
                    req_msg->url = (char*)req_msg + sizeof(bh_request_msg_t);
                    bh_strcpy_s(req_msg->url, strlen(p)+1, p); /* Actual url sent to tool agent */
                    req_msg->action = packet->code;
                    req_msg->fmt = 0;
                    if (attr_cont) {
                        req_msg->payload = (char*)req_msg + sizeof(bh_request_msg_t) +
                        strlen(p) + 1;
                        attr_container_serialize(req_msg->payload, attr_cont);
                    }

                    /* Set queue message and send to tool agent's queue */
                    tool_agent_msg->message_type = JDWP_REQUEST;
                    tool_agent_msg->payload_size = req_msg_len;
                    tool_agent_msg->payload = (char*)req_msg;
                    if (!bh_queue_send_message(applet_data->tool_agent_queue, tool_agent_msg)) {
                        APP_MGR_FREE(req_msg);
                        APP_MGR_FREE(tool_agent_msg);
                        SEND_ERR_RESPONSE
                        (mid, "Send request to tool agent failed: send queue msg failed.");
                        return false;
                    }

                    /* app_manager_printf("Send request to tool agent of applet %s success.\n", applet_name); */
                }

                return true;
            }
        }
#endif /* BEIHAI_ENABLE_TOOL_AGENT != 0 */
        return false;
    }

    static module_data*
    jeff_module_get_module_data(void)
    {
        JeffThreadLocalRoot *self = jeff_runtime_get_tlr();
        return (module_data *)self->il_root->start_routine_arg;
    }

#if BEIHAI_ENABLE_TOOL_AGENT != 0

#define JDWP_HANDSHAKE_MAGIC    "JDWP-Handshake"
#define JDWP_HANDSHAKE_LEN      (sizeof (JDWP_HANDSHAKE_MAGIC) - 1)

#define JDWP_PAYLOAD_KEY        "jdwp"

    static bool debug = true;

    static bool
    send_msg_to_host (int mid, const char *url, int code, const uint8 *msg, unsigned size)
    {
        bool ret;
        int payload_len = 0;
        attr_container_t *payload = NULL;

        if (msg) {
            if ((payload = attr_container_create(""))) {
                attr_container_set_bytearray(&payload, JDWP_PAYLOAD_KEY, (const int8_t *)msg, size);
                payload_len = attr_container_get_serialize_length(payload);
            }
        }
        ret = app_send_msg_to_host(mid, url, code, (char*)payload, payload_len);

        if (payload)
        attr_container_destroy(payload);

        return ret;
    }

    static bool
    send_response(int mid, int code, const uint8 *msg, unsigned size)
    {
        return send_msg_to_host(mid, NULL, code, msg, size);
    }

    static bool
    send_packet_response(int mid, int code, JeffBuffer *packet)
    {
        int size;

        if ((size = jeff_buffer_size(packet)) == 0)
        /* No data need to be written, succeed.  */
        return true;

        return send_msg_to_host(mid, NULL, code, jeff_buffer_at(packet, 0), size);
    }

    void
    jeff_tool_event_publish(uint8 *evtbuf, unsigned size)
    {
        char *prefix = "/jdwp/", *url = NULL;
        int url_len;

        url_len = strlen(prefix) + strlen(app_manager_get_module_name(Module_Jeff));
        if (NULL == (url = jeff_runtime_malloc(url_len + 1)))
        return;

        bh_strcpy_s(url,url_len + 1, prefix);
        bh_strcat_s(url,url_len + 1, app_manager_get_module_name(Module_Jeff));

        /* Event is sent as request so we set code as COAP_PUT */
        if (event_is_registered(url))
        send_msg_to_host(0, url, COAP_PUT, evtbuf, size);

        jeff_runtime_free(url);
    }

#define SEND_ERROR_RESPONSE(err_msg) do {                  \
    app_manager_printf("%s\n", err_msg);                   \
    send_response(req_msg->mid, INTERNAL_SERVER_ERROR_5_00,\
                  (uint8 *)err_msg, strlen(err_msg) + 1);  \
  } while (0)

    /* Queue callback of tool agent */
    void
    tool_agent_queue_callback(void *arg)
    {
        bh_queue_msg_t *msg = (bh_queue_msg_t*)arg;

        if (msg->message_type == JDWP_REQUEST) {
            bh_request_msg_t *req_msg = (bh_request_msg_t*)msg->payload;
            attr_container_t *attr_cont = (attr_container_t*)req_msg->payload;
            JeffThreadLocalRoot *self = jeff_runtime_get_tlr();
            JeffInstanceLocalRoot *cur_instance = self->il_root;
            JeffToolAgent *agent = cur_instance->tool_agent;
            bh_queue *queue = (bh_queue *)self->start_routine_arg;

            if (debug)
            app_manager_printf("Tool Agent of applet %s got request, url %s, action %d\n",
            app_manager_get_module_name(Module_Jeff), req_msg->url, req_msg->action);

            /* Handshake or Process Request */
            if (req_msg->action == COAP_GET) {
                uint8 *buf;
                unsigned buf_len;

                if (!attr_cont
                || !(buf = (uint8*)
                        attr_container_get_as_bytearray(attr_cont, JDWP_PAYLOAD_KEY, &buf_len))) {
                    SEND_ERROR_RESPONSE("Tool Agent fail: invalid JDWP payload.");
                    goto fail;
                }

                if (!agent->connected) {
                    if (buf_len != JDWP_HANDSHAKE_LEN
                    || memcmp (buf, JDWP_HANDSHAKE_MAGIC, JDWP_HANDSHAKE_LEN)) {
                        SEND_ERROR_RESPONSE("Tool Agent fail: handshake fail.");
                        goto fail;
                    }

                    /* Handshake success and response */
                    agent->connected = true;
                    send_response(req_msg->mid, CONTENT_2_05, buf, buf_len);
                } else {
                    /* TODO: tool-agent thread should reuse the request/reply buffer to avoid allocating memory repeatedly */
                    JeffBuffer request, reply;

                    /* Initialize the package buffers. */
                    jeff_buffer_init(&request);
                    jeff_buffer_init(&reply);

                    if (!jeff_buffer_resize(&request, buf_len)) {
                        SEND_ERROR_RESPONSE("Tool Agent fail: resize buffer fail.");
                        jeff_buffer_destroy(&request);
                        jeff_buffer_destroy(&reply);
                        goto fail;
                    }

                    /* Copy data from request to jeff buffer */
                    bh_memcpy_s(jeff_buffer_at(&request, 0), jeff_buffer_size(&request), buf, buf_len);

                    /* Handle JDWP request */
                    if (!jeff_tool_handle_packet(agent, &request, &reply)) {
                        SEND_ERROR_RESPONSE("Tool agent fail: handle request fail.");
                        jeff_buffer_destroy(&request);
                        jeff_buffer_destroy(&reply);
                        goto fail;
                    }

                    /* Response JDWP reply */
                    send_packet_response(req_msg->mid, CONTENT_2_05, &reply);

                    /* Destroy the package buffers. */
                    jeff_buffer_destroy(&request);
                    jeff_buffer_destroy(&reply);
                }
            }
            /* Debugger disconnect */
            else if (req_msg->action == COAP_DELETE) {
                send_response(req_msg->mid, DELETED_2_02, NULL, 0);
                bh_queue_exit_loop_run(queue);
            }
            else {
                SEND_ERROR_RESPONSE("Tool agent fail: invalid request.");
                goto fail;
            }

            APP_MGR_FREE(req_msg);
            APP_MGR_FREE(msg);
            return;

            fail:
            bh_queue_exit_loop_run(queue);
            APP_MGR_FREE(req_msg);
        }

        APP_MGR_FREE(msg);
    }

    void
    tool_agent_queue_free_callback(void *message)
    {
        bh_queue_msg_t *msg = (bh_queue_msg_t*)message;

        if (msg->message_type == JDWP_REQUEST) {
            bh_request_msg_t *req_msg = (bh_request_msg_t*)msg->payload;
            APP_MGR_FREE(req_msg);
        }

        APP_MGR_FREE(msg);
    }

#endif  /* BEIHAI_ENABLE_TOOL_AGENT != 0 */

    module_interface jeff_module_interface = {
        jeff_module_init,
        jeff_module_install,
        jeff_module_uninstall,
        jeff_module_watchdog_kill,
        jeff_module_handle_host_url,
        jeff_module_get_module_data,
        NULL
    };

#endif
