/****************************************************************************

Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.

This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.

****************************************************************************/

#include "iot_io.h"

#include "iot_cli_host_interface.h"
#include "iot_cli_plc_module.h"
#include "iot_cli_msg.h"
#include "iot_cli_plc_tx_rx.h"
#include "iot_cli_sg_api.h"
#include "iot_cli_sg_ctrl_api.h"
#include "iot_cli_sg.h"
#include "iot_cli_upgrade_status_type_def.h"
#include "iot_cli_upgrade.h"

#if IOT_CLI_SG_INTERFACE_ENABLE

extern iot_plc_host_config_t *host_config;
extern iot_cli_host_info_t *host_info;

uint8_t iot_cli_sg_get_headroom_req()
{
    return sizeof(iot_cli_sg_msg_header_t);
}

uint32_t iot_cli_sg_interface_register(iot_cli_sg_interface_t *cli_interface)
{
    if (cli_interface == NULL) {
        return IOT_CLI_SG_REGISTER_FAILURE;
    }
    host_config->cli_sg_interface = cli_interface;
    return IOT_CLI_SG_REGISTER_SUCCESS;
}

void iot_cli_sg_prep_msg(iot_pkt_t *pkt, uint8_t msg_id, uint8_t req_id)
{
    iot_cli_sg_msg_header_t *hd;
    hd = (iot_cli_sg_msg_header_t *)iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_HEAD);
    hd->msg_id = msg_id;
    hd->req_id = req_id;
}

void iot_sg_cli_send_cmd(uint8_t req_id, uint8_t msg_id,
    uint8_t *data, uint32_t data_len)
{
    iot_pkt_t *pkt = NULL;
    uint8_t *data_ptr;

    if (host_config->cli_sg_interface == NULL) {
        return;
    }

    pkt = iot_pkt_alloc(data_len + iot_cli_sg_get_headroom_req(), IOT_CLI_MID);
    IOT_ASSERT(pkt);

    data_ptr = iot_pkt_reserve(pkt, iot_cli_sg_get_headroom_req());
    iot_cli_sg_prep_msg(pkt, msg_id, req_id);

    if (data && data_len) {
        iot_pkt_set_tail(pkt,
            iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_DATA) + data_len);
        os_mem_cpy(data_ptr, data, data_len);
    }

    host_config->cli_sg_interface->recv(NULL, pkt);
}

void iot_cli_sg_send_data_to_cli_interface(iot_pkt_t *pkt, uint8_t msg_id,
    uint8_t req_id)
{
    iot_task_msg_t *t_msg;
    if (pkt == NULL) {
        return;
    }

    iot_cli_sg_prep_msg(pkt, msg_id, req_id);
    t_msg = iot_cli_create_cli_msg(IOT_CLI_SG_MSG, pkt);
    if (t_msg) {
        iot_task_queue_msg(
            host_info->host_task_h, t_msg, IOT_CLI_QUEUE_HOST);
    } else if (pkt) {
        iot_pkt_free(pkt);
    }
}

void iot_cli_sg_set_mac(uint8_t req_id, iot_cli_sg_set_mac_dl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_MAC, (uint8_t *)data,
        sizeof(*data));
}

#if IOT_CLI_SUPPORT_WL_CMD

void iot_sg_cli_query_wl_state(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_WL_STATE, NULL, 0);
}

void iot_sg_cli_query_wl(uint8_t req_id, iot_cli_sg_query_wl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_WL,
        (uint8_t *)data, sizeof(iot_cli_sg_query_wl_t));
}

void iot_sg_cli_add_wl(uint8_t req_id, iot_cli_sg_add_wl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_ADD_WL,
        (uint8_t *)data,
        sizeof(iot_cli_sg_add_wl_t) + data->count * sizeof(data->node_info[0]));
}

void iot_sg_cli_rm_wl(uint8_t req_id, iot_cli_sg_rm_wl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_RM_WL,
        (uint8_t *)data,
        sizeof(iot_cli_sg_rm_wl_t) + data->count * IOT_MAC_ADDR_LEN);
}

void iot_sg_cli_set_wl_state(uint8_t req_id, iot_cli_sg_set_wl_state_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_WL_STATE,
        (uint8_t *)data, sizeof(iot_cli_sg_set_wl_state_t));
}

static uint8_t iot_cli_sg_handle_wl_msg(iot_cli_sg_msg_header_t *hdr,
    uint8_t *data)
{
    uint8_t done = 1;
    cli_app_cmd_mapping_item *cmd = NULL;
    uint8_t *cli_src_mac = NULL;

    IOT_ASSERT(hdr);

    if (hdr->req_id) {
        cmd = get_cmd_from_mapping_table(hdr->req_id);
    }

    if (cmd) {
        cli_src_mac = cmd->mac;
        iot_printf("plc_sg_handle_mac_mapping msg=%d, index=%d\n", \
            hdr->msg_id, hdr->req_id);
    }

    switch (hdr->msg_id) {
    case IOT_CLI_SG_MSG_RPT_WL_STATE:
    {
        iot_cli_sg_rpt_wl_state_t *rsp = (iot_cli_sg_rpt_wl_state_t *)data;
        iot_printf("%s: wl state is %d\n", __FUNCTION__, rsp->state);

        iot_cli_send_to_host(CLI_MSGID_GETWHITELIST_STATE_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_wl_state_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_WL:
    {
        iot_cli_sg_rpt_wl_t *rsp = (iot_cli_sg_rpt_wl_t *)data;
        iot_printf("%s: total node: %d, transfer node: %d\n", __FUNCTION__,
            rsp->total_count, rsp->rsp_count);
        for (uint32_t i = 0; i < rsp->rsp_count; ++i) {
            iot_printf("meter mac=[%02X:%02X:%02X:%02X:%02X:%02X],"
                " proto type=%d\n",
                rsp->node_info[i].mac[0], rsp->node_info[i].mac[1],
                rsp->node_info[i].mac[2], rsp->node_info[i].mac[3],
                rsp->node_info[i].mac[4], rsp->node_info[i].mac[5],
                rsp->node_info[i].proto_type);
        }

        iot_cli_send_to_host(CLI_MSGID_GETWHITELIST_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_wl_t) +
            (sizeof(rsp->node_info[0]) * rsp->rsp_count), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_ADD_WL:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: add wl is %lu\n", __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSGID_ADD_WHITELIST_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_RM_WL:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: rm wl is %lu\n", __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSGID_RM_WHITELIST_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SET_WL_STATE:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: set wl state is %lu\n", __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SET_WHITELIST_STATE_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    default:
        done = 0;
        break;
    }

    return done;
}

#endif /* IOT_CLI_SUPPORT_WL_CMD */

#if PLC_SUPPORT_CCO_ROLE

void iot_cli_sg_get_meter_data(uint8_t req_id, uint8_t *data,
    uint32_t datalen)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_GET_METER, data, datalen);
}

void iot_cli_sg_get_meter_rt_data(uint8_t req_id, uint8_t *data,
    uint32_t datalen)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_GET_RT_METER, data, datalen);
}

void iot_cli_sg_get_report_ack(uint8_t req_id, uint8_t *data,
    uint32_t datalen)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_GET_REPORT_ACK, data, datalen);
}

void iot_cli_sg_handle_user_data(uint8_t req_id, uint8_t* src_mac,
    uint8_t *data, uint32_t datalen)
{
    iot_pkt_t *pkt = NULL;
    iot_cli_sg_user_data_dl_t *user_data;

    if (host_config->cli_sg_interface == NULL) {
        return;
    }

    pkt = iot_pkt_alloc(iot_cli_sg_get_headroom_req() +
        datalen + sizeof(iot_cli_sg_user_data_dl_t), IOT_CLI_MID);
    IOT_ASSERT(pkt);

    user_data = (iot_cli_sg_user_data_dl_t *)
        iot_pkt_reserve(pkt, iot_cli_sg_get_headroom_req());
    iot_cli_sg_prep_msg(pkt, IOT_CLI_SG_MSG_HANDLE_USER_DATA, req_id);
    iot_pkt_put(pkt, datalen + sizeof(iot_cli_sg_user_data_dl_t));

    os_mem_cpy(user_data->src_mac, src_mac, CLI_MAC_ADDR_LEN);
    user_data->data_len = (uint8_t)datalen;
    os_mem_cpy(user_data->data, data, user_data->data_len);

    host_config->cli_sg_interface->recv(NULL, pkt);
}

void iot_cli_sg_start_get_meter_list(uint8_t req_id, uint16_t duration)
{
    iot_pkt_t *pkt = NULL;
    iot_cli_sg_start_sec_node_reg_dl_t *rpt;

    if (host_config->cli_sg_interface == NULL) {
        return;
    }

    host_config->cli_request_id = req_id;

    pkt = iot_pkt_alloc(CLI_SG_MSG_SHORT_BUF_SIZE, IOT_CLI_MID);
    IOT_ASSERT(pkt);

    rpt = (iot_cli_sg_start_sec_node_reg_dl_t *)iot_pkt_reserve(pkt,
        iot_cli_sg_get_headroom_req());
    iot_cli_sg_prep_msg(pkt, IOT_CLI_SG_MSG_START_METER_LIST, req_id);
    iot_pkt_put(pkt, sizeof(iot_cli_sg_start_sec_node_reg_dl_t));

    rpt->duration = duration;

    host_config->cli_sg_interface->recv(NULL, pkt);
}

void iot_sg_cli_stop_get_meter_list(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_STOP_METER_LIST, NULL, 0);
}

void iot_sg_cli_get_meter_list(uint8_t req_id, uint16_t start_index,
    uint8_t count)
{
    iot_pkt_t *pkt = NULL;
    iot_cli_sg_get_sec_node_info_dl_t *req;

    if (host_config->cli_sg_interface == NULL) {
        return;
    }

    pkt = iot_pkt_alloc(CLI_SG_MSG_SHORT_BUF_SIZE, IOT_CLI_MID);
    IOT_ASSERT(pkt);

    req = (iot_cli_sg_get_sec_node_info_dl_t *)iot_pkt_reserve(pkt,
        iot_cli_sg_get_headroom_req());
    iot_cli_sg_prep_msg(pkt, IOT_CLI_SG_MSG_GET_METER_LIST, req_id);
    iot_pkt_put(pkt, sizeof(iot_cli_sg_get_sec_node_info_dl_t));

    req->sec_node_start_index = start_index;
    req->sec_node_count = count;

    host_config->cli_sg_interface->recv(NULL, pkt);
}

void cli_upgrade_dst_status_sg_query(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_UPGRADE_STATUS, NULL, 0);
}

void cli_upgrade_dst_status_sg_list(uint16_t start_index,
    uint8_t dst_num, uint8_t req_id)
{
    iot_pkt_t *pkt = NULL;
    iot_cli_sg_upgrade_progress_dl *query;
    if (host_config->cli_sg_interface == NULL) {
        return;
    }

    pkt = iot_pkt_alloc(CLI_SG_MSG_SHORT_BUF_SIZE, IOT_CLI_MID);
    IOT_ASSERT(pkt);

    query = (iot_cli_sg_upgrade_progress_dl *)iot_pkt_reserve(pkt,
        iot_cli_sg_get_headroom_req());
    iot_cli_sg_prep_msg(pkt, IOT_CLI_SG_MSG_QUERY_UPGRADE_PROGRESS, req_id);
    iot_pkt_put(pkt, sizeof(iot_cli_sg_upgrade_progress_dl));

    query->start_index = start_index;
    query->dst_num = dst_num;

    host_config->cli_sg_interface->recv(NULL, pkt);
}

void iot_sg_cli_set_tsfm_detect_state(uint8_t req_id,
    iot_cli_sg_set_tsfm_detect_state_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_TSFM_DETECT_STATE,
        (uint8_t *)data, sizeof(iot_cli_sg_set_tsfm_detect_state_t));
}

void iot_sg_cli_query_tsfm_detect_state(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id,
        IOT_CLI_SG_MSG_QUERY_TSFM_DETECT_STATE, NULL, 0);
}

void iot_sg_cli_set_con_mr_param(uint8_t req_id,
    iot_cli_sg_con_mr_param_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_CON_MR_PARAM,
        (uint8_t *)data, sizeof(iot_cli_sg_con_mr_param_t));
}

void iot_sg_cli_query_con_mr_param(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_CON_MR_PARAM, NULL, 0);
}

void iot_sg_cli_plc_mgr_state_change(uint8_t req_id,
    iot_cli_sg_plc_mgr_state_change_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_PLC_MGR_STATE_CHANGE,
        (uint8_t *)data, sizeof(iot_cli_sg_plc_mgr_state_change_t));
}

void iot_sg_cli_bd_start(uint8_t req_id, iot_cli_sg_bd_start_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_BD_START, (uint8_t *)data,
        sizeof(iot_cli_sg_bd_start_t));
}

void iot_sg_cli_bd_query_state(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_BD_QUERY_STATE, NULL, 0);
}

void iot_sg_cli_bd_query_ret(uint8_t req_id, iot_cli_sg_bd_query_ret_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_BD_QUERY_RESULT, (uint8_t *)data,
        sizeof(iot_cli_sg_bd_query_ret_t));
}

void iot_cli_sg_set_esp(uint8_t req_id, iot_cli_sg_set_esp_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_ESP, (uint8_t *)data,
        sizeof(iot_cli_sg_set_esp_t));
}

void iot_cli_sg_query_esp(uint8_t req_id)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_ESP, NULL, 0);
}

void iot_cli_sg_query_node_info(uint8_t req_id,
    iot_cli_sg_qr_node_info_dl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_QUERY_NODE_INFO,
        (uint8_t *)data, sizeof(iot_cli_sg_qr_node_info_dl_t));
}

void iot_cli_sg_send_broadcast_data(uint8_t req_id,
    iot_cli_sg_send_broadcast_data_dl *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SEND_BROADCAST_DATA,
        (uint8_t *)data, sizeof(*data) + data->len);
}

void iot_cli_sg_handle_msg(iot_pkt_t *pkt)
{
    iot_cli_sg_msg_header_t *hdr =
        (iot_cli_sg_msg_header_t*)iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_HEAD);
    uint8_t *data = iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_DATA);
    uint32_t msg_id = CLI_MSGID_GETMETERLIST_RESP;
    uint8_t *cli_src_mac = NULL;
    cli_app_cmd_mapping_item *cmd = NULL;

    IOT_ASSERT(hdr);
#if IOT_CLI_SUPPORT_WL_CMD
    if (iot_cli_sg_handle_wl_msg(hdr, data)) {
        iot_pkt_free(pkt);
        return;
    }
#endif /* IOT_CLI_SUPPORT_WL_CMD */
    if ((IOT_CLI_SG_MSG_PRT_METER_DATA == hdr->msg_id) ||
        (IOT_CLI_SG_MSG_PRT_RT_REQ_MR_DATA == hdr->msg_id) ||
        (IOT_CLI_SG_MSG_PRT_SEARCH_METER_LIST == hdr->msg_id)) {
        cmd = get_cmd_from_mapping_table(host_config->cli_request_id);
    } else if (hdr->req_id) {
        cmd = get_cmd_from_mapping_table(hdr->req_id);
    }

    if (cmd) {
        cli_src_mac = cmd->mac;
        iot_printf("plc_sg_handle_mac_mapping msg=%d, index=%d\n", \
            hdr->msg_id, hdr->req_id);
    }

    switch (hdr->msg_id) {
    case IOT_CLI_SG_MSG_RPT_CONFIG_INFO:
    {
        iot_cli_sg_config_t *rpt = (iot_cli_sg_config_t *)data;
        host_config->proto = rpt->proto;
        break;
    }
    case IOT_CLI_SG_MSG_PRT_METER:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: rsp mr data ack : %d \n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_GET_METER_DATA_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_PRT_METER_DATA:
    {
        iot_cli_sg_rpt_mr_data_ul *rsp = (iot_cli_sg_rpt_mr_data_ul *)data;
        iot_printf("%s: start report mr data ,proto %d len %lu\n", __FUNCTION__,
            rsp->proto_type, rsp->datalen);
        cli_ul_send_with_retry(CLI_MSGID_GET_METER_DATA_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_mr_data_ul) + rsp->datalen, cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_PRT_RT_REQ_MR_DATA:
    {
        iot_cli_request_rt_mr_data_ul *req =
            (iot_cli_request_rt_mr_data_ul *)data;
        iot_printf("%s: rt request meter reading ,opt_flag %d MAC: \
            mac: %02X:%02X:%02X:%02X:%02X:%02X\n", __FUNCTION__, req->opt_flag,
            req->mac_addr[0], req->mac_addr[1], req->mac_addr[2],
            req->mac_addr[3], req->mac_addr[4], req->mac_addr[5]);
        iot_cli_send_to_host(CLI_MSGID_GET_METER_RT_DATA_REQ, (uint8_t*)req,
            sizeof(iot_cli_request_rt_mr_data_ul), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_START_METER_LIST:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: start get meter list result: %lu\n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_START_SEARCH_METER_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_STOP_METER_LIST:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: stop get meter list result: %lu\n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_STOP_SEARCH_METER_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_PRT_SEARCH_METER_LIST:
    {
        /* fall to next case by design. */
        msg_id = CLI_MSGID_SEARCH_MERLIST_RESP;
    }
    case IOT_CLI_SG_MSG_RPT_METER_LIST:
    {
        iot_cli_sg_rpt_sec_node_info_ul_t *rsp =
            (iot_cli_sg_rpt_sec_node_info_ul_t *)data;

        iot_printf("%s: total node: %d, transfer node: %d\n", __FUNCTION__,
            rsp->sec_node_count, rsp->rsp_sec_node_count);
        for (uint32_t i = 0; i < rsp->rsp_sec_node_count; ++i) {
            iot_printf("meter mac=[%02X:%02X:%02X:%02X:%02X:%02X], \
                sta mac=[%02X:%02X:%02X:%02X:%02X:%02X]\n",
                rsp->node_info[i].meter_mac[0], rsp->node_info[i].meter_mac[1],
                rsp->node_info[i].meter_mac[2], rsp->node_info[i].meter_mac[3],
                rsp->node_info[i].meter_mac[4], rsp->node_info[i].meter_mac[5],
                rsp->node_info[i].sta_mac[0], rsp->node_info[i].sta_mac[1],
                rsp->node_info[i].sta_mac[2], rsp->node_info[i].sta_mac[3],
                rsp->node_info[i].sta_mac[4], rsp->node_info[i].sta_mac[5]);
        }

        iot_cli_send_to_host(msg_id, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_sec_node_info_ul_t) +
            (sizeof(rsp->node_info[0]) * rsp->rsp_sec_node_count), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SEARCH_METER_DONE:
    {
        iot_cli_send_to_host(CLI_MSGID_METERLIST_DATA_DONE_RESP, NULL, 0, cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_PRT_UPGRADE_STATUS:
    {
        iot_plc_upgrade_dst_status_query *req =
            (iot_plc_upgrade_dst_status_query *)data;
        iot_plc_upgrade_dst_status_query_ul requl;
        os_mem_cpy(&(requl.query), req, sizeof(*req));
        iot_cli_send_to_host(CLI_MSGID_UPGRADE_DST_STATUS_QUERY_ACK,
            (uint8_t*)&requl, sizeof(iot_plc_upgrade_dst_status_query_ul),
            cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_PRT_UPGRADE_PROGRESS:
    {
        iot_plc_upgrade_dst_status_list *req =
            (iot_plc_upgrade_dst_status_list *)data;
        iot_plc_upgrade_dst_status_list_ul requl;
        os_mem_cpy(&(requl.status_list), req, sizeof(*req));
        iot_cli_send_to_host(CLI_MSGID_UPGRADE_DST_STATUS_LIST_ACK,
            (uint8_t*)&requl, sizeof(iot_plc_upgrade_dst_status_list_ul),
            cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_EVT_DATA:
    {
        iot_cli_sg_rpt_evt_data_t *rsp = (iot_cli_sg_rpt_evt_data_t *)data;
        iot_printf("%s: report event data.\n", __FUNCTION__);

        iot_cli_send_to_host(CLI_MSGID_RPT_EVENT_DATA, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_evt_data_t) + rsp->data_len, cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SET_TSFM_DETECT_STATE:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: set tsfm detect state is %lu.\n",
            __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SET_TSFM_DETECT_STATE_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_TSFM_DETECT_STATE:
    {
        iot_cli_sg_rpt_tsfm_detect_state_t *rsp =
            (iot_cli_sg_rpt_tsfm_detect_state_t *)data;
        iot_printf("%s: query tsfm detect state: %lu, sta lock: %lu, "
            "tsfm detect progress: %lu\n", __FUNCTION__, rsp->tsfm_detect_state,
            rsp->sta_lock, rsp->tsfm_detect_progress);
        iot_cli_send_to_host(CLI_MSGID_QUERY_TSFM_DETECT_STATE_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_tsfm_detect_state_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_USER_DATA:
    {
        iot_cli_sg_send_user_data_t *rsp = (iot_cli_sg_send_user_data_t *)data;

        iot_cli_send_to_host(CLI_MSGID_USER_DATA, (uint8_t*)rsp,
            sizeof(iot_cli_sg_send_user_data_t) + rsp->data_len,
            rsp->target_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SET_EVENT_RPT_ENABLED:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: set event enabled result: %lu\n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SET_EVENT_RPT_ENABLED_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SET_CCTT_DATA_ENABLED:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: set enable cctt data result: %lu\n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SET_CCTT_DATA_ENABLED_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SET_CON_MR_PARAM:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: set con mr param is %lu.\n", __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSG_SET_CON_MR_PARAM_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_QUERY_CON_MR_PARAM:
    {
        iot_cli_sg_con_mr_param_t *rsp = (iot_cli_sg_con_mr_param_t *)data;
        iot_printf("%s: query con mr param, sec_node_monitor_timeout: %lu, "
            "max_bcast_con_count: %lu\n", __FUNCTION__,
            rsp->sec_node_monitor_timeout, rsp->max_bcast_con_count);
        iot_cli_send_to_host(CLI_MSG_QUERY_CON_MR_PARAM_RESP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_con_mr_param_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_BD_START:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: bd start %lu.\n", __FUNCTION__, rsp->result);
        iot_cli_send_to_host(CLI_MSGID_BD_START_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_BD_QUERY_STATE:
    {
        iot_cli_sg_bd_rpt_state_t *rsp = (iot_cli_sg_bd_rpt_state_t *)data;
        iot_printf("%s: bd state: %lu\n", __FUNCTION__, rsp->state);
        iot_cli_send_to_host(CLI_MSGID_BD_QUERY_STATE_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_bd_rpt_state_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_BD_QUERY_RESULT:
    {
        iot_cli_sg_bd_ret_rpt_t *rsp = (iot_cli_sg_bd_ret_rpt_t *)data;
        iot_printf("%s: bd result total_cnt: %lu, start_index: %lu, "
            "rpt_cnt: %lu\n", __FUNCTION__, rsp->total_cnt, rsp->start_index,
            rsp->rpt_cnt);
        iot_cli_send_to_host(CLI_MSGID_BD_QUERY_RET_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_bd_ret_rpt_t) +
            (rsp->rpt_cnt * sizeof(rsp->node_info[0])), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_ESP_RESULT:
    {
        iot_cli_sg_rpt_esp_t *rsp = (iot_cli_sg_rpt_esp_t *)data;
        iot_printf("%s: rpt cco esp %lu\n", __FUNCTION__, rsp->esp);
        iot_cli_send_to_host(CLI_MSGID_SET_ESP_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_rpt_esp_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_NODE_INFO:
    {
        iot_cli_sg_qr_node_info_ul_t *rsp =
            (iot_cli_sg_qr_node_info_ul_t *)data;
        iot_printf("%s: totoal_cnt %lu, start_index %lu, count %lu\n",
            __FUNCTION__, rsp->total_cnt, rsp->start_index, rsp->rpt_cnt);
        iot_cli_send_to_host(CLI_MSGID_NODE_INFO_RSP, (uint8_t*)rsp,
            sizeof(*rsp) + (rsp->rpt_cnt * sizeof(*rsp->node_info)),
            cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_SEND_BROADCAST_DATA:
    {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: send broadcast data result %lu.\n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SEND_BROADCAST_RSP, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
        break;
    }
    case IOT_CLI_SG_MSG_RPT_LOCAL_PROTO_DATA:
    {
        iot_cli_sg_resp_local_proto_data_ul_t *rsp =
            (iot_cli_sg_resp_local_proto_data_ul_t*)data;

        iot_printf("%s: send response data to cli, dataLen:%d\n", __FUNCTION__,
            rsp->date_len);
        iot_cli_send_to_host(CLI_MSGID_TRANS_USER_LOCAL_PROTO_DATA_RESP,
            (uint8_t *)rsp,
            sizeof(iot_cli_sg_resp_local_proto_data_ul_t) + rsp->date_len,
            cli_src_mac);
        break;
    }
    default:
        IOT_ASSERT(0);
        break;
    }
    iot_pkt_free(pkt);
}

void iot_cli_sg_set_event_rpt_enabled(uint8_t req_id,
    iot_cli_sg_set_event_enabled_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_EVENT_RPT_ENABLED,
        (uint8_t *)data, sizeof(*data));
}

void iot_cli_sg_set_cctt_data_enabled(uint8_t req_id,
    iot_cli_sg_set_cctt_data_enabled_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_MSG_SET_CCTT_DATA_ENABLED,
        (uint8_t *)data, sizeof(*data));
}

void iot_cli_sg_trans_local_proto_data(uint8_t req_id,
    iot_cli_sg_trans_local_proto_data_dl_t *data)
{
    iot_sg_cli_send_cmd(req_id, IOT_CLI_SG_TRANS_LOCAL_PROTO_DATA, data->data,
        data->data_len);
}

#elif ((IOT_STA_CONTROL_MODE == IOT_STA_CONTROL_TYPE_STA) && \
    (IOT_SG_CONTROLLER_ENABLE == 1))

void iot_cli_sg_handle_msg(iot_pkt_t *pkt)
{
    iot_cli_sg_msg_header_t *hdr =
        (iot_cli_sg_msg_header_t*)iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_HEAD);
    uint8_t cli_src_mac[6] = { 0 };

    IOT_ASSERT(hdr);

    iot_printf("%s: msg id : %lu \n", __FUNCTION__, hdr->msg_id);
    switch (hdr->msg_id) {
    case IOT_CLI_SG_CTRL_MSG_RPT_IS_READY:
    {
        iot_cli_sg_ctrl_is_ready_t *rsp;
        rsp = (iot_cli_sg_ctrl_is_ready_t *)iot_pkt_block_ptr(pkt,
            IOT_PKT_BLOCK_DATA);
        iot_printf("%s: ctrl is ready : %lu \n", __FUNCTION__, rsp->ready);
        if (rsp->ready) {
            iot_cli_host_set_ctrl_connected(1);
        } else {
            iot_cli_host_set_ctrl_connected(0);
        }
        break;
    }
    case IOT_CLI_SG_CTRL_MSG_RPT_DATA_UL:
    {
        iot_cli_sg_ctrl_data_ul_t *rsp;
        rsp = (iot_cli_sg_ctrl_data_ul_t *)iot_pkt_block_ptr(pkt,
            IOT_PKT_BLOCK_DATA);
        iot_cli_send_to_host(CLI_MSGID_CTRL_DATA_UL, (uint8_t *)rsp,
            sizeof(*rsp) + rsp->data_len, cli_src_mac);
        break;
    }
    default:
        IOT_ASSERT(0);
        break;
    }

    iot_pkt_free(pkt);
}

#elif IOT_SMART_CONFIG

void iot_cli_sg_handle_msg(iot_pkt_t *pkt)
{
    iot_cli_sg_msg_header_t *hdr =
        (iot_cli_sg_msg_header_t*)iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_HEAD);
    uint8_t *data = iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_DATA);
    cli_app_cmd_mapping_item *cmd = NULL;
    uint8_t *cli_src_mac = NULL;

    IOT_ASSERT(hdr);
#if IOT_CLI_SUPPORT_WL_CMD
    if (iot_cli_sg_handle_wl_msg(hdr, data)) {
        iot_pkt_free(pkt);
        return;
    }
#endif /* IOT_CLI_SUPPORT_WL_CMD */

    if (hdr->req_id) {
        cmd = get_cmd_from_mapping_table(hdr->req_id);
    }
    if (cmd) {
        cli_src_mac = cmd->mac;
        iot_printf("plc_sg_handle_mac_mapping msg=%d, index=%d\n", \
            hdr->msg_id, hdr->req_id);
    }
    if (hdr->msg_id == IOT_CLI_SG_MSG_RPT_MAC) {
        iot_cli_sg_result_t *rsp = (iot_cli_sg_result_t *)data;
        iot_printf("%s: rsp set mac ack : %d \n", __FUNCTION__,
            rsp->result);
        iot_cli_send_to_host(CLI_MSGID_SET_MAC_ACK, (uint8_t*)rsp,
            sizeof(iot_cli_sg_result_t), cli_src_mac);
    }
    iot_pkt_free(pkt);
}

#endif /* PLC_SUPPORT_CCO_ROLE */

#endif /* IOT_CLI_SG_INTERFACE_ENABLE */