/*
 * Copyright (c) 2018 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.
 */


#include <fstream>
#include <sstream>
#include <istream>
#include <thread>
#include <map>
#include <systemd/sd-event.h>
#include <json-c/json.h>
#include "policy_manager.hpp"
#include "hmi-debug.h"

namespace stm {
extern "C" {
#include "dummy_stm.h"
}
} // namespace stm


namespace pm {
struct sd_event* event_loop;
std::map<int, struct sd_event_source*> event_source_list;
PolicyManager::CallbackTable callback;
}  // namespace pm


PolicyManager::PolicyManager() :
  eventname2no_(),
  categoryname2no_(),
  areaname2no_(),
  role2category_(),
  category2role_(),
  role2defaultarea_()
{
    HMI_DEBUG("wm:pm", "Call");
}

int PolicyManager::initialize() {
    HMI_DEBUG("wm:pm", "Call");

    int ret = 0;

    // Create convert map
    for (unsigned int i=0; i<STM_NUM_EVT; i++) {
        HMI_DEBUG("wm:pm", "event name:%s no:%d", stm::gStmEventName[i], stm::gStmEventNo[i]);
        this->eventname2no_[stm::gStmEventName[i]] = stm::gStmEventNo[i];
    }

    for (unsigned int i=0; i<STM_NUM_CTG; i++) {
        HMI_DEBUG("wm:pm", "category name:%s no:%d", stm::gStmCategoryName[i], stm::gStmCategoryNo[i]);
        this->categoryname2no_[stm::gStmCategoryName[i]] = stm::gStmCategoryNo[i];
    }

    for (unsigned int i=0; i<STM_NUM_ARA; i++) {
        HMI_DEBUG("wm:pm", "area name:%s no:%d", stm::gStmAreaName[i], stm::gStmAreaNo[i]);
        this->areaname2no_[stm::gStmAreaName[i]] = stm::gStmAreaNo[i];
    }

    // Load role.db
    ret = this->loadRoleDb();
    if (0 > ret) {
        HMI_ERROR("wm:pm", "Load role.db Error!!");
        return ret;
    }

    // Initialize StateTransitioner
    stm::stmInitialize();

    // Initialize sd_event loop
    ret = this->initializeSdEventLoop();
    if (0 > ret) {
        HMI_ERROR("wm:pm", "Failed to initializeSdEventLoop!!");
        return ret;
    }

    return ret;
}

int PolicyManager::initializeSdEventLoop() {
    // Get default event loop object
    int ret = sd_event_new(&(pm::event_loop));
    if (0 > ret) {
        HMI_ERROR("wm:pm", "Faild to sd_event_default: errno:%d", ret);
        return -1;
    }

    // Create thread for sd_event and detach
    std::thread sd_event_loop([this]() {
        while (1) {
            sd_event_run(pm::event_loop, 1000);
        }
    });
    sd_event_loop.detach();

    return 0;
}

static void addStateToJson(
  const char* key, int is_changed, const char* state, json_object** json_out) {
    if ((nullptr == key) || (nullptr == state) || (nullptr == json_out)) {
        HMI_ERROR("wm:pm", "Argument is nullptr!!!");
        return;
    }

    json_object* json_obj = json_object_new_object();
    json_object_object_add(json_obj, "is_changed", json_object_new_boolean(is_changed));
    if (is_changed) {
        HMI_DEBUG("wm:pm", "%s: state changed (%s)", key, state);
        json_object_object_add(json_obj, "state", json_object_new_string(state));
    }
    json_object_object_add(*json_out, key, json_obj);
}

static int checkPolicyEntry(int event, uint64_t delay_ms);
static int checkPolicy(sd_event_source *source, void *data) {
    HMI_DEBUG("wm:pm", "Call");
    HMI_DEBUG("wm:pm", ">>>>>>>>>> START CHECK POLICY");

    int event = *((int*)data);

    int event_no, category_no, area_no;
    event_no    = event & STM_MSK_EVT_NO;
    category_no = event & STM_MSK_CTG_NO;
    area_no     = event & STM_MSK_ARA_NO;
    HMI_DEBUG("wm:pm", ">>>>>>>>>> event:%s category:%s area:%s",
              stm::gStmEventName[event_no - 1],
              stm::gStmCategoryName[(category_no >> 8) - 1],
              stm::gStmAreaName[(area_no >> 16) - 1]);

    // Transition state
    stm::stm_state_t crr_state;
    int ret = stm::stmTransitionState(event, &crr_state);
    if (0 > ret) {
        HMI_ERROR("wm:pm", "Error!!");
        return -1;
    }

    HMI_DEBUG("wm:pm", "parking brake state     (is_changed:%d state:%d:%s)",
              crr_state.parking_brake.is_changed,
              crr_state.parking_brake.state,
              stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state]);
    HMI_DEBUG("wm:pm", "accelerator pedal state (is_changed:%d state:%d:%s)",
              crr_state.accel_pedal.is_changed,
              crr_state.accel_pedal.state,
              stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state]);
    HMI_DEBUG("wm:pm", "lightstatus brake state (is_changed:%d state:%d:%s)",
              crr_state.lightstatus_brake.is_changed,
              crr_state.lightstatus_brake.state,
              stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state]);
    HMI_DEBUG("wm:pm", "car state               (is_changed:%d state:%d:%s)",
              crr_state.car.is_changed,
              crr_state.car.state,
              stm::gStmCarStateNo2Name[crr_state.car.state]);
    HMI_DEBUG("wm:pm", "lamp state              (is_changed:%d state:%d:%s)",
              crr_state.lamp.is_changed,
              crr_state.lamp.state,
              stm::gStmLampStateNo2Name[crr_state.lamp.state]);
    HMI_DEBUG("wm:pm", "restriction mode state  (is_changed:%d state:%d:%s)",
              crr_state.restriction_mode.is_changed,
              crr_state.restriction_mode.state,
              stm::gStmRestrictionModeStateNo2Name[crr_state.restriction_mode.state]);
    HMI_DEBUG("wm:pm", "homescreen state        (is_changed:%d state:%d:%s)",
              crr_state.layer.homescreen.is_changed,
              crr_state.layer.homescreen.state,
              stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state]);
    HMI_DEBUG("wm:pm", "apps state              (is_changed:%d state:%d:%s)",
              crr_state.layer.apps.is_changed,
              crr_state.layer.apps.state,
              stm::gStmLayoutNo2Name[crr_state.layer.apps.state]);
    HMI_DEBUG("wm:pm", "restriction state       (is_changed:%d state:%d:%s)",
              crr_state.layer.restriction.is_changed,
              crr_state.layer.restriction.state,
              stm::gStmLayoutNo2Name[crr_state.layer.restriction.state]);
    HMI_DEBUG("wm:pm", "on_screen state         (is_changed:%d state:%d:%s)",
              crr_state.layer.on_screen.is_changed,
              crr_state.layer.on_screen.state,
              stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state]);

    json_object* json_out = json_object_new_object();

    // Create result
    // {
    //     "parking_brake": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("parking_brake",
                   crr_state.parking_brake.is_changed,
                   stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state],
                   &json_out);

    //     "accel_pedal": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("accel_pedal",
                   crr_state.accel_pedal.is_changed,
                   stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state],
                   &json_out);

    //     "lightstatus_brake": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("lightstatus_brake",
                   crr_state.lightstatus_brake.is_changed,
                   stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state],
                   &json_out);

    //     "car": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("car",
                   crr_state.car.is_changed,
                   stm::gStmCarStateNo2Name[crr_state.car.state],
                   &json_out);

    //     "lamp": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("lamp",
                   crr_state.lamp.is_changed,
                   stm::gStmLampStateNo2Name[crr_state.lamp.state],
                   &json_out);

    //     "restriction_mode": {
    //         "is_changed": <bool>,
    //         "state": <const char*>
    //     },
    addStateToJson("restriction_mode",
                   crr_state.restriction_mode.is_changed,
                   stm::gStmRestrictionModeStateNo2Name[crr_state.restriction_mode.state],
                   &json_out);

    //     "layers": [
    json_object* json_layer = json_object_new_array();
    json_object* json_tmp;

    //         {
    //             "homescreen": {
    //                 "is_changed": <bool>,
    //                 "state": <const char*>
    //             }
    //         },
    //     ]
    // }
    json_tmp = json_object_new_object();
    addStateToJson("homescreen",
                   crr_state.layer.homescreen.is_changed,
                   stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state],
                   &json_tmp);
    json_object_array_add(json_layer, json_tmp);

    //         {
    //             "apps": {
    //                 "is_changed": <bool>,
    //                 "state": <const char*>
    //             }
    //         },
    json_tmp = json_object_new_object();
    addStateToJson("apps",
                   crr_state.layer.apps.is_changed,
                   stm::gStmLayoutNo2Name[crr_state.layer.apps.state],
                   &json_tmp);
    json_object_array_add(json_layer, json_tmp);

    //         {
    //             "restriction": {
    //                 "is_changed": <bool>,
    //                 "state": <const char*>
    //             }
    //         },
    json_tmp = json_object_new_object();
    addStateToJson("restriction",
                   crr_state.layer.restriction.is_changed,
                   stm::gStmLayoutNo2Name[crr_state.layer.restriction.state],
                   &json_tmp);
    json_object_array_add(json_layer, json_tmp);

    //         {
    //             "on_screen": {
    //                 "is_changed": <bool>,
    //                 "state": <const char*>
    //             }
    //         },
    json_tmp = json_object_new_object();
    addStateToJson("on_screen",
                   crr_state.layer.on_screen.is_changed,
                   stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state],
                   &json_tmp);
    json_object_array_add(json_layer, json_tmp);

    // Add json array of layer
    json_object_object_add(json_out, "layers", json_layer);

    // Notify state is changed
    if (nullptr != pm::callback.onStateTransitioned) {
        pm::callback.onStateTransitioned(json_out);
    }

    if (crr_state.car.is_changed) {
        if (stm::gStmCarStateNoRun == crr_state.car.state) {
            // Set delay event(restriction mode on)
            checkPolicyEntry(STM_EVT_NO_RESTRICTION_MODE_ON, 3000);
        }
        else if (stm::gStmCarStateNoStop == crr_state.car.state) {
            // Set event(restriction mode off)
            checkPolicyEntry(STM_EVT_NO_RESTRICTION_MODE_OFF, 0);

            // Stop timer for restriction on event
            if (pm::event_source_list.find(STM_EVT_NO_RESTRICTION_MODE_ON)
              != pm::event_source_list.end()) {
                HMI_DEBUG("wm:pm", "Stop timer for restriction on");
                sd_event_source *event_source
                    = pm::event_source_list[STM_EVT_NO_RESTRICTION_MODE_ON];
                int ret = sd_event_source_set_enabled(event_source, SD_EVENT_OFF);
                if (0 > ret) {
                    HMI_ERROR("wm:pm", "Failed to stop timer");
                }
            }
        }
    }

    // Release json_object
    json_object_put(json_out);

    // Release data
    delete (int*)data;

    // Destroy sd_event_source object
    sd_event_source_unref(source);

    // Remove event source from list
    if (pm::event_source_list.find(event) != pm::event_source_list.end()) {
        pm::event_source_list.erase(event);
    }

    HMI_DEBUG("wm:pm", ">>>>>>>>>> FINISH CHECK POLICY");
    return 0;
}

static int timerEvent(sd_event_source *source, uint64_t usec, void *data) {
    checkPolicy(source, data);
};

static int checkPolicyEntry(int event, uint64_t delay_ms)
{
    HMI_DEBUG("wm:pm", "Call");
    HMI_DEBUG("wm:pm", "event:0x%x", event);

    if (0 == delay_ms) {
        int ret = sd_event_add_defer(pm::event_loop, NULL,
                                     &checkPolicy, new int(event));
        if (0 > ret) {
            HMI_ERROR("wm:pm", "Faild to sd_event_add_defer: errno:%d", ret);
            return -1;
        }
    }
    else {
        // Get current time
        struct timespec time_spec;
        clock_gettime(CLOCK_MONOTONIC, &time_spec);

        // Calculate timer fired time
        uint64_t usec = (time_spec.tv_sec * 1000000)
            + (time_spec.tv_nsec / 1000)
            + (delay_ms * 1000);

        // Set timer
        struct sd_event_source* event_source;
        int ret = sd_event_add_time(pm::event_loop, &event_source, CLOCK_MONOTONIC, usec, 1,
                                    &timerEvent, new int(event));
        if (0 > ret) {
            HMI_ERROR("wm:pm", "Faild to sd_event_add_time: errno:%d", ret);
            return -1;
        }

        // Store event source
        pm::event_source_list[event] = event_source;
    }

    return 0;
}

void PolicyManager::registerCallback(CallbackTable callback) {
    pm::callback.onStateTransitioned = callback.onStateTransitioned;
    pm::callback.onError             = callback.onError;
}

int PolicyManager::inputEvent(json_object* json_in) {
    HMI_DEBUG("wm:pm", "Call");

    // Check arguments
    if (nullptr == json_in) {
        HMI_ERROR("wm:pm", "Argument is NULL!!");
        return -1;
    }

    // Get event from json_object
    const char* event = this->getStringFromJson(json_in, "event");
    int event_no = 0;
    if (nullptr != event) {
        // Convert name to number
        event_no = this->eventname2no_[event];
        HMI_DEBUG("wm:pm", "event(%s:%d)", event, event_no);
    }

    // Get role from json_object
    const char* role = this->getStringFromJson(json_in, "role");
    int category_no = 0;
    if (nullptr != role) {
        HMI_DEBUG("wm:pm", "role(%s)", role);

        // Convert role to category
        const char* category = this->role2category_[role].c_str();
        if (0 == strcmp("", category)) {
            HMI_ERROR("wm:pm", "Error!!");
            return -1;
        }
        HMI_DEBUG("wm:pm", "category(%s)", category);

        // Convert name to number
        category_no = categoryname2no_[category];
        HMI_DEBUG("wm:pm", "role(%s), category(%s:%d)", role, category, category_no);
    }

    // Get areat from json_object
    const char* area = this->getStringFromJson(json_in, "area");
    int area_no = 0;
    if (nullptr != area) {
        // Convert name to number
        area_no = areaname2no_[area];
        HMI_DEBUG("wm:pm", "area(%s:%d)", area, area_no);
    }

    // Check policy
    checkPolicyEntry((event_no | category_no | area_no), 0);

    return 0;
}

std::string PolicyManager::roleToCategory(const char* role) {
    return this->role2category_[role];
}

extern const char* kDefaultRoleDb;
int PolicyManager::loadRoleDb() {
    HMI_DEBUG("wm:pm", "Call");

    std::string file_name;

    // Get afm application installed dir
    char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
    HMI_DEBUG("wm:pm", "afm_app_install_dir:%s", afm_app_install_dir);

    if (!afm_app_install_dir) {
        HMI_ERROR("wm:pm", "AFM_APP_INSTALL_DIR is not defined");
    }
    else {
        file_name = std::string(afm_app_install_dir) + std::string("/etc/role.db");
    }

    // Load role.db
    json_object* json_obj;
    int ret = this->inputJsonFilie(file_name.c_str(), &json_obj);
    if (0 > ret) {
        HMI_ERROR("wm:pm", "Could not open role.db, so use default role information");
        json_obj = json_tokener_parse(kDefaultRoleDb);
    }
    HMI_DEBUG("wm:pm", "json_obj dump:%s", json_object_get_string(json_obj));

    json_object* json_roles;
    if (!json_object_object_get_ex(json_obj, "roles", &json_roles)) {
        HMI_ERROR("wm:pm", "Parse Error!!");
        return -1;
    }

    int len = json_object_array_length(json_roles);
    HMI_DEBUG("wm:pm", "json_cfg len:%d", len);
    HMI_DEBUG("wm:pm", "json_cfg dump:%s", json_object_get_string(json_roles));

    json_object* json_tmp;
    const char* category;
    const char* roles;
    const char* areas;
    for (int i=0; i<len; i++) {
        json_tmp = json_object_array_get_idx(json_roles, i);

        category = this->getStringFromJson(json_tmp, "category");
        roles =  this->getStringFromJson(json_tmp, "role");
        areas =  this->getStringFromJson(json_tmp, "area");

        if ((nullptr == category) || (nullptr == roles) || (nullptr == areas)) {
            HMI_ERROR("wm:pm", "Parse Error!!");
            return -1;
        }

        // Parse roles by '|'
        std::vector<std::string> vct_roles;
        vct_roles = this->parseString(std::string(roles), '|');

        // Parse areas by '|'
        std::vector<std::string> vct_areas;
        vct_areas = this->parseString(std::string(areas), '|');

        // Set role, category, default area
        for (auto itr = vct_roles.begin(); itr != vct_roles.end(); ++itr) {
            // Delete space from role and area name
            std::string role = this->deleteSpace(*itr);
            std::string area = this->deleteSpace(vct_areas[0]);

            this->role2category_[role] = std::string(category);
            this->role2defaultarea_[role] = area;
        }

        this->category2role_[std::string(category)] = std::string(roles);
    }

    // Check
    HMI_DEBUG("wm:pm", "Check role2category_");
    for (auto& x:this->role2category_){
        HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
    }

    HMI_DEBUG("wm:pm", "Check role2defaultarea_");
    for (auto& x:this->role2defaultarea_){
        HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
    }

    HMI_DEBUG("wm:pm", "Check category2role_");
    for (auto& x:this->category2role_){
        HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
    }

    return 0;
}

// TODO:
// This function will be removed because json_helper has same function.
// json_helper should be library.
const char* PolicyManager::getStringFromJson(json_object* obj, const char* key) {
    if ((nullptr == obj) || (nullptr == key)) {
        HMI_ERROR("wm:pm", "Argument is nullptr!!!");
        return nullptr;
    }

    json_object* tmp;
    if (!json_object_object_get_ex(obj, key, &tmp)) {
        HMI_DEBUG("wm:pm", "Not found key \"%s\"", key);
        return nullptr;
    }

    return json_object_get_string(tmp);
}

// TODO:
// This function will be removed because json_helper has same function.
// json_helper should be library.
int PolicyManager::inputJsonFilie(const char* file, json_object** obj) {
    const int input_size = 128;
    int ret = -1;

    if ((nullptr == file) || (nullptr == obj)) {
        HMI_ERROR("wm:jh", "Argument is nullptr!!!");
        return ret;
    }

    HMI_DEBUG("wm:jh", "Input file: %s", file);

    // Open json file
    FILE *fp = fopen(file, "rb");
    if (nullptr == fp) {
        HMI_ERROR("wm:jh", "Could not open file");
        return ret;
    }

    // Parse file data
    struct json_tokener *tokener = json_tokener_new();
    enum json_tokener_error json_error;
    char buffer[input_size];
    int block_cnt = 1;
    while (1) {
        size_t len = fread(buffer, sizeof(char), input_size, fp);
        *obj = json_tokener_parse_ex(tokener, buffer, len);
        if (nullptr != *obj) {
            HMI_DEBUG("wm:jh", "File input is success");
            ret = 0;
            break;
        }

        json_error = json_tokener_get_error(tokener);
        if ((json_tokener_continue != json_error)
            || (input_size > len)) {
            HMI_ERROR("wm:jh", "Failed to parse file (byte:%d err:%s)",
                      (input_size * block_cnt), json_tokener_error_desc(json_error));
            HMI_ERROR("wm:jh", "\n%s", buffer);
            *obj = nullptr;
            break;
        }
        block_cnt++;
    }

    // Close json file
    fclose(fp);

    // Free json_tokener
    json_tokener_free(tokener);

    return ret;
}

std::vector<std::string> PolicyManager::parseString(std::string str, char delimiter) {
    // Parse string by delimiter
    std::vector<std::string> vct;
    std::stringstream ss{str};
    std::string buf;
    while (std::getline(ss, buf, delimiter)) {
      if (!buf.empty()) {
        vct.push_back(buf);
      }
    }
    return vct;
}

std::string PolicyManager::deleteSpace(std::string str) {
    std::string ret = str;
    size_t pos;
    while ((pos = ret.find_first_of(" ")) != std::string::npos) {
      ret.erase(pos, 1);
    }
    return ret;
}

const char* kDefaultRoleDb = "{ \
    \"roles\":[ \
    { \
        \"category\": \"homescreen\", \
        \"role\": \"homescreen\", \
        \"area\": \"full\", \
    }, \
    { \
        \"category\": \"map\", \
        \"role\": \"map\", \
        \"area\": \"full | normal | split.main\", \
    }, \
    { \
        \"category\": \"general\", \
        \"role\": \"poi | music | video | browser | sdl | settings | mixer | radio | hvac | dashboard | debug\", \
        \"area\": \"normal\", \
    }, \
    { \
        \"category\": \"phone\", \
        \"role\": \"phone\", \
        \"area\": \"normal\", \
    }, \
    { \
        \"category\": \"splitable\", \
        \"role\": \"splitable1 | splitable2\", \
        \"area\": \"normal | split.main | split.sub\", \
    }, \
    { \
        \"category\": \"popup\", \
        \"role\": \"popup\", \
        \"area\": \"on_screen\", \
    }, \
    { \
        \"category\": \"system_alert\", \
        \"role\": \"system_alert\", \
        \"area\": \"on_screen\", \
    }, \
    { \
        \"category\": \"tbt\", \
        \"role\": \"tbt\", \
        \"area\": \"hud\", \
    } \
    ] \
}";