meshx_light_cwww_client.c

Go to the documentation of this file.

#include "meshx_common.h"
#include "meshx_control_task.h"
#include "meshx_nvs.h"
#include "meshx_api.h"
 
#if CONFIG_LIGHT_CWWW_CLIENT_COUNT > 0
#include "meshx_light_cwww_client_element.h"
 
#if CONFIG_ENABLE_CONFIG_SERVER
#include "meshx_config_server.h"

#define CONFIG_SERVER_CB_MASK        \
        CONTROL_TASK_MSG_EVT_PUB_ADD \
    |   CONTROL_TASK_MSG_EVT_SUB_ADD \
    |   CONTROL_TASK_MSG_EVT_APP_KEY_BIND
#endif /* CONFIG_ENABLE_CONFIG_SERVER */

#if defined(__MESHX_CONTROL_TASK__)
#define CONTROL_TASK_MSG_CODE_EVT_MASK          \
        CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF  \
    |   CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL
#endif /* __MESHX_CONTROL_TASK__ */
 
#define MOD_LCC                             MODULE_ID_ELEMENT_LIGHT_CWWWW_CLIENT
#define CWWW_CLI_MESHX_ONOFF_ENABLE_CB      true
#define CWWW_CLI_EL_STATE_CH_EVT_MASK       CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF | CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL
 
#define IS_EL_IN_RANGE(_element_id)         ((_element_id) >= cwww_client_element_init_ctrl.element_id_start && (_element_id) < cwww_client_element_init_ctrl.element_id_end)
#define GET_RELATIVE_EL_IDX(_element_id)    ((_element_id) - cwww_client_element_init_ctrl.element_id_start)
#define CWWW_CLI_EL(_el_id)                 cwww_client_element_init_ctrl.el_list[_el_id]
 
static meshx_cwww_client_elements_ctrl_t cwww_client_element_init_ctrl;
 
#if CWWW_CLI_MESHX_ONOFF_ENABLE_CB
 
static meshx_err_t meshx_cwww_cli_send_onoff_msg( const dev_struct_t *pdev, uint16_t element_id, uint8_t set_get, uint8_t ack);
static meshx_err_t meshx_cwww_cli_send_ctl_msg( const dev_struct_t *pdev, uint16_t element_id, uint8_t set_get, uint8_t is_temp_range, uint8_t ack);
static meshx_err_t cwww_client_on_off_state_change_handler(
    const meshx_on_off_cli_el_msg_t *param)
{
    uint16_t element_id = param->model.el_id;
 
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_cwww_client_model_ctx_t *el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
    meshx_api_light_cwww_client_evt_t app_notify;
    meshx_err_t err = MESHX_SUCCESS;
    err = meshx_gen_on_off_state_change_handle(param, &el_ctx->prev_state, &el_ctx->state);
    if(err == MESHX_SUCCESS)
    {
        app_notify.err_code = param->err_code;
        app_notify.state_change.on_off.state = el_ctx->prev_state.on_off;
 
        err = meshx_send_msg_to_app(element_id,
                                    MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT,
                                    MESHX_ELEMENT_FUNC_ID_LIGHT_CWWW_CLIENT_ONN_OFF,
                                    sizeof(meshx_api_light_cwww_client_evt_t),
                                    &app_notify);
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_LCC, "Failed to send CWWW state change message: (%d)", err);
        }
    }
    return err;
}

 
static meshx_err_t cwww_light_ctl_state_change_handler(
    const meshx_ctl_cli_el_msg_t *param)
{
    uint16_t element_id = param->model.el_id;
 
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_cwww_client_model_ctx_t *el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
    meshx_api_light_cwww_client_evt_t app_notify;
    meshx_err_t err = MESHX_SUCCESS;
 
    if(param->err_code == MESHX_SUCCESS)
    {
        CWWW_CLI_EL(rel_el_id).element_model_init |= MESHX_BIT(CWWW_CLI_SIG_L_CTL_MODEL_ID);
 
        err = meshx_light_ctl_state_change_handle(param, &el_ctx->prev_ctl_state, &el_ctx->ctl_state);
        if (err == MESHX_SUCCESS)
        {
            MESHX_LOGD(MOD_LCC, "PUBLISH: light|temp : %d|%d",
                     el_ctx->prev_ctl_state.lightness,
                     el_ctx->prev_ctl_state.temperature);
 
            app_notify.err_code = param->err_code;
            if(param->err_code == MESHX_SUCCESS)
            {
                app_notify.state_change.ctl.delta_uv        = el_ctx->prev_ctl_state.delta_uv;
                app_notify.state_change.ctl.lightness       = el_ctx->prev_ctl_state.lightness;
                app_notify.state_change.ctl.temperature     = el_ctx->prev_ctl_state.temperature;
                app_notify.state_change.ctl.temp_range_max  = el_ctx->prev_ctl_state.temp_range_max;
                app_notify.state_change.ctl.temp_range_min  = el_ctx->prev_ctl_state.temp_range_min;
            }
 
            err = meshx_send_msg_to_app(element_id,
                                        MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT,
                                        MESHX_ELEMENT_FUNC_ID_LIGHT_CWWW_CLIENT_CTL,
                                        sizeof(meshx_api_light_cwww_client_evt_t),
                                        &app_notify);
            if (err != MESHX_SUCCESS)
            {
                MESHX_LOGE(MOD_LCC, "Failed to send CWWW state change message: (%d)", err);
            }
        }
    }
    return err;
}
 
static meshx_err_t meshx_cwww_client_element_state_change_handler(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_ptr_t params
)
{
    if (!pdev || !params)
    {
        return MESHX_INVALID_ARG;
    }
    meshx_err_t err = MESHX_SUCCESS;
    uint16_t element_id = ((const meshx_on_off_cli_el_msg_t *)params)->model.el_id;
    if (!IS_EL_IN_RANGE(element_id))
    {
        return MESHX_SUCCESS;
    }
    switch (evt)
            {
        case CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF:
            err = cwww_client_on_off_state_change_handler(
                (meshx_on_off_cli_el_msg_t *)params);
            break;
        case CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL:
            err = cwww_light_ctl_state_change_handler(
                (meshx_ctl_cli_el_msg_t *)params);
            break;
        default:
            err = MESHX_FAIL;
    }
    if(err == MESHX_SUCCESS)
    {
        err = meshx_nvs_element_ctx_set(element_id, CWWW_CLI_EL(GET_RELATIVE_EL_IDX(element_id)).cwww_cli_ctx, sizeof(meshx_cwww_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_LCC, "Failed to set cwww client element context: (%d)", err);
        }
    }
    return err;
}
 
#if CONFIG_ENABLE_CONFIG_SERVER
static meshx_err_t cwww_client_config_srv_cb (
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_config_srv_cb_param_t *params)
{
    MESHX_UNUSED(pdev);
    meshx_cwww_client_model_ctx_t *el_ctx = NULL;
    size_t rel_el_id = 0;
    uint16_t element_id = 0;
    uint16_t base_el_id = 0;
    bool nvs_save = false;
    meshx_get_base_element_id(&base_el_id);
 
    switch (evt)
    {
    case CONTROL_TASK_MSG_EVT_APP_KEY_BIND:
        element_id = params->state_change.mod_app_bind.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
        el_ctx->app_id = params->state_change.appkey_add.app_idx;
        nvs_save = true;
        break;
    case CONTROL_TASK_MSG_EVT_PUB_ADD:
    case CONTROL_TASK_MSG_EVT_PUB_DEL:
        element_id = params->state_change.mod_pub_set.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
        el_ctx->pub_addr = evt == CONTROL_TASK_MSG_EVT_PUB_ADD ? params->state_change.mod_pub_set.pub_addr
                                                           : MESHX_ADDR_UNASSIGNED;
        el_ctx->app_id = params->state_change.mod_pub_set.app_idx;
        nvs_save = true;
        MESHX_LOGI(MOD_LCC, "PUB_ADD: %d, %d, 0x%X, 0x%X", element_id, rel_el_id, el_ctx->pub_addr, el_ctx->app_id);
        break;
    default:
        break;
    }
    if (nvs_save)
    {
        meshx_err_t err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_cwww_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_LCC, "Failed to set cwww client element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
 
#if defined(__MESHX_CONTROL_TASK__)

static meshx_err_t cwww_cli_prov_srv_msg_handle(const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
{
    if(!pdev)
        return MESHX_INVALID_ARG;
 
    MESHX_UNUSED(params);
    meshx_err_t err = MESHX_SUCCESS;
 
    if (evt == CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT)
    {
        for(uint16_t i = cwww_client_element_init_ctrl.element_id_start; i < cwww_client_element_init_ctrl.element_id_end; i++)
        {
            err = meshx_cwww_el_get_state(i, CWWW_CLI_SIG_ID_MAX);
        }
    }
    else
    {
        MESHX_LOGW(MOD_LCC, "Unhandled event: %d", evt);
    }
    return err;
}

static meshx_err_t meshx_cwww_cli_send_onoff_msg(
    const dev_struct_t *pdev,
    uint16_t element_id,
    uint8_t set_get,
    uint8_t ack)
{
    if (!pdev || !IS_EL_IN_RANGE(element_id))
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_onoff_client_model_t *model = CWWW_CLI_EL(rel_el_id).onoff_cli_model;
 
    meshx_cwww_client_model_ctx_t *el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
    uint16_t opcode = MESHX_MODEL_OP_GEN_ONOFF_GET;
 
    if (MESHX_GEN_ON_OFF_CLI_MSG_SET == set_get)
    {
        opcode = ack ? MESHX_MODEL_OP_GEN_ONOFF_SET : MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK;
    }
 
    MESHX_LOGD(MOD_LCC, "OPCODE: %p", (void *)(uint32_t)opcode);
 
    meshx_gen_onoff_send_params_t params = {
        .element_id = element_id,
        .model      = model,
        .opcode     = opcode,
        .addr       = el_ctx->pub_addr,
        .net_idx    = pdev->meshx_store.net_key_id,
        .app_idx    = el_ctx->app_id,
        .state      = el_ctx->state.on_off,
        .tid        = el_ctx->tid
    };
    /* Send message to the relay client */
    err = meshx_onoff_client_send_msg(&params);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "Cwww Client Send Message failed: (%d)", err);
    }
    else
    {
        el_ctx->tid++;
        if(opcode == MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK)
        {
            el_ctx->prev_state.on_off = el_ctx->state.on_off;
            el_ctx->state.on_off = !el_ctx->state.on_off;
        }
    }
    return err;
}

static meshx_err_t meshx_cwww_cli_send_ctl_msg(
    const dev_struct_t *pdev,
    uint16_t element_id,
    uint8_t set_get,
    uint8_t is_temp_range,
    uint8_t ack)
{
    if (!pdev || !IS_EL_IN_RANGE(element_id))
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_cwww_client_model_ctx_t *el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
    meshx_light_ctl_client_model_t *model = CWWW_CLI_EL(rel_el_id).ctl_cli_model;
 
    meshx_gen_ctl_send_params_t params = {
        .model      = model,
        .opcode     = MESHX_MODEL_OP_LIGHT_CTL_GET,
        .element_id = element_id,
        .tid        = el_ctx->tid,
        .app_idx    = el_ctx->app_id,
        .addr       = el_ctx->pub_addr,
        .net_idx    = pdev->meshx_store.net_key_id,
    };
 
    if(is_temp_range == false)
    {
        if( MESHX_LIGHT_CTL_CLI_MSG_SET == set_get)
        {
            params.opcode = ack ? MESHX_MODEL_OP_LIGHT_CTL_SET : MESHX_MODEL_OP_LIGHT_CTL_SET_UNACK;
        }
 
        MESHX_LOGD(MOD_LCC, "OPCODE: %p", (void *)(uint32_t)params.opcode);
 
        params.delta_uv = el_ctx->ctl_state.delta_uv;
        params.lightness = el_ctx->ctl_state.lightness;
        params.temperature = el_ctx->ctl_state.temperature;
 
        /* Send message to the cwww client */
        err = meshx_light_ctl_client_send_msg(&params);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Cwww Client Send Message failed: (%d)", err);
        }
        else
        {
            el_ctx->tid++;
            if(params.opcode == MESHX_MODEL_OP_LIGHT_CTL_SET_UNACK)
            {
                el_ctx->prev_ctl_state.delta_uv = el_ctx->ctl_state.delta_uv;
                el_ctx->prev_ctl_state.lightness = el_ctx->ctl_state.lightness;
                el_ctx->prev_ctl_state.temperature = el_ctx->ctl_state.temperature;
            }
        }
    }
    else
    {
        params.opcode = MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_GET;
        /* If set operation, change opcode accordingly */
        if( MESHX_LIGHT_CTL_CLI_MSG_SET == set_get)
        {
            params.opcode = ack ? MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET : MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET_UNACK;
        }
 
        MESHX_LOGD(MOD_LCC, "OPCODE: %p", (void *)(uint32_t)params.opcode);
 
        params.temp_range_max = el_ctx->ctl_state.temp_range_max;
        params.temp_range_min = el_ctx->ctl_state.temp_range_min;
 
        /* Send message to the cwww client */
        err = meshx_light_ctl_temp_range_client_send_msg(&params);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Cwww Client Send Message failed: (%d)", err);
        }
        else
        {
            if(params.opcode == MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET_UNACK)
            {
                el_ctx->prev_ctl_state.temp_range_max = el_ctx->ctl_state.temp_range_max;
                el_ctx->prev_ctl_state.temp_range_min = el_ctx->ctl_state.temp_range_min;
            }
        }
    }
    return err;
}

static meshx_err_t meshx_cwww_client_element_to_ble_handler(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const void *params)
{
    if (!pdev || !params)
        return MESHX_INVALID_ARG;
    MESHX_UNUSED(pdev);
    bool is_temp_range = false;
    meshx_err_t err = MESHX_SUCCESS;
    const meshx_cwww_client_msg_t *msg = (const meshx_cwww_client_msg_t *)params;
    MESHX_LOGD(MOD_LCC, "EVT: %p, el_id: %d, set_get: %d, ack: %d",
               (void *)evt, msg->element_id, msg->set_get, msg->ack);
 
    if (!IS_EL_IN_RANGE(msg->element_id))
    {
        return MESHX_INVALID_ARG;
    }
    if (CWWW_CLI_EL(GET_RELATIVE_EL_IDX(msg->element_id)).cwww_cli_ctx->pub_addr == MESHX_ADDR_UNASSIGNED)
    {
        MESHX_LOGW(MOD_LCC, "No publish address set for element: %d", msg->element_id);
        return MESHX_INVALID_STATE;
    }
    if(evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF)
    {
        err = meshx_cwww_cli_send_onoff_msg(
                pdev,
                msg->element_id,
                msg->set_get,
                msg->ack
            );
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_LCC, "CWWW Client Control Task: Set OnOff failed (%p)", (void *)err);
            return err;
        }
    }
    else if(evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL)
    {
        size_t rel_el_id = msg->element_id - cwww_client_element_init_ctrl.element_id_start;
        meshx_cwww_client_model_ctx_t *el_ctx = CWWW_CLI_EL(rel_el_id).cwww_cli_ctx;
        /* Set new context value as per msg sent */
        el_ctx->ctl_state.delta_uv       = (msg->arg_bmap & CWWW_ARG_BMAP_DELTA_UV_SET) ? msg->delta_uv : el_ctx->ctl_state.delta_uv;
        el_ctx->ctl_state.lightness      = (msg->arg_bmap & CWWW_ARG_BMAP_LIGHTNESS_SET) ? msg->lightness : el_ctx->ctl_state.lightness;
        el_ctx->ctl_state.temperature    = (msg->arg_bmap & CWWW_ARG_BMAP_TEMPERATURE_SET) ? msg->temperature : el_ctx->ctl_state.temperature;
        el_ctx->ctl_state.temp_range_max = (msg->arg_bmap & CWWW_ARG_BMAP_TEMPERATURE_RANGE_SET_MAX) ? msg->temp_range_max : el_ctx->ctl_state.temp_range_max;
        el_ctx->ctl_state.temp_range_min = (msg->arg_bmap & CWWW_ARG_BMAP_TEMPERATURE_RANGE_SET_MIN) ? msg->temp_range_min : el_ctx->ctl_state.temp_range_min;
        is_temp_range                    = (msg->arg_bmap & CWWW_ARG_BMAP_TEMPERATURE_RANGE_SET_MAX) || (msg->arg_bmap & CWWW_ARG_BMAP_TEMPERATURE_RANGE_SET_MIN);
        err = meshx_cwww_cli_send_ctl_msg(
                pdev,
                msg->element_id,
                msg->set_get,
                is_temp_range,
                msg->ack
            );
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_LCC, "CWWW Client Control Task: Set CTL failed (%p)", (void *)err);
            return err;
        }
    }
    return err;
}
#endif /* __MESHX_CONTROL_TASK__ */
 
#if CONFIG_ENABLE_UNIT_TEST

typedef enum cwww_cli_cmd
{
    /* ONOFF UT COMMANDS */
    CWWW_CLI_UT_CMD_ONOFF_GET = 0,
    CWWW_CLI_UT_CMD_ONOFF_SET,
    CWWW_CLI_UT_CMD_ONOFF_SET_UNACK,
    /* CTL UT COMMANDS */
    CWWW_CLI_UT_CMD_CTL_GET,
    CWWW_CLI_UT_CMD_CTL_SET,
    CWWW_CLI_UT_CMD_CTL_SET_UNACK,
    CWWW_CLI_UT_CMD_LIGHTNESS_SET,
    CWWW_CLI_UT_CMD_LIGHTNESS_SET_UNACK,
    CWWW_CLI_UT_CMD_TEMPERATURE_SET,
    CWWW_CLI_UT_CMD_TEMPERATURE_SET_UNACK,
    CWWW_CLI_UT_CMD_DELTA_UV_SET,
    CWWW_CLI_UT_CMD_DELTA_UV_SET_UNACK,
    CWWW_CLI_UT_CMD_TEMPERATURE_RANGE_SET,
    CWWW_CLI_UT_CMD_TEMPERATURE_RANGE_SET_UNACK,
    CWWW_CLI_MAX_CMD
} cwww_cli_cmd_t;

static meshx_err_t cwww_cli_unit_test_cb_handler(int cmd_id, int argc, char **argv)
{
    meshx_err_t err = MESHX_SUCCESS;
    meshx_cwww_client_msg_t msg = {0};
    msg.element_id = UT_GET_ARG(0, uint16_t, argv);
    cwww_cli_cmd_t cmd = (cwww_cli_cmd_t)cmd_id;
 
    MESHX_LOGD(MOD_LCC, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (argc < 1 || cmd_id >= CWWW_CLI_MAX_CMD)
    {
        MESHX_LOGE(MOD_LCC, "CWW Client Unit Test: Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    control_task_msg_evt_to_ble_t msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_MAX;
    switch (cmd)
    {
    case CWWW_CLI_UT_CMD_ONOFF_GET:
        /* ut 1 0 1 <el_id> */
        msg.ack = CWWW_CLI_MSG_ACK;
        msg.set_get = CWWW_CLI_MSG_GET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF;
        break;
    case CWWW_CLI_UT_CMD_ONOFF_SET:
        /* ut 1 1 1 <el_id> */
    case CWWW_CLI_UT_CMD_ONOFF_SET_UNACK:
        /* ut 1 2 1 <el_id> */
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_ONOFF_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF;
        msg.ack = cmd == CWWW_CLI_UT_CMD_ONOFF_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    case CWWW_CLI_UT_CMD_CTL_GET:
        /* ut 1 3 1 <el_id> */
        msg.ack = CWWW_CLI_MSG_NO_ACK;
        msg.set_get = CWWW_CLI_MSG_GET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        break;
    case CWWW_CLI_UT_CMD_CTL_SET:
        /* ut 1 4 4 <el_id> <temp> <light> <delta_uv> */
    case CWWW_CLI_UT_CMD_CTL_SET_UNACK:
        /* ut 1 5 4 <el_id> <temp> <light> <delta_uv> */
        if (argc >= 2)
            msg.temperature = UT_GET_ARG(1, uint16_t, argv);
        if (argc >= 3)
            msg.lightness = UT_GET_ARG(2, uint16_t, argv);
        if (argc >= 4)
            msg.delta_uv = UT_GET_ARG(3, uint16_t, argv);
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_CTL_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        msg.ack = cmd == CWWW_CLI_UT_CMD_CTL_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    case CWWW_CLI_UT_CMD_LIGHTNESS_SET:
        /* ut 1 6 2 <el_id> <light> */
    case CWWW_CLI_UT_CMD_LIGHTNESS_SET_UNACK:
        /* ut 1 7 2 <el_id> <light> */
        if (argc >= 2)
            msg.lightness = UT_GET_ARG(1, uint16_t, argv);
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_LIGHTNESS_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        msg.ack = cmd == CWWW_CLI_UT_CMD_LIGHTNESS_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    case CWWW_CLI_UT_CMD_TEMPERATURE_SET:
        /* ut 1 8 2 <el_id> <temp> */
    case CWWW_CLI_UT_CMD_TEMPERATURE_SET_UNACK:
        /* ut 1 9 2 <el_id> <temp> */
        if (argc >= 2)
            msg.temperature = UT_GET_ARG(1, uint16_t, argv);
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_TEMPERATURE_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        msg.ack = cmd == CWWW_CLI_UT_CMD_TEMPERATURE_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    case CWWW_CLI_UT_CMD_DELTA_UV_SET:
        /* ut 1 10 2 <el_id> <delta_uv> */
    case CWWW_CLI_UT_CMD_DELTA_UV_SET_UNACK:
        /* ut 1 11 2 <el_id> <delta_uv> */
        if (argc >= 2)
            msg.delta_uv = UT_GET_ARG(1, uint16_t, argv);
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_DELTA_UV_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        msg.ack = cmd == CWWW_CLI_UT_CMD_DELTA_UV_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    case CWWW_CLI_UT_CMD_TEMPERATURE_RANGE_SET:
        /* ut 1 12 3 <el_id> <min> <max> */
    case CWWW_CLI_UT_CMD_TEMPERATURE_RANGE_SET_UNACK:
        /* ut 1 13 3 <el_id> <min> <max> */
        if (argc >= 2)
            msg.temp_range_min = UT_GET_ARG(1, uint16_t, argv);
        if (argc >= 3)
            msg.temp_range_max = UT_GET_ARG(2, uint16_t, argv);
        msg.set_get = CWWW_CLI_MSG_SET;
        msg.arg_bmap = CWWW_ARG_BMAP_TEMPERATURE_RANGE_SET;
        msg_evt = CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL;
        msg.ack = cmd == CWWW_CLI_UT_CMD_TEMPERATURE_RANGE_SET ? CWWW_CLI_MSG_ACK : CWWW_CLI_MSG_NO_ACK;
        break;
    default:
        MESHX_LOGE(MOD_LCC, "CWWW Client Unit Test: Invalid command");
        return MESHX_INVALID_ARG;
    }
 
    err = control_task_msg_publish(CONTROL_TASK_MSG_CODE_TO_BLE, msg_evt, &msg, sizeof(msg));
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "CWWW Client Unit Test: Command %d failed", cmd);
    }
    return err;
}
 
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
#endif /* CWWW_CLI_MESHX_ONOFF_ENABLE_CB */

static meshx_err_t meshx_element_struct_init(uint16_t n_max)
{
    if(!n_max)
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    cwww_client_element_init_ctrl.element_cnt = n_max;
    cwww_client_element_init_ctrl.element_id_end = 0;
    cwww_client_element_init_ctrl.element_id_start = 0;
 
    cwww_client_element_init_ctrl.el_list =
        (meshx_cwww_client_elements_t *)MESHX_CALOC(cwww_client_element_init_ctrl.element_cnt, sizeof(meshx_cwww_client_elements_t));
    if (!cwww_client_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_LCC, "Failed to allocate memory for cwww client elements");
        return MESHX_NO_MEM;
    }
 
    for (size_t i = 0; i < cwww_client_element_init_ctrl.element_cnt; i++)
    {
        CWWW_CLI_EL(i).cwww_cli_ctx = (meshx_cwww_client_model_ctx_t *)MESHX_CALOC(n_max, sizeof(meshx_cwww_client_model_ctx_t));
        if (!CWWW_CLI_EL(i).cwww_cli_ctx)
        {
            MESHX_LOGE(MOD_LCC, "Failed to allocate memory for cwww client context");
            return MESHX_NO_MEM;
        }
        err = meshx_on_off_client_create(&CWWW_CLI_EL(i).onoff_cli_model,
                                         &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_ONOFF_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Meshx On Off Client create failed (Err : 0x%x)", err);
            return err;
        }
        CWWW_CLI_EL(i).onoff_cli_model->meshx_sig
            = &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_ONOFF_MODEL_ID];
 
        err = meshx_light_ctl_client_create(&CWWW_CLI_EL(i).ctl_cli_model,
                                            &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_L_CTL_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Meshx CTL Client create failed (Err : 0x%x)", err);
            return err;
        }
        CWWW_CLI_EL(i).ctl_cli_model->meshx_sig
            = &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_L_CTL_MODEL_ID];
    }
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_element_struct_deinit(uint16_t n_max)
{
    if (!cwww_client_element_init_ctrl.element_cnt || !cwww_client_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_LCC, "CWWW element list not initialized");
        return MESHX_INVALID_STATE;
    }
 
    if (cwww_client_element_init_ctrl.el_list)
    {
        for (size_t i = 0; i < n_max; i++)
        {
            if (CWWW_CLI_EL(i).cwww_cli_ctx)
            {
                MESHX_FREE(CWWW_CLI_EL(i).cwww_cli_ctx);
                CWWW_CLI_EL(i).cwww_cli_ctx = NULL;
            }
        }
        MESHX_FREE(cwww_client_element_init_ctrl.el_list);
        cwww_client_element_init_ctrl.el_list = NULL;
    }
    cwww_client_element_init_ctrl.element_cnt = 0;
    cwww_client_element_init_ctrl.element_id_end = 0;
    cwww_client_element_init_ctrl.element_id_start = 0;
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_dev_create_cwww_model_space(dev_struct_t const *pdev, uint16_t n_max)
{
    if (!pdev)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = meshx_element_struct_init(n_max);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "Failed to initialize cwww element structures: (%d)", err);
        meshx_element_struct_deinit(n_max);
        return err;
    }
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_add_cwww_cli_model_to_element_list(dev_struct_t *pdev, uint16_t *start_idx, uint16_t n_max)
{
    if (!pdev || !start_idx || !n_max)
        return MESHX_INVALID_ARG;
 
    if ((n_max + *start_idx) > CONFIG_MAX_ELEMENT_COUNT)
    {
        MESHX_LOGE(MOD_LCC, "No of elements limit reached");
        return MESHX_NO_MEM;
    }
    meshx_err_t err = MESHX_SUCCESS;
 
    cwww_client_element_init_ctrl.element_id_start = *start_idx;
 
    for (uint16_t i = *start_idx; i < (n_max + *start_idx) && (i - *start_idx) < CWWW_CLI_MODEL_SIG_CNT; i++)
    {
        if (i == 0)
            continue;
        err = meshx_plat_add_element_to_composition(
            i,
            pdev->elements,
            CWWW_CLI_EL(i - *start_idx).cwww_cli_sig_model_list,
            NULL,
            CWWW_CLI_MODEL_SIG_CNT,
            CWWW_CLI_MODEL_VEN_CNT);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Failed to add element to composition: (%d)", err);
            return err;
        }
        err = meshx_nvs_element_ctx_get(i,
                                        CWWW_CLI_EL(i - *start_idx).cwww_cli_ctx,
                                        sizeof(meshx_cwww_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGW(MOD_LCC, "Failed to get cwww cli element context: (0x%x)", err);
        }
    }
    /* Increment the index for further registrations */
    cwww_client_element_init_ctrl.element_id_end = *start_idx += n_max;
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_cwww_cli_reg_app_req_cb()
{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CONTROL_TASK_MSG_CODE_EVT_MASK,
        (control_task_msg_handle_t)&meshx_cwww_client_element_to_ble_handler
    );
}
 
static meshx_err_t meshx_cwww_cli_el_state_change_reg_cb()
{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_EL_STATE_CH,
        CWWW_CLI_EL_STATE_CH_EVT_MASK,
        (control_task_msg_handle_t)&meshx_cwww_client_element_state_change_handler
    );
}

meshx_err_t meshx_cwww_el_get_state(uint16_t element_id, cwww_cli_sig_id_t model_id)
{
    if (!IS_EL_IN_RANGE(element_id))
    {
        MESHX_LOGE(MOD_LCC, "Invalid element id: %d", element_id);
        return MESHX_INVALID_ARG;
    }
    meshx_cwww_client_msg_t msg = {0};
    msg.ack = CWWW_CLI_MSG_ACK;
    msg.set_get = CWWW_CLI_MSG_GET;
    msg.element_id = element_id;
 
    if (model_id != CWWW_CLI_SIG_ID_MAX)
    {
        MESHX_LOGD(MOD_LCC, "Sending GET for model: %d", model_id);
        if(model_id == CWWW_CLI_SIG_L_CTL_MODEL_ID)
        {
            control_task_msg_publish(
                CONTROL_TASK_MSG_CODE_TO_BLE,
                CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL,
                &msg,
                sizeof(msg));
        }
        else
        {
            control_task_msg_publish(
                CONTROL_TASK_MSG_CODE_TO_BLE,
                CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
                &msg,
                sizeof(msg));
        }
    }
    else
    {
        for(model_id = CWWW_CLI_SIG_ONOFF_MODEL_ID; model_id < CWWW_CLI_SIG_ID_MAX; model_id++)
        {
 
            MESHX_LOGD(MOD_LCC, "Sending GET for model: %d", model_id);
            if(model_id == CWWW_CLI_SIG_L_CTL_MODEL_ID)
            {
                control_task_msg_publish(
                    CONTROL_TASK_MSG_CODE_TO_BLE,
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL,
                    &msg,
                    sizeof(msg));
            }
            else
            {
                control_task_msg_publish(
                    CONTROL_TASK_MSG_CODE_TO_BLE,
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
                    &msg,
                    sizeof(msg));
            }
        }
    }
    return MESHX_SUCCESS;
}

meshx_err_t create_cwww_client_elements(dev_struct_t *pdev, uint16_t element_cnt)
{
    meshx_err_t err;
 
    err = meshx_dev_create_cwww_model_space(pdev, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "CWWW Model space create failed: (%d)", err);
        return err;
    }
 
    err = meshx_add_cwww_cli_model_to_element_list(pdev, (uint16_t *)&pdev->element_idx, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "CWWW Model add to element create failed: (%d)", err);
        return err;
    }
 
    err = meshx_on_off_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "meshx_onoff_client_init failed: (%d)", err);
        return err;
    }
 
    err = meshx_light_ctl_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "meshx_light_ctl_client_init failed: (%d)", err);
        return err;
    }
 
#if CONFIG_ENABLE_CONFIG_SERVER
    err = meshx_config_server_cb_reg(
        (config_srv_cb_t) &cwww_client_config_srv_cb,
        CONFIG_SERVER_CB_MASK);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "Light CWWW config server callback reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
 
#if defined(__MESHX_CONTROL_TASK__)
    /* Register control task callback */
    err = meshx_cwww_cli_reg_app_req_cb();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "control task callback reg failed: (%d)", err);
        return err;
    }
    /* Register element state change callback */
    err = meshx_cwww_cli_el_state_change_reg_cb();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "element state change callback reg failed: (%d)", err);
        return err;
    }
    /* Register freshboot control task callback */
    err = meshx_prov_srv_reg_el_client_cb(
        (prov_srv_cb_t)&cwww_cli_prov_srv_msg_handle);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "control task callback reg failed: (%d)", err);
        return err;
    }
 
#endif /* __MESHX_CONTROL_TASK__ */
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MODULE_ID_ELEMENT_LIGHT_CWWWW_CLIENT, &cwww_cli_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    return MESHX_SUCCESS;
}
 
REG_MESHX_ELEMENT_FN(cwww_cli_el, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT, create_cwww_client_elements);
 
#endif /* CONFIG_LIGHT_CWWW_CLIENT_COUNT */