#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <cjson/cJSON.h>

#include "log.h"
#include "mpack.h"
#include "utils.h"
#include "control_packet.h"

const char *session_state_to_string(enum session_state state)
{
    switch (state)
    {
    case SESSION_STATE_OPENING:
        return "opening";
    case SESSION_STATE_CLOSING:
        return "closing";
    case SESSION_STATE_ACTIVE:
        return "active";
    case SESSION_STATE_RESETALL:
        return "resetall";
    default:
        return "unknown";
    }
}

// return  0 : success
// return -1 : error
int control_packet_parse(struct control_packet *handler, const char *data, size_t length)
{
    memset(handler, 0, sizeof(struct control_packet));

    mpack_tree_t tree;
    mpack_node_t root;
    mpack_node_t temp;
    mpack_node_t item;
    mpack_error_t ret;
    char buffer[16];

    mpack_tree_init_data(&tree, data, length);
    mpack_tree_parse(&tree);
    root = mpack_tree_root(&tree);
    if (mpack_node_is_nil(root))
    {
        LOG_ERROR("%s: unexpected control packet: (invalid mpack format)", LOG_TAG_CTRLPKT);
        goto error_out;
    }

    // tsync
    temp = mpack_node_map_cstr(root, "tsync");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (tsync no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    mpack_node_copy_cstr(temp, handler->tsync, sizeof(handler->tsync));
    if (strcasecmp(handler->tsync, "2.0") != 0)
    {
        LOG_ERROR("%s: unexpected control packet: (invalid tsync value) %s", LOG_TAG_CTRLPKT, handler->tsync);
        goto error_out;
    }

    // session_id
    temp = mpack_node_map_cstr(root, "session_id");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (session_id no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    handler->session_id = mpack_node_u64(temp);
    if (handler->session_id == 0)
    {
        LOG_ERROR("%s: unexpected control packet: (invalid session_id value) %lu", LOG_TAG_CTRLPKT, handler->session_id);
        goto error_out;
    }

    // state
    temp = mpack_node_map_cstr(root, "state");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (state no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    mpack_node_copy_cstr(temp, buffer, sizeof(buffer));
    if (strcasecmp(buffer, "opening") == 0)
    {
        handler->state = SESSION_STATE_OPENING;
    }
    else if (strcasecmp(buffer, "active") == 0)
    {
        handler->state = SESSION_STATE_ACTIVE;
    }
    else if (strcasecmp(buffer, "closing") == 0)
    {
        handler->state = SESSION_STATE_CLOSING;
    }
    else if (strcasecmp(buffer, "resetall") == 0)
    {
        handler->state = SESSION_STATE_RESETALL;
    }
    else
    {
        LOG_ERROR("%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, buffer);
        goto error_out;
    }
    if (handler->state != SESSION_STATE_ACTIVE)
    {
        goto success_out;
    }

    // method
    temp = mpack_node_map_cstr(root, "method");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (method no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    mpack_node_copy_cstr(temp, handler->method, sizeof(handler->method));
    if (strcasecmp(handler->method, "policy_update") != 0)
    {
        LOG_ERROR("%s: unexpected control packet: (invalid method value) %s", LOG_TAG_CTRLPKT, handler->method);
        goto error_out;
    }

    // params
    temp = mpack_node_map_cstr(root, "params");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (params no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    // params->sce
    temp = mpack_node_map_cstr(temp, "sce");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (sce no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    // params->sce->rule_ids
    temp = mpack_node_map_cstr(temp, "rule_ids");
    if (mpack_node_is_nil(temp))
    {
        LOG_ERROR("%s: unexpected control packet: (rule_ids no found)", LOG_TAG_CTRLPKT);
        goto error_out;
    }
    handler->rule_id_num = MIN(mpack_node_array_length(temp), (int)(sizeof(handler->rule_ids) / sizeof(handler->rule_ids[0])));
    if (handler->rule_id_num <= 0)
    {
        LOG_ERROR("%s: unexpected control packet: (invalid rule id num) %ld", LOG_TAG_CTRLPKT, mpack_node_array_length(temp));
        goto error_out;
    }
    for (int i = 0; i < handler->rule_id_num; i++)
    {
        item = mpack_node_array_at(temp, i);
        handler->rule_ids[i] = mpack_node_u64(item);
    }

success_out:
    ret = mpack_tree_destroy(&tree);
    if (ret != mpack_ok)
    {
        LOG_ERROR("%s: unexpected control packet: (mpack return error) %d", LOG_TAG_CTRLPKT, ret);
        return -1;
    }

    return 0;

error_out:
    mpack_tree_destroy(&tree);
    return -1;
}

void control_packet_dump(struct control_packet *handler)
{
    if (handler)
    {
        LOG_INFO("%s: tsync           : %s", LOG_TAG_POLICY, handler->tsync);
        LOG_INFO("%s: session_id      : %lu", LOG_TAG_POLICY, handler->session_id);
        LOG_INFO("%s: state           : %s", LOG_TAG_POLICY, session_state_to_string(handler->state));
        LOG_INFO("%s: method          : %s", LOG_TAG_POLICY, handler->method);
        LOG_INFO("%s: rule_id_num     : %d", LOG_TAG_POLICY, handler->rule_id_num);

        for (int i = 0; i < handler->rule_id_num; i++)
        {
            LOG_INFO("%s: rule_ids[%03d]   : %lu", LOG_TAG_POLICY, i, handler->rule_ids[i]);
        }
    }
}