/*
 * BLE Mesh Switch MiBoxer P3
 *
 * (C)2026 St(u)dio of Computer Games
 */

#include <stdint.h>
#include <string.h>

#include "boards.h"

/* core */
#include "nrf_mesh_config_core.h"
#include "nrf_mesh_gatt.h"
#include "nrf_mesh_configure.h"
#include "nrf_mesh_events.h"
#include "nrf_mesh.h"
#include "mesh_stack.h"
#include "device_state_manager.h"
#include "access_config.h"
#include "proxy.h"

/* provisioning and configuration */
#include "mesh_provisionee_output_blink.h"
#include "mesh_app_utils.h"

/* models */
#include "model_config_file.h"

/* application specific includes */
#include "ctrl_led.h"
#include "ctrl_miboxer_p3.h"
#include "nordic_common.h"
#include "nrf_mesh_config_app.h"
#include "nrf.h"
#include "example_common.h"
#include "nrf_drv_pwm.h"
#include "nrf_mesh_config_examples.h"
#include "ble_softdevice_support.h"
#include "fsm.h"
#include "fsm_assistant.h"
#include "scene_client.h"
#include "generic_onoff_client.h"
#include "generic_level_client.h"
#include "app_timer.h"
#include "app_config.h"
#include "deferrer_flag.h"

/* logging */
#include "log.h"


/*** Definitions ***/

#define SCHED_MAX_EVENT_DATA_SIZE                               (APP_TIMER_SCHED_EVENT_DATA_SIZE + sizeof(uint16_t))
#define SCHED_QUEUE_SIZE                                        (10)

/* Controls if the model instance should force all mesh messages to be segmented messages. */
#define APP_FORCE_SEGMENTATION                                  (false)
/* Controls the MIC size used by the model instance for sending the mesh messages. */
#define APP_MIC_SIZE                                            (NRF_MESH_TRANSMIC_SIZE_SMALL)
/** The maximum message size in bytes. */
#define APP_MAX_MESSAGE_BYTES                                   (256)

#define APP_SCENE_CLIENT_ELEMENT_INDEX                          (0)
#define APP_CTL_ONOFF_CLIENT_ELEMENT_INDEX                      (0)
#define APP_CTL_LIGHTNESS_CLIENT_ELEMENT_INDEX                  (0)
#define APP_CTL_TEMPERATURE_CLIENT_ELEMENT_INDEX                (1)
#define APP_HSL_ONOFF_CLIENT_ELEMENT_INDEX                      (2)
#define APP_HSL_LIGHTNESS_CLIENT_ELEMENT_INDEX                  (2)
#define APP_HSL_HUE_CLIENT_ELEMENT_INDEX                        (3)
#define APP_HSL_SATURATION_CLIENT_ELEMENT_INDEX                 (4)

#define SCENES_MAX                                              (4)
#define SCENE_NUMBERS                                           { 0xff01, 0xff02, 0xff03, 0xff04 }

#define APP_UNACK_MSG_REPEAT_COUNT                              (0)
#define STATUS_THRESHOLD_TIMEOUT_MS                             (1000)

#define BUTTON_TIMER_PERIOS_S                                   (1)
#define BUTTON_WARN_TIMEOUT_S                                   (5)
#define BUTTON_RESET_TIMEOUT_S                                  (10)

#define EVENT_LIST  E_GENERIC_ONOFF_STATUS,     \
                    E_GET_ONOFF_STATUS,         \
                    E_TRANSFER_SUCCESS,         \
                    E_TRANSFER_FAILURE,         \
                    E_CTL_ONOFF_STATUS,         \
                    E_HSL_ONOFF_STATUS,         \
                    E_TOGGLE_CTL,               \
                    E_TOGGLE_HSL

#define STATE_LIST  S_IDLE,                             \
                    S_GET_CTL_ONOFF_STATUS,             \
                    S_GET_CTL_LIGHTNESS_STATUS,         \
                    S_GET_HSL_ONOFF_STATUS,             \
                    S_GET_HSL_LIGHTNESS_STATUS,         \
                    S_TOGGLE_GET_CTL_ONOFF_STATUS,      \
                    S_TOGGLE_GET_HSL_ONOFF_STATUS

#define ACTION_LIST A_GET_CTL_ONOFF_STATUS,             a_get_ctl_onoff_status,         \
                    A_GET_CTL_LIGHTNESS_STATUS,         a_get_ctl_lightness_status,     \
                    A_GET_HSL_ONOFF_STATUS,             a_get_hsl_onoff_status,         \
                    A_GET_HSL_LIGHTNESS_STATUS,         a_get_hsl_lightness_status,     \
                    A_TOGGLE_SET_CTL_ONOFF,             a_toggle_set_ctl_onoff,         \
                    A_TOGGLE_SET_HSL_ONOFF,             a_toggle_set_hsl_onoff



/*** Forward declarations ***/

static void update_mode_and_state();
static void toggle_onoff();
static void set_ctl_mode();
static void set_lightness(uint8_t sensor_value);
static void set_hue(uint8_t sensor_value);
static void set_temperature_saturation(uint8_t sensor_value);
static void set_scene(uint16_t scene_number);

typedef void (* client_fsm_action_t)(void *);
typedef bool (* client_fsm_guard_t)(void *);

DECLARE_ACTION_PROTOTYPE(ACTION_LIST)
DECLARE_GUARD_PROTOTYPE(GUARD_LIST)

static void client_fsm_action(fsm_action_id_t action_id, void *p_data);
static bool client_fsm_guard(fsm_guard_id_t guard_id, void *p_data);

/* models behavior */
static void scene_client_status_cb(const scene_client_t *p_self,
                                   const access_message_rx_meta_t *p_meta,
                                   const scene_status_params_t *p_in);
static void scene_client_register_status_cb(const scene_client_t *p_self,
                                            const access_message_rx_meta_t *p_meta,
                                            const scene_register_status_params_t *p_in);
static void scene_client_transaction_status_cb(access_model_handle_t model_handle,
                                               void *p_args,
                                               access_reliable_status_t status);
static void scene_client_publish_interval_cb(access_model_handle_t handle, void *p_self);

static void generic_onoff_client_status_cb(const generic_onoff_client_t *p_self,
                                           const access_message_rx_meta_t *p_meta,
                                           const generic_onoff_status_params_t *p_in);
static void generic_onoff_client_transaction_status_cb(access_model_handle_t model_handle,
                                                       void *p_args,
                                                       access_reliable_status_t status);
static void generic_onoff_client_publish_interval_cb(access_model_handle_t handle, void *p_self);

static void generic_level_client_publish_interval_cb(access_model_handle_t handle, void * p_self);
static void generic_level_client_status_cb(const generic_level_client_t * p_self,
                                           const access_message_rx_meta_t * p_meta,
                                           const generic_level_status_params_t * p_in);
static void generic_level_client_transaction_status_cb(access_model_handle_t model_handle,
                                                       void * p_args,
                                                       access_reliable_status_t status);
/* proivisioning */
static void provisioning_output_request_cb(uint8_t action, uint8_t size, const uint8_t *p_data);
static void provisioning_complete_cb(void);
static void provisioning_abort_cb(void);

/* mesh basic */
static void mesh_events_handle(const nrf_mesh_evt_t *p_evt);
static void node_reset(void);



/*** Type definitions */

typedef enum {
    DEVICE_MODE_CTL,
    DEVICE_MODE_HSL,
} device_mode_t;

typedef enum {
    DECLARE_ENUM(EVENT_LIST)
} client_event_ids_t;

typedef enum {
    DECLARE_ENUM(STATE_LIST)
} client_state_ids_t;

typedef enum {
    DECLARE_ENUM_PAIR(ACTION_LIST)
} client_action_ids_t;



/*** Static variables ***/

static const fsm_transition_t m_fsm_transition_table[] = {
    FSM_STATE(S_IDLE),
    FSM_TRANSITION(E_GET_ONOFF_STATUS,  FSM_ALWAYS,     A_GET_CTL_ONOFF_STATUS,         S_GET_CTL_ONOFF_STATUS),
    FSM_TRANSITION(E_TOGGLE_CTL,        FSM_ALWAYS,     A_GET_CTL_ONOFF_STATUS,         S_TOGGLE_GET_CTL_ONOFF_STATUS),
    FSM_TRANSITION(E_TOGGLE_HSL,        FSM_ALWAYS,     A_GET_HSL_ONOFF_STATUS,         S_TOGGLE_GET_HSL_ONOFF_STATUS),

    FSM_STATE(S_GET_CTL_ONOFF_STATUS),
    FSM_TRANSITION(E_TRANSFER_SUCCESS,  FSM_ALWAYS,     A_GET_CTL_LIGHTNESS_STATUS,     S_GET_CTL_LIGHTNESS_STATUS),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     A_GET_CTL_LIGHTNESS_STATUS,     S_GET_CTL_LIGHTNESS_STATUS),

    FSM_STATE(S_GET_CTL_LIGHTNESS_STATUS),
    FSM_TRANSITION(E_TRANSFER_SUCCESS,  FSM_ALWAYS,     A_GET_HSL_ONOFF_STATUS,         S_GET_HSL_ONOFF_STATUS),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     A_GET_HSL_ONOFF_STATUS,         S_GET_HSL_ONOFF_STATUS),

    FSM_STATE(S_GET_HSL_ONOFF_STATUS),
    FSM_TRANSITION(E_TRANSFER_SUCCESS,  FSM_ALWAYS,     A_GET_HSL_LIGHTNESS_STATUS,     S_GET_HSL_LIGHTNESS_STATUS),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     A_GET_HSL_LIGHTNESS_STATUS,     S_GET_HSL_LIGHTNESS_STATUS),

    FSM_STATE(S_GET_HSL_LIGHTNESS_STATUS),
    FSM_TRANSITION(E_TRANSFER_SUCCESS,  FSM_ALWAYS,     FSM_NO_ACTION,                  S_IDLE),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     FSM_NO_ACTION,                  S_IDLE),

    FSM_STATE(S_TOGGLE_GET_CTL_ONOFF_STATUS),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     FSM_NO_ACTION,                  S_IDLE),
    FSM_TRANSITION(E_CTL_ONOFF_STATUS,  FSM_ALWAYS,     A_TOGGLE_SET_CTL_ONOFF,         S_IDLE),

    FSM_STATE(S_TOGGLE_GET_HSL_ONOFF_STATUS),
    FSM_TRANSITION(E_TRANSFER_FAILURE,  FSM_ALWAYS,     FSM_NO_ACTION,                  S_IDLE),
    FSM_TRANSITION(E_HSL_ONOFF_STATUS,  FSM_ALWAYS,     A_TOGGLE_SET_HSL_ONOFF,         S_IDLE),
};

static const client_fsm_action_t m_fsm_actions[] =
{
    DECLARE_HANDLER(ACTION_LIST)
};

#if FSM_DEBUG
static const char *m_action_lookup_table[] =
{
    DECLARE_STRING_PAIR(ACTION_LIST)
};

static const char *m_guard_lookup_table[] =
{
    DECLARE_STRING_PAIR(GUARD_LIST)
};

static const char *m_event_lookup_table[] =
{
    DECLARE_STRING(EVENT_LIST)
};

static const char *m_state_lookup_table[] =
{
    DECLARE_STRING(STATE_LIST)
};
#endif  /* FSM_DEBUG */

static const fsm_const_descriptor_t m_client_fsm_descriptor =
{
    .transition_table = m_fsm_transition_table,
    .transitions_count = ARRAY_SIZE(m_fsm_transition_table),
    .initial_state = S_IDLE,
    .guard = client_fsm_guard,
    .action = client_fsm_action,
#if FSM_DEBUG
    .fsm_name = "app_tuya_fsm",
    .action_lookup = m_action_lookup_table,
    .event_lookup = m_event_lookup_table,
    .guard_lookup = m_guard_lookup_table,
    .state_lookup = m_state_lookup_table
#endif  /* FSM_DEBUG */
};

/* mesh */
static bool m_device_provisioned;
static uint32_t m_pin_blink;
static nrf_mesh_evt_handler_t m_event_handler = {
    .evt_cb = mesh_events_handle,
};

/* control */
APP_TIMER_DEF(m_button_timer);
static int m_button_timer_cnt;
static bool m_reset_warning;

static const uint16_t m_scene_numbers[] = SCENE_NUMBERS;

/* Models callbacks */
static const scene_client_callbacks_t m_scene_client_cbs =
{
    .scene_status_cb = scene_client_status_cb,
    .scene_register_status_cb = scene_client_register_status_cb,
    .ack_transaction_status_cb = scene_client_transaction_status_cb,
    .periodic_publish_cb = scene_client_publish_interval_cb
};
const generic_onoff_client_callbacks_t m_generic_onoff_client_cbs = {
    .onoff_status_cb = generic_onoff_client_status_cb,
    .ack_transaction_status_cb = generic_onoff_client_transaction_status_cb,
    .periodic_publish_cb = generic_onoff_client_publish_interval_cb
};
const generic_level_client_callbacks_t m_generic_level_client_cbs =
{
    .level_status_cb = generic_level_client_status_cb,
    .ack_transaction_status_cb = generic_level_client_transaction_status_cb,
    .periodic_publish_cb = generic_level_client_publish_interval_cb
};


/* Scene client */
static scene_client_t m_scene_client;

/* CTL client */
static generic_onoff_client_t m_ctl_onoff_client;
static generic_level_client_t m_ctl_lightness_client;
static generic_level_client_t m_ctl_temperature_client;

/* HSL client */
static generic_onoff_client_t m_hsl_onoff_client;
static generic_level_client_t m_hsl_lightness_client;
static generic_level_client_t m_hsl_hue_client;
static generic_level_client_t m_hsl_saturation_client;

/* device status */
static device_mode_t m_device_mode;
static uint16_t m_scene_number;
static bool m_ctl_onoff_status;
static int16_t m_ctl_lightness_status;
static int16_t m_ctl_temperature_status;
static bool m_hsl_onoff_status;
static int16_t m_hsl_lightness_status;
static int16_t m_hsl_hue_status;
static int16_t m_hsl_saturation_status;

static fsm_t m_client_fsm;
static deferrer_flag_t m_client_fsm_get_failure_flag;

static deferrer_flag_t m_scene_set_flag;
static deferrer_flag_t m_ctl_onoff_set_flag;
static deferrer_flag_t m_ctl_lightness_set_flag;
static deferrer_flag_t m_ctl_temperature_set_flag;
static deferrer_flag_t m_hsl_onoff_set_flag;
static deferrer_flag_t m_hsl_lightness_set_flag;
static deferrer_flag_t m_hsl_hue_set_flag;
static deferrer_flag_t m_hsl_saturation_set_flag;

APP_TIMER_DEF(m_ctl_status_threshold_timer);
APP_TIMER_DEF(m_hsl_status_threshold_timer);
static bool m_ctl_status_threshold;
static bool m_hsl_status_threshold;



/* helpers section */

static void unicast_address_print(void)
{
    dsm_local_unicast_address_t node_address;
    dsm_local_unicast_addresses_get(&node_address);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Node Address: 0x%04x\n", node_address.address_start);
}


/* Sensor Panel section */

static int16_t sensor_to_generic_level(uint8_t sensor_value)
{
    int16_t generic_level_value;

    generic_level_value = (((int32_t)sensor_value * UINT16_MAX) / UINT8_MAX) + INT16_MIN;

    return generic_level_value;
}


static void button_timer_handler(void * p_context)
{
    m_button_timer_cnt += BUTTON_TIMER_PERIOS_S;

    if (m_button_timer_cnt == BUTTON_WARN_TIMEOUT_S) {
        ctrl_led_flash(LED_1, 100);
        m_reset_warning = true;
    } else if (m_button_timer_cnt == BUTTON_RESET_TIMEOUT_S) {
        node_reset();
    }
}


static void miboxer_handler(const miboxer_evt_t *evt)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(), type=%d\n", __func__, evt->type);

    /* handling the reset button press */
    if (evt->type == MIBOXER_EVT_BUTTON) {
        if (evt->btn_flags == MIBOXER_BTN_FLAG_ONOFF) {
            m_button_timer_cnt = 0;
            APP_ERROR_CHECK(app_timer_start(m_button_timer,
                            APP_TIMER_TICKS(SEC_TO_MS(BUTTON_TIMER_PERIOS_S)),
                            NULL));

        } else {
            app_timer_stop(m_button_timer);
             if (m_reset_warning) {
                m_reset_warning = false;
                if (mesh_stack_is_device_provisioned()) {
                    update_mode_and_state();
                } else {
                    ctrl_led_blink_count(LED_1, 1, 100, 1000);
                }
            }
        }
    }

    /* remaining buttons are handled after device provisioning */
    if (mesh_stack_is_device_provisioned()) {
        switch (evt->type) {
        case MIBOXER_EVT_BUTTON:
            if (evt->btn_flags == MIBOXER_BTN_FLAG_DELAY_OFF) {
                set_scene(m_scene_numbers[3]);
            } else if (evt->btn_flags == MIBOXER_BTN_FLAG_WHITE) {
                set_ctl_mode();
            } else if (evt->btn_flags == MIBOXER_BTN_FLAG_SPEED_MINUS) {
                set_scene(m_scene_numbers[0]);
            } else if (evt->btn_flags == MIBOXER_BTN_FLAG_SPEED_PLUS) {
                set_scene(m_scene_numbers[1]);
            } else if (evt->btn_flags == MIBOXER_BTN_FLAG_MODE) {
                set_scene(m_scene_numbers[2]);
            } else if (evt->btn_flags == MIBOXER_BTN_FLAG_ONOFF) {
                toggle_onoff();
            }
            break;

        case MIBOXER_EVT_LIGHTNESS:
            set_lightness(evt->lightness);
            break;

        case MIBOXER_EVT_SATURATION:
            set_temperature_saturation(evt->saturation);
            break;

        case MIBOXER_EVT_HUE:
            set_hue(evt->hue);
            break;

        default:
            break;
        }
    }
}


static void update_mode_and_state()
{
    bool onoff_status;

    onoff_status = m_ctl_onoff_status | m_hsl_onoff_status;
    ctrl_led_set(LED_1, !onoff_status);

    if (m_ctl_onoff_status && !m_hsl_onoff_status) {
        m_device_mode = DEVICE_MODE_CTL;
    } else if (!m_ctl_onoff_status && m_hsl_onoff_status) {
        m_device_mode = DEVICE_MODE_HSL;
    }

    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): m_ctl_onoff_status=%d, m_hsl_onoff_status=%d, m_device_mode=%d\n",
          __func__, m_ctl_onoff_status, m_hsl_onoff_status, m_device_mode);
}


static void set_scene(uint16_t scene_number)
{
    m_scene_number = scene_number;
    deferrer_flag_set(m_scene_set_flag);
}


static void toggle_onoff()
{
    if (m_device_mode == DEVICE_MODE_CTL) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "CTL OnOff toggle\n");
        fsm_event_post(&m_client_fsm, E_TOGGLE_CTL, NULL);
    } else {
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "HSL OnOff toggle\n");
        fsm_event_post(&m_client_fsm, E_TOGGLE_HSL, NULL);
    }
}


static void set_ctl_mode()
{
    bool onoff_status;

    onoff_status = m_ctl_onoff_status | m_hsl_onoff_status;
    if (!onoff_status) {
        m_device_mode = DEVICE_MODE_CTL;
        return;
    }

    if (m_device_mode != DEVICE_MODE_CTL) {
        /* switch Off HSL lightness */
        m_hsl_onoff_status = false;
        deferrer_flag_set(m_hsl_onoff_set_flag);

        /* switch On CLT lightness */
        m_ctl_onoff_status = true;
        deferrer_flag_set(m_ctl_onoff_set_flag);
    }
    m_device_mode = DEVICE_MODE_CTL;
}


static void set_lightness(uint8_t sensor_value)
{
    bool onoff_status;

    onoff_status = m_ctl_onoff_status | m_hsl_onoff_status;
    if (!onoff_status) {
        return;
    }

    if (m_device_mode == DEVICE_MODE_CTL) {
        m_ctl_lightness_status = sensor_to_generic_level(sensor_value);
        deferrer_flag_set(m_ctl_lightness_set_flag);
        if (m_ctl_lightness_status == GENERIC_LEVEL_MIN) {
            m_ctl_onoff_status = false;
            update_mode_and_state();
        }
    } else {
        m_hsl_lightness_status = sensor_to_generic_level(sensor_value);
        deferrer_flag_set(m_hsl_lightness_set_flag);
        if (m_hsl_lightness_status == GENERIC_LEVEL_MIN) {
            m_hsl_onoff_status = false;
            update_mode_and_state();
        }
    }
}


static void set_hue(uint8_t sensor_value)
{
    bool onoff_status;

    onoff_status = m_ctl_onoff_status | m_hsl_onoff_status;
    if (!onoff_status) {
        m_device_mode = DEVICE_MODE_HSL;
        return;
    }

    if (m_device_mode != DEVICE_MODE_HSL) {
        /* switch Off CTL lightness */
        m_ctl_onoff_status = false;
        deferrer_flag_set(m_ctl_onoff_set_flag);

        /* switch On HSL lightness */
        m_hsl_onoff_status = true;
        deferrer_flag_set(m_hsl_onoff_set_flag);
    }

    m_device_mode = DEVICE_MODE_HSL;
    m_hsl_hue_status = sensor_to_generic_level(sensor_value);
    deferrer_flag_set(m_hsl_hue_set_flag);
}


static void set_temperature_saturation(uint8_t sensor_value)
{
    bool onoff_status;

    onoff_status = m_ctl_onoff_status | m_hsl_onoff_status;
    if (!onoff_status) {
        return;
    }

    if (m_device_mode == DEVICE_MODE_CTL) {
        m_ctl_temperature_status = sensor_to_generic_level(sensor_value);
        deferrer_flag_set(m_ctl_temperature_set_flag);
    } else {
        m_hsl_saturation_status = sensor_to_generic_level(sensor_value);
        deferrer_flag_set(m_hsl_saturation_set_flag);
    }
}


void scene_set_cb(void *p_data)
{
    scene_recall_params_t recall_params;
    static uint8_t tid = 0;
    uint32_t status;

    recall_params.scene_number = m_scene_number;
    recall_params.tid = tid++;
    status = scene_client_recall_unack(&m_scene_client, &recall_params,
                                       NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Recall scene 0x%04x\n", m_scene_number);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot recall scene: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for Scene client\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


void ctl_onoff_set_cb(void *p_data)
{
    generic_onoff_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.on_off = m_ctl_onoff_status;
    set_params.tid = tid++;
    status = generic_onoff_client_set_unack(&m_ctl_onoff_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set CTL OnOff to %d\n", m_ctl_onoff_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set CTL OnOff: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for CTL OnOff\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}

void ctl_lightness_set_cb(void *p_data)
{
    generic_level_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.level = m_ctl_lightness_status;
    set_params.tid = tid++;

    status = generic_level_client_set_unack(&m_ctl_lightness_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set CTL Lightness to %d\n", m_ctl_lightness_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set CTL Lightness: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for CTL Lightness\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


void ctl_temperature_set_cb(void *p_data)
{
    generic_level_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.level = m_ctl_temperature_status;
    set_params.tid = tid++;

    status = generic_level_client_set_unack(&m_ctl_temperature_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set CTL Temperature to %d\n", m_ctl_temperature_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set CTL Temperature: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for CTL Temperature\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


static void hsl_onoff_set_cb(void *p_data)
{
    generic_onoff_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.tid = tid++;
    set_params.on_off = m_hsl_onoff_status;
    status = generic_onoff_client_set_unack(&m_hsl_onoff_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set HSL OnOff to %d\n", m_hsl_onoff_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set HSL OnOff: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for HSL OnOff\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


static void hsl_lightness_set_cb(void *p_data)
{
    generic_level_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.level = m_hsl_lightness_status;
    set_params.tid = tid++;

    status = generic_level_client_set_unack(&m_hsl_lightness_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set HSL Lightness to %d\n", m_hsl_lightness_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set HSL Lightness: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for HSL Lightness\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }

}


static void hsl_hue_set_cb(void *p_data)
{
    generic_level_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.level = m_hsl_hue_status;
    set_params.tid = tid++;
    status = generic_level_client_set_unack(&m_hsl_hue_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set HSL Hue to %d\n", m_hsl_hue_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set HSL Hue: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for HSL Hue\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


static void hsl_saturation_set_cb(void *p_data)
{
    generic_level_set_params_t set_params;
    static uint8_t tid = 0;
    uint32_t status;

    set_params.level = m_hsl_saturation_status;
    set_params.tid = tid++;
    status = generic_level_client_set_unack(&m_hsl_saturation_client, &set_params,
                                            NULL, APP_UNACK_MSG_REPEAT_COUNT);
    switch (status) {
    case NRF_SUCCESS:
        __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "Set HSL Saturation to %d\n", m_hsl_saturation_status);
        break;

    case NRF_ERROR_NO_MEM:
    case NRF_ERROR_BUSY:
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot set HSL Saturation: status: %d\n", status);
        break;

    case NRF_ERROR_INVALID_PARAM:
        /* Publication not enabled for this client. One (or more) of the following is wrong:
         * - An application key is missing, or there is no application key bound to the model
         * - The client does not have its publication state set
         *
         * It is the provisioner that adds an application key, binds it to the model and sets
         * the model's publication state.
         */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Publication not configured for HSL Saturation\n");
        break;

    default:
        ERROR_CHECK(status);
        break;
    }
}


static void ctl_status_threshold_timer_handler(void * p_context)
{
    m_ctl_status_threshold = false;
}


static void hsl_status_threshold_timer_handler(void * p_context)
{
    m_hsl_status_threshold = false;
}


/*** FSM section */

/* FSM guards */

static bool client_fsm_guard(fsm_guard_id_t guard_id, void * p_data)
{
    return false;
}


/* FSM actions */

static void client_fsm_action(fsm_action_id_t action_id, void * p_data)
{
    m_fsm_actions[action_id](p_data);
}


static void a_get_ctl_onoff_status(void *p_data)
{
    uint32_t status;

    status = generic_onoff_client_get(&m_ctl_onoff_client);
    if (status != NRF_SUCCESS) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot get CTL OnOff: status: %d\n", status);
        deferrer_flag_set(m_client_fsm_get_failure_flag);
    }

}

static void a_get_ctl_lightness_status(void *p_data)
{
    uint32_t status = generic_level_client_get(&m_ctl_lightness_client);
    if (status != NRF_SUCCESS) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot get CTL Lightness: status: %d\n", status);
        deferrer_flag_set(m_client_fsm_get_failure_flag);
    }
}

static void a_get_hsl_onoff_status(void *p_data)
{
    uint32_t status = generic_onoff_client_get(&m_hsl_onoff_client);
    if (status != NRF_SUCCESS) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot get HSL OnOff: status: %d\n", status);
        deferrer_flag_set(m_client_fsm_get_failure_flag);
    }
}

static void a_get_hsl_lightness_status(void *p_data)
{
    uint32_t status = generic_level_client_get(&m_hsl_lightness_client);
    if (status != NRF_SUCCESS) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot get HSL Lightness: status: %d\n", status);
        deferrer_flag_set(m_client_fsm_get_failure_flag);
    }
}


static void a_toggle_set_ctl_onoff(void *p_data)
{
    m_ctl_onoff_status = !m_ctl_onoff_status;
    deferrer_flag_set(m_ctl_onoff_set_flag);
    update_mode_and_state();
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): new status=%u\n", __func__, m_ctl_onoff_status);
}


static void a_toggle_set_hsl_onoff(void *p_data)
{
    m_hsl_onoff_status = !m_hsl_onoff_status;
    deferrer_flag_set(m_hsl_onoff_set_flag);
    update_mode_and_state();
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): new status=%u\n", __func__, m_hsl_onoff_status);
}


static void client_fsm_get_failure_cb(void *p_data)
{
    fsm_event_post(&m_client_fsm, E_TRANSFER_FAILURE, NULL);
}


/*** Models behavior section ***/

/* Scene client functons */
static void scene_client_status_cb(const scene_client_t *p_self,
                                   const access_message_rx_meta_t *p_meta,
                                   const scene_status_params_t *p_in)
{
    /* do nothing */
}


static void scene_client_register_status_cb(const scene_client_t *p_self,
                                            const access_message_rx_meta_t *p_meta,
                                            const scene_register_status_params_t *p_in)
{
    /* do nothing */
}


static void scene_client_transaction_status_cb(access_model_handle_t model_handle,
                                               void *p_args,
                                               access_reliable_status_t status)
{
}


static void scene_client_publish_interval_cb(access_model_handle_t handle, void *p_self)
{
    /* do nothing */
}


/* Generoc On/Off Client functions*/

static void generic_onoff_client_publish_interval_cb(access_model_handle_t handle, void *p_self)
{
    /* do nothing */
}


static void generic_onoff_client_status_cb(const generic_onoff_client_t *p_self,
                                           const access_message_rx_meta_t *p_meta,
                                           const generic_onoff_status_params_t *p_in)
{
    bool onoff_status = p_in->remaining_time_ms > 0 ? p_in->target_on_off : p_in->present_on_off;

    if (p_self == &m_ctl_onoff_client) {
        if (!m_ctl_status_threshold) {
            __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): onoff_status=%d, m_ctl_onoff_status=%d\n", __func__, onoff_status, m_ctl_onoff_status);
            m_ctl_onoff_status = onoff_status;
            update_mode_and_state();

            m_ctl_status_threshold = true;
            APP_ERROR_CHECK(app_timer_start(m_ctl_status_threshold_timer,
                            APP_TIMER_TICKS(STATUS_THRESHOLD_TIMEOUT_MS),
                            NULL));
        }
        fsm_event_post(&m_client_fsm, E_CTL_ONOFF_STATUS, NULL);
    } else if (p_self == &m_hsl_onoff_client) {
        if (!m_hsl_status_threshold) {
            __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): onoff_status=%d, m_hsl_onoff_status=%d\n", __func__, onoff_status, m_hsl_onoff_status);
            m_hsl_onoff_status = onoff_status;
            update_mode_and_state();

            m_hsl_status_threshold = true;
            APP_ERROR_CHECK(app_timer_start(m_hsl_status_threshold_timer,
                            APP_TIMER_TICKS(STATUS_THRESHOLD_TIMEOUT_MS),
                            NULL));
        }
        fsm_event_post(&m_client_fsm, E_HSL_ONOFF_STATUS, NULL);
    }
}


static void generic_onoff_client_transaction_status_cb(access_model_handle_t model_handle,
                                                       void *p_args,
                                                       access_reliable_status_t status)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "%s(): status=%d\n", __func__, status);

    if (status == ACCESS_RELIABLE_TRANSFER_SUCCESS) {
        fsm_event_post(&m_client_fsm, E_TRANSFER_SUCCESS, NULL);
    } else {
        fsm_event_post(&m_client_fsm, E_TRANSFER_FAILURE, NULL);
    }
}


/* Generic Level functions */

static void generic_level_client_publish_interval_cb(access_model_handle_t handle, void * p_self)
{
    /* do nothing */
}


static void generic_level_client_status_cb(const generic_level_client_t * p_self,
                                           const access_message_rx_meta_t * p_meta,
                                           const generic_level_status_params_t * p_in)
{
    int16_t level_status;
    bool onoff_status;

    level_status = p_in->remaining_time_ms > 0 ? p_in->target_level : p_in->present_level;
    onoff_status = level_status > GENERIC_LEVEL_MIN;

    if (p_self == &m_ctl_lightness_client) {
        if (!m_ctl_status_threshold) {
            m_ctl_onoff_status = onoff_status;
            update_mode_and_state();
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "%s(): m_ctl_onoff_status=%d\n", __func__, m_ctl_onoff_status);

            m_ctl_status_threshold = true;
            APP_ERROR_CHECK(app_timer_start(m_ctl_status_threshold_timer,
                            APP_TIMER_TICKS(STATUS_THRESHOLD_TIMEOUT_MS),
                            NULL));
        }
    } else if (p_self == &m_hsl_lightness_client) {
        if (!m_hsl_status_threshold) {
            m_hsl_onoff_status = onoff_status;
            update_mode_and_state();
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "%s(): m_hsl_onoff_status=%d\n", __func__, m_hsl_onoff_status);

            m_ctl_status_threshold = true;
            APP_ERROR_CHECK(app_timer_start(m_ctl_status_threshold_timer,
                            APP_TIMER_TICKS(STATUS_THRESHOLD_TIMEOUT_MS),
                            NULL));
        }
    }
}


static void generic_level_client_transaction_status_cb(access_model_handle_t model_handle,
                                                       void * p_args,
                                                       access_reliable_status_t status)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "%s(): status=%d\n", __func__, status);

    if (status == ACCESS_RELIABLE_TRANSFER_SUCCESS) {
        fsm_event_post(&m_client_fsm, E_TRANSFER_SUCCESS, NULL);
    } else {
        fsm_event_post(&m_client_fsm, E_TRANSFER_FAILURE, NULL);
    }
}



/*** provisionoing section ***/

static void provisioning_output_request_cb(uint8_t action, uint8_t size, const uint8_t *p_data)
{
    if (action == NRF_MESH_PROV_OUTPUT_ACTION_BLINK) {
        memcpy(&m_pin_blink, &p_data[PROV_AUTH_LEN - sizeof(m_pin_blink)], sizeof(m_pin_blink));
        m_pin_blink = BE2LE32(m_pin_blink);
        ctrl_led_blink_count(LED_1, m_pin_blink, 500, 3000);
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Provisioning output PIN: %d\n", m_pin_blink);
    }
}


static void provisioning_complete_cb(void)
{
#if MESH_FEATURE_GATT_ENABLED
    /* Restores the application parameters after switching from the Provisioning
     * service to the Proxy  */
    gap_params_init();
    conn_params_init();
#endif

    update_mode_and_state();

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Provisioning complete\n");
    unicast_address_print();
}


static void provisioning_abort_cb(void)
{
    ctrl_led_blink_count(LED_1, 1, 100, 1000);

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Provisioning abort\n");
}



/*** mesh basic section ***/

static void mesh_events_handle(const nrf_mesh_evt_t *p_evt)
{
    switch (p_evt->type) {
    case NRF_MESH_EVT_ENABLED:
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- NRF_MESH_EVT_ENABLED  -----\n");

        if (mesh_stack_is_device_provisioned()) {
            /* get current OnOff status */
            fsm_event_post(&m_client_fsm, E_GET_ONOFF_STATUS, NULL);
        } else {
            ctrl_led_blink_count(LED_1, 1, 100, 1000);
        }
        break;

    default:
        break;
    }
}


static void node_reset(void)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- NODE RESET -----\n");

#if MESH_FEATURE_GATT_PROXY_ENABLED
    proxy_stop();
#endif
    mesh_stack_config_clear();

    /* this function may return if there are ongoing flash operations */
    model_config_file_clear();
    mesh_stack_device_reset();
}


static void config_server_evt_cb(const config_server_evt_t *p_evt)
{
    if (p_evt->type == CONFIG_SERVER_EVT_NODE_RESET) {
        node_reset();
    }
}


static void models_init_cb(void)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n");



    /* Element 0: Scene client */
    m_scene_client.settings.p_callbacks = &m_scene_client_cbs;
    m_scene_client.settings.timeout = 0;
    m_scene_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_scene_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(scene_client_init(&m_scene_client, APP_SCENE_CLIENT_ELEMENT_INDEX));

    /* Element 0: CTL Lightness client */
    m_ctl_onoff_client.settings.p_callbacks = &m_generic_onoff_client_cbs;
    m_ctl_onoff_client.settings.timeout = 0;
    m_ctl_onoff_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_ctl_onoff_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_onoff_client_init(&m_ctl_onoff_client,
                                          APP_CTL_ONOFF_CLIENT_ELEMENT_INDEX));

    m_ctl_lightness_client.settings.p_callbacks = &m_generic_level_client_cbs;
    m_ctl_lightness_client.settings.timeout = 0;
    m_ctl_lightness_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_ctl_lightness_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_level_client_init(&m_ctl_lightness_client,
                                         APP_CTL_LIGHTNESS_CLIENT_ELEMENT_INDEX));

    /* Element 1: CTL Temperature client */
    m_ctl_temperature_client.settings.p_callbacks = &m_generic_level_client_cbs;
    m_ctl_temperature_client.settings.timeout = 0;
    m_ctl_temperature_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_ctl_temperature_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_level_client_init(&m_ctl_temperature_client,
                                          APP_CTL_TEMPERATURE_CLIENT_ELEMENT_INDEX));


    /* Element 2: CTL Lightness client */
    m_hsl_onoff_client.settings.p_callbacks = &m_generic_onoff_client_cbs;
    m_hsl_onoff_client.settings.timeout = 0;
    m_hsl_onoff_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_hsl_onoff_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_onoff_client_init(&m_hsl_onoff_client,
                                          APP_HSL_ONOFF_CLIENT_ELEMENT_INDEX));

    m_hsl_lightness_client.settings.p_callbacks = &m_generic_level_client_cbs;
    m_hsl_lightness_client.settings.timeout = 0;
    m_hsl_lightness_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_hsl_lightness_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_level_client_init(&m_hsl_lightness_client,
                                         APP_HSL_LIGHTNESS_CLIENT_ELEMENT_INDEX));

    /* Element 3: CTL Hue client */
    m_hsl_hue_client.settings.p_callbacks = &m_generic_level_client_cbs;
    m_hsl_hue_client.settings.timeout = 0;
    m_hsl_hue_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_hsl_hue_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_level_client_init(&m_hsl_hue_client,
                                         APP_HSL_HUE_CLIENT_ELEMENT_INDEX));

    /* Element 3: CTL Saturation client */
    m_hsl_saturation_client.settings.p_callbacks = &m_generic_level_client_cbs;
    m_hsl_saturation_client.settings.timeout = 0;
    m_hsl_saturation_client.settings.force_segmented = APP_FORCE_SEGMENTATION;
    m_hsl_saturation_client.settings.transmic_size = APP_MIC_SIZE;
    ERROR_CHECK(generic_level_client_init(&m_hsl_saturation_client,
                                         APP_HSL_SATURATION_CLIENT_ELEMENT_INDEX));
}


static void mesh_init(void)
{
    /* initialize the application storage for models */
    model_config_file_init();

    mesh_stack_init_params_t init_params = {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = NULL,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };

    uint32_t status = mesh_stack_init(&init_params, &m_device_provisioned);

    if (status == NRF_SUCCESS) {
        /* check if application stored data is valid, if not clear all data and use default values */
        status = model_config_file_config_apply();
    }

    switch (status) {
    case NRF_ERROR_INVALID_DATA:
        /* clear model config file as loading failed */
        model_config_file_clear();
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Data in the persistent memory was corrupted. Device starts as unprovisioned.\n");
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reboot device before starting of the provisioning process.\n");
        break;
    case NRF_SUCCESS:
        break;
    default:
        ERROR_CHECK(status);
    }
}


/* change the voltage on the GPIO pins to 3 volts */
static void gpio_output_voltage_setup(void)
{
    /* configure UICR_REGOUT0 register only if it is set to default value */
    if ((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) ==
        (UICR_REGOUT0_VOUT_DEFAULT << UICR_REGOUT0_VOUT_Pos))
    {
        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Wen;
        while (NRF_NVMC->READY == NVMC_READY_READY_Busy){}

        NRF_UICR->REGOUT0 = (NRF_UICR->REGOUT0 & ~((uint32_t)UICR_REGOUT0_VOUT_Msk)) |
                            (UICR_REGOUT0_VOUT_3V0 << UICR_REGOUT0_VOUT_Pos);

        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Ren;
        while (NRF_NVMC->READY == NVMC_READY_READY_Busy){}

        /* system reset is needed to update UICR registers */
        NVIC_SystemReset();
    }
}


static void initialize(void)
{
    gpio_output_voltage_setup();

    __LOG_INIT(LOG_SRC_APP/* | LOG_SRC_ACCESS*/, LOG_LEVEL_DBG2, LOG_CALLBACK_DEFAULT);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- %s -----\n", GAP_DEVICE_NAME);

    ERROR_CHECK(app_timer_init());
    APP_ERROR_CHECK(app_timer_create(&m_button_timer,
                                     APP_TIMER_MODE_REPEATED,
                                     button_timer_handler));
    APP_ERROR_CHECK(app_timer_create(&m_ctl_status_threshold_timer,
                                     APP_TIMER_MODE_SINGLE_SHOT,
                                     ctl_status_threshold_timer_handler));
    APP_ERROR_CHECK(app_timer_create(&m_hsl_status_threshold_timer,
                                     APP_TIMER_MODE_SINGLE_SHOT,
                                     hsl_status_threshold_timer_handler));
    deferrer_flag_init();
    m_client_fsm_get_failure_flag = deferrer_flag_add(client_fsm_get_failure_cb, NULL);
    m_scene_set_flag = deferrer_flag_add(scene_set_cb, NULL);
    m_ctl_onoff_set_flag = deferrer_flag_add(ctl_onoff_set_cb, NULL);
    m_ctl_lightness_set_flag = deferrer_flag_add(ctl_lightness_set_cb, NULL);
    m_ctl_temperature_set_flag = deferrer_flag_add(ctl_temperature_set_cb, NULL);
    m_hsl_onoff_set_flag = deferrer_flag_add(hsl_onoff_set_cb, NULL);
    m_hsl_lightness_set_flag = deferrer_flag_add(hsl_lightness_set_cb, NULL);
    m_hsl_hue_set_flag = deferrer_flag_add(hsl_hue_set_cb, NULL);
    m_hsl_saturation_set_flag = deferrer_flag_add(hsl_saturation_set_cb, NULL);


    ERROR_CHECK(miboxer_init(miboxer_handler));
    ctrl_led_init();
    m_reset_warning = false;

    fsm_init(&m_client_fsm, &m_client_fsm_descriptor);

    m_ctl_status_threshold = false;
    m_hsl_status_threshold = false;

    m_ctl_onoff_status = false;
    m_hsl_onoff_status = false;
    m_device_mode = DEVICE_MODE_CTL;

    ble_stack_init();

#if MESH_FEATURE_GATT_ENABLED
    gap_params_init();
    conn_params_init();
#endif

    mesh_init();
}


static void start(void)
{
    if (!m_device_provisioned) {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Device is unprovisioned\n");
        mesh_provisionee_start_params_t prov_start_params = {
            .prov_sd_ble_opt_set_cb = NULL,
            .prov_complete_cb = provisioning_complete_cb,
            .prov_device_identification_start_cb = NULL,
            .prov_device_identification_stop_cb = NULL,
            .prov_abort_cb = provisioning_abort_cb,
            .prov_output_request_cb = provisioning_output_request_cb,
            .p_device_uri = EX_URI_DM_SERVER
        };
        ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params));
    } else {
        unicast_address_print();
    }

    ERROR_CHECK(miboxer_start());

    mesh_app_uuid_print(nrf_mesh_configure_device_uuid_get());

    /* NRF_MESH_EVT_ENABLED is triggered in the mesh IRQ context after the stack is fully enabled.
     * This event is used to call Model APIs for establishing bindings and publish a model state information. */
    nrf_mesh_evt_handler_add(&m_event_handler);
    ERROR_CHECK(mesh_stack_start());
}



/*** entry point ***/

int main(void)
{
    /* mark timers main structure as unused */
    const app_timer_id_t m_timer[] __attribute__((unused)) = {
        m_button_timer,
        m_ctl_status_threshold_timer,
        m_hsl_status_threshold_timer,
    };

    initialize();
    start();

    for (;;) {
        UNUSED_VARIABLE(sd_app_evt_wait());
    }
}
