/*
 * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
 *
 * 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.
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <unistd.h>
#include <memory>
#include <algorithm>
#include <unordered_map>
#include <list>
#include <thread>
#include "hs-helper.h"
#include "hs-clientmanager.h"
#include "hs-appinfo.h"
#include "hs-config.h"
#include "hs-apprecover.h"
#include "hs-vuiadapter.h"


const char _error[] = "error";
const char _application_id[] = "application_id";
const char _display_message[] = "display_message";
const char _reply_message[] = "reply_message";
const char _keyData[] = "data";
const char _keyId[] = "id";
const char _parameter[] = "parameter";
const char _area[] = "area";

struct hs_handshake {
    hs_handshake(int times, int sleep) : m_times(times), m_sleep(sleep) {}
    int start(afb_api_t api);
    void handshake_loop(afb_api_t api, int times, int sleeps);

    enum HandshakeStatus {
        Handshake_Idle = 0,
        Handshake_Subscribing,
        Handshake_Subscribe_Fail,
        Handshake_WaitEvent,
        Handshake_Over
    };
    static int hs_sts;

private:
    const std::string sub_event = "windowmanager/handshake";
    const int m_times;
    const int m_sleep;
};

int hs_handshake::hs_sts = hs_handshake::Handshake_Idle;

/**
 * handshake callback function
 *
 * #### Parameters
 * - obj : reply json object
 * - error : api_call error
 * - info : api_call information
 *
 * #### Return
 * None
 *
 */
void handshake_subscribe_callback(struct json_object *obj, const char *error, const char *info)
{
    AFB_NOTICE("subscribe handshake reply: obj=%s, error=%s, info=%s", json_object_to_json_string(obj), error, info);
    if(hs_handshake::hs_sts == hs_handshake::Handshake_Over) {
        return;
    }
    if(error == nullptr) {
        hs_handshake::hs_sts =  hs_handshake::Handshake_WaitEvent;
    }
    else {
        hs_handshake::hs_sts =  hs_handshake::Handshake_Subscribe_Fail;
    }
}

/**
 * handshake event function
 *
 * #### Parameters
 * - api : the api
 * - event : received event name
 * - object : received json object
 *
 * #### Return
 * 0 : event can transfer to others
 * 1 : event not transfer to others
 */
int on_handshake_event(afb_api_t api, const char *event, struct json_object *object)
{
    AFB_NOTICE("received handshake event from windowmanager.");
    hs_handshake::hs_sts =  hs_handshake::Handshake_Over;
    return 1;
}

/**
 * start handshake function
 *
 * #### Parameters
 * - api : the api
 *
 * #### Return
 * 0 : handshake success
 * other : handshake fail
 * 
 */
int hs_handshake::start(afb_api_t api)
{
    AFB_NOTICE("start handshake with windowmanager.");
    setEventHook(sub_event.c_str(), on_handshake_event);

    std::thread th(&hs_handshake::handshake_loop, this, api, m_times, m_sleep);
    th.detach();
    return 0;
}

/**
 * handshake loop
 *
 * #### Parameters
 * - api : the api
 *
 * #### Return
 * None
 *
 */
void hs_handshake::handshake_loop(afb_api_t api, int times, int sleeps)
{
    int count = 0;
    do {
        // try to subscribe handshake event
        if(hs_handshake::hs_sts == hs_handshake::Handshake_Idle
        || hs_handshake::hs_sts == hs_handshake::Handshake_Subscribe_Fail) {
            hs_handshake::hs_sts = Handshake_Subscribing;
            HS_WmProxy wm_proxy;
            wm_proxy.subscribe(api, HS_WmProxy::Event_Handshake, handshake_subscribe_callback);
        }

        // wait handshake event
        if(hs_handshake::hs_sts == hs_handshake::Handshake_Over) {
            break;
        }

        ++count;
        usleep(sleeps*1000);
    } while(count < times);
    AFB_NOTICE("handshake over, m_times=%d, m_sleep=%d, count=%d.", times, sleeps, count);
    HS_AppRecover::instance()->startRecovery(api);
}

struct hs_instance {
    HS_ClientManager *client_manager;   // the connection session manager
    HS_AppInfo *app_info;               // application info
    HS_AppRecover *app_recover;		// application recover
    HS_VuiAdapter * vui_adapter;        // vui function adapter

    hs_instance() : client_manager(HS_ClientManager::instance()), app_info(HS_AppInfo::instance()), app_recover(HS_AppRecover::instance()), vui_adapter(HS_VuiAdapter::instance()) {}
    int init(afb_api_t api);
    void setEventHook(const char *event, const event_hook_func f);
    void onEvent(afb_api_t api, const char *event, struct json_object *object);
private:
    std::unordered_map<std::string, std::list<event_hook_func>> event_hook_list;
};

static struct hs_instance *g_hs_instance;

/**
 * init function
 *
 * #### Parameters
 * - api : the api serving the request
 *
 * #### Return
 * 0 : init success
 * 1 : init fail
 *
 */
int hs_instance::init(afb_api_t api)
{
    if(client_manager == nullptr) {
        AFB_ERROR("client_manager is nullptr.");
        return -1;
    }
    client_manager->init();

    if(app_info == nullptr) {
        AFB_ERROR("app_info is nullptr.");
        return -1;
    }
    app_info->init(api);

    HS_Config hs_config;
    if(hs_config.readConfig() < 0) {
        AFB_ERROR("read config file failed.");
        return -1;
    }

    if(app_recover == nullptr) {
        AFB_ERROR("app_recover is nullptr.");
        return -1;
    }
    app_recover->init(api);
    app_recover->setRecoverMap(hs_config.getRecoverMap());

    const struct handshake_info *h = hs_config.getHandshakeInfo();
    struct hs_handshake handshake(h->times, h->sleep);
    if(handshake.start(api) < 0) {
        AFB_ERROR("handshake with windowmanager failed.");
        return -1;
    }

    if(vui_adapter == nullptr) {
        AFB_ERROR("vui_adapter is nullptr."); 
    }
    vui_adapter->init(api);

    return 0;
}

/**
 * set event hook
 *
 * #### Parameters
 *  - event  : event name
 *  - f : hook function
 *
 * #### Return
 * Nothing
 */
void hs_instance::setEventHook(const char *event, const event_hook_func f)
{
    AFB_INFO("hook event %s", event);
    if(event == nullptr || f == nullptr) {
        AFB_WARNING("argument is null.");
        return;
    }

    std::string ev(event);
    auto it = event_hook_list.find(ev);
    if(it != event_hook_list.end()) {
        it->second.push_back(f);
    }
    else {
        std::list<event_hook_func> l;
        l.push_back(f);
        event_hook_list[ev] = std::move(l);
    }
}

/**
 * onEvent function
 *
 * #### Parameters
 *  - api : the api serving the request
 *  - event  : event name
 *  - object : event json object
 *
 * #### Return
 * Nothing
 */
void hs_instance::onEvent(afb_api_t api, const char *event, struct json_object *object)
{
    std::string ev(event);
    auto it = event_hook_list.find(ev);
    if(it != event_hook_list.end()) {
        for(auto &ref : it->second) {
            if(ref(api, event, object))
                break;
        }
    }
    else {
        AFB_INFO("don't find hook event %s", event);
    }
}

/**
 * set event hook
 *
 * #### Parameters
 *  - event  : event name
 *  - f : hook function pointer
 *
 * #### Return
 * Nothing
 */
void setEventHook(const char *event, const event_hook_func f)
{
    if(g_hs_instance == nullptr) {
        AFB_ERROR("g_hs_instance is null.");
        return;
    }

    g_hs_instance->setEventHook(event, f);
}

/*
********** Method of HomeScreen Service (API) **********
*/

static void pingSample(afb_req_t request)
{
   static int pingcount = 0;
   afb_req_success_f(request, json_object_new_int(pingcount), "Ping count = %d", pingcount);
   AFB_DEBUG("Verbosity macro at level notice invoked at ping invocation count = %d", pingcount);
   pingcount++;
}

/**
 * tap_shortcut notify for homescreen
 * When Shortcut area is tapped,  notify these applciations
 *
 * #### Parameters
 * Request key
 * - application_id   : application id
 *
 * #### Return
 * None
 *
 */
static void tap_shortcut (afb_req_t request)
{
    int ret = 0;
    struct json_object *param_obj, *area_obj;
    const char* value = afb_req_value(request, _application_id);
    if (value
    && json_object_object_get_ex(afb_req_json(request), _parameter, &param_obj)
    && json_object_object_get_ex(param_obj, _area, &area_obj)) {
        AFB_INFO("request appid = %s.", value);
        const char* area = json_object_get_string(area_obj);
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
        if(ret == AFB_REQ_NOT_STARTED_APPLICATION) {
            g_hs_instance->client_manager->setStartupAppidAndArea(make_pair(std::string(value), std::string(area)));
            std::string id = g_hs_instance->app_info->getAppProperty(value, _keyId);
            HS_AfmMainProxy afm_proxy;
            afm_proxy.start(request->api, id);
            ret = 0;
        }
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [tap_shortcut]");
    }
}

/**
 * HomeScreen OnScreen message
 *
 * #### Parameters
 * Request key
 * - display_message   : message for display
 *
 * #### Return
 * None
 *
 */
static void on_screen_message (afb_req_t request)
{
    int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__);
    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [on_screen_message]");
    }
}

/**
 * HomeScreen OnScreen Reply
 *
 * #### Parameters
 * Request key
 * - reply_message   : message for reply
 *
 * #### Return
 * None
 *
 */
static void on_screen_reply (afb_req_t request)
{
    int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__);
    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [on_screen_reply]");
    }
}

/**
 * Subscribe event
 *
 * #### Parameters
 *  - event  : Event name. Event list is written in libhomescreen.cpp
 *
 * #### Return
 * None
 *
 */
static void subscribe(afb_req_t request)
{
    int ret = 0;
    std::string req_appid = std::move(get_application_id(request));
    if(!req_appid.empty()) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str());
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if(ret) {
        afb_req_fail_f(request, "afb_req_subscribe failed", "called %s.", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
            _error, ret);
        afb_req_success_f(request, res, "homescreen binder subscribe.");
    }
}

/**
 * Unsubscribe event
 *
 * #### Parameters
 *  - event  : Event name. Event list is written in libhomescreen.cpp
 *
 * #### Return
 * None
 *
 */
static void unsubscribe(afb_req_t request)
{
    int ret = 0;
    std::string req_appid = std::move(get_application_id(request));
    if(!req_appid.empty()) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str());
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if(ret) {
        afb_req_fail_f(request, "afb_req_unsubscribe failed", "called %s.", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
            _error, ret);
        afb_req_success_f(request, res, "homescreen binder unsubscribe success.");
    }
}

/**
 * showWindow event
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 * None
 *
 */
static void showWindow(afb_req_t request)
{
    int ret = 0;
    struct json_object *param_obj, *area_obj;
    const char* value = afb_req_value(request, _application_id);
    if (value
    && json_object_object_get_ex(afb_req_json(request), _parameter, &param_obj)
    && json_object_object_get_ex(param_obj, _area, &area_obj)) {
        const char* area = json_object_get_string(area_obj);
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
        if(ret == AFB_REQ_NOT_STARTED_APPLICATION) {
            g_hs_instance->client_manager->setStartupAppidAndArea(make_pair(std::string(value), std::string(area)));
            std::string id = g_hs_instance->app_info->getAppProperty(value, _keyId);
            HS_AfmMainProxy afm_proxy;
            afm_proxy.start(request->api, id);
            ret = 0;
        }
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [showWindow]");
    }
}

/**
 * hideWindow event
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 * None
 *
 */
static void hideWindow(afb_req_t request)
{
    int ret = 0;
    const char* value = afb_req_value(request, _application_id);
    if (value) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [hideWindow]");
    }
}

/**
 * replyShowWindow event
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 *  None
 *
 */
static void replyShowWindow(afb_req_t request)
{
    int ret = 0;
    const char* value = afb_req_value(request, _application_id);
    if (value) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [replyShowWindow]");
    }
}

/**
 * showNotification event
 *
 * the contents to homescreen which display at top area.
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 * None
 *
 */
static void showNotification(afb_req_t request)
{
    int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, "homescreen");
    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [showNotification]");
    }
}

/**
 * showInformation event
 *
 * the contents to homescreen which display at bottom area.
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 * None
 *
 */
static void showInformation(afb_req_t request)
{
    int ret = g_hs_instance->client_manager->handleRequest(request,  __FUNCTION__, "homescreen");
    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [showInformation]");
    }
}

/**
 * get runnables list
 *
 * #### Parameters
 *  - request : the request
 *
 * #### Return
 * None
 *
 */
static void getRunnables(afb_req_t request)
{
    struct json_object* j_runnable = json_object_new_array();
    g_hs_instance->app_info->getRunnables(&j_runnable);

    /*create response json object*/
    struct json_object *res = json_object_new_object();
    hs_add_object_to_json_object_func(res, __FUNCTION__, 2, _error, 0);
    json_object_object_add(res, _keyData, j_runnable);
    afb_req_success_f(request, res, "homescreen binder unsubscribe success.");
}

/**
 * registerShortcut event
 *
 * #### Parameters
 *  - value  : the json contents to MenuBar.
 *    {"application_id":"homescreen","parameter":{"shortcut_id":"dashboard@0.1","shortcut_name":"Dashboard","postion": 1}}
 *
 * #### Return
 * None
 *
 */
static void registerShortcut(afb_req_t request)
{
    int ret = 0;
    const char* value = afb_req_value(request, _application_id);
    if (value) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [registerShortcut]");
    }
}

/**
 * updateShortcut event
 *
 * #### Parameters
 *  - value  : homescreen shortcut json contents.
 *    {"application_id":"launcher","parameter":{"shortcut":[{"shortcut_id":"hvac","shortcut_name":"HVAC"},...]}}
 *
 * #### Return
 * None
 *
 */
static void updateShortcut(afb_req_t request)
{
    int ret = 0;
    const char* value = afb_req_value(request, _application_id);
    if (value) {
        ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
    }
    else {
        ret = AFB_EVENT_BAD_REQUEST;
    }

    if (ret) {
        afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
    }
    else {
        struct json_object *res = json_object_new_object();
        hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
          _error,  ret);
        afb_req_success(request, res, "afb_event_push event [updateShortcut]");
    }
}

/*
 * array of the verbs exported to afb-daemon
 */
static const afb_verb_t verbs[]= {
    /* VERB'S NAME                 FUNCTION TO CALL                  */
    { .verb="ping",              .callback=pingSample             },
    { .verb="tap_shortcut",      .callback=tap_shortcut           },
    { .verb="showWindow",        .callback=showWindow             },
    { .verb="hideWindow",        .callback=hideWindow             },
    { .verb="replyShowWindow",   .callback=replyShowWindow        },
    { .verb="on_screen_message", .callback=on_screen_message      },
    { .verb="on_screen_reply",   .callback=on_screen_reply        },
    { .verb="subscribe",         .callback=subscribe              },
    { .verb="unsubscribe",       .callback=unsubscribe            },
    { .verb="showNotification",  .callback=showNotification       },
    { .verb="showInformation",   .callback=showInformation        },
    { .verb="getRunnables",      .callback=getRunnables           },
    { .verb="registerShortcut",  .callback=registerShortcut       },
    { .verb="updateShortcut",    .callback=updateShortcut         },
    {NULL } /* marker for end of the array */
};

/**
 * homescreen binding preinit function
 *
 * #### Parameters
 *  - api : the api serving the request
 *
 * #### Return
 * None
 *
 */
static int preinit(afb_api_t api)
{
    AFB_DEBUG("binding preinit (was register)");
    return 0;
}

/**
 * homescreen binding init function
 *
 * #### Parameters
 *  - api : the api serving the request
 *
 * #### Return
 * None
 *
 */
static int init(afb_api_t api)
{
    AFB_DEBUG("binding init");

    if(g_hs_instance != nullptr) {
        AFB_WARNING( "g_hs_instance isn't null.");
        delete g_hs_instance->client_manager;
        delete g_hs_instance->app_info;
        delete g_hs_instance->app_recover;
        delete g_hs_instance->vui_adapter;
        delete g_hs_instance;
        g_hs_instance = nullptr;
    }
    g_hs_instance = new hs_instance();
    if(g_hs_instance == nullptr) {
        AFB_ERROR( "new g_hs_instance failed.");
        return -1;
    }

    return g_hs_instance->init(api);
}

/**
 * homescreen binding event function
 *
 * #### Parameters
 *  - api : the api serving the request
 *  - event  : event name
 *  - object : event json object
 *
 * #### Return
 * None
 *
 */
static void onevent(afb_api_t api, const char *event, struct json_object *object)
{
    AFB_INFO("on_event %s, object %s", event, json_object_to_json_string(object));
    g_hs_instance->onEvent(api, event, object);
}

const afb_binding_t afbBindingExport = {
    .api = "homescreen",
    .specification = NULL,
    .info = NULL,
    .verbs = verbs,
    .preinit = preinit,
    .init = init,
    .onevent = onevent
};