/*
 * Tencent is pleased to support the open source community by making IoT Hub
 available.
 * Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.

 * Licensed under the MIT License (the "License"); you may not use this file
 except in
 * compliance with the License. You may obtain a copy of the License at
 * http://opensource.org/licenses/MIT

 * Unless required by applicable law or agreed to in writing, software
 distributed under the License is
 * distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 KIND,
 * either express or implied. See the License for the specific language
 governing permissions and
 * limitations under the License.
 *
 */
#define bool	_Bool

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ql_fs.h"
#include "ql_api_fota.h"
#include "ql_api_osi.h"
#include "ql_api_datacall.h"
#include "ql_power.h"

#include "lite-utils.h"
#include "qcloud_iot_export.h"
#include "qcloud_iot_import.h"
#include "ql_log.h"

#define PROFILE_IDX 1

#ifdef DEBUG_DEV_INFO_USED
extern int device_info_copy(void *pdst, void *psrc, uint8_t max_len);
#endif

#ifdef DEBUG_DEV_INFO_USED
#define PRODUCT_ID "KSS57PUDXP"
#define DEVICE_NAME "Smart_light_01"
#define DEVICE_SECRET "0TJoksp0+vkWMr1qSAR7ow=="
#define REGION "china"
#define DEVICE_CERT "./certsSmart_light_01_cert.crt"
#define DEVICE_PRIVATE "./certsSmart_light_01_private.key"
#else
#define DEVICE_INFO_JSON_DOC "UFS:device_info.json"
#endif

#define FW_FILE_PATH_FORMAT "UFS:EC200U_FIRMWARE.bin"
#define FW_FILE_INFO_PATH_FORMAT "UFS:EC200U_FIRMWARE.json"

#define FW_RUNNING_VERSION "1.0.0"

#define KEY_VER  "version"
#define KEY_SIZE "downloaded_size"

#define FW_VERSION_MAX_LEN    32
#define FW_FILE_PATH_MAX_LEN  128
#define OTA_BUF_LEN           5000
#define FW_INFO_FILE_DATA_LEN 128

typedef struct OTAContextData {
    void *ota_handle;
    void *mqtt_client;
    char  fw_file_path[FW_FILE_PATH_MAX_LEN];
    char  fw_info_file_path[FW_FILE_PATH_MAX_LEN];

    // remote_version means version for the FW in the cloud and to be downloaded
    char     remote_version[FW_VERSION_MAX_LEN];
    uint32_t fw_file_size;

    // for resuming download
    /* local_version means downloading but not running */
    char local_version[FW_VERSION_MAX_LEN];
    int  downloaded_size;

    // to make sure report is acked
    bool report_pub_ack;
    int  report_packet_id;

} OTAContextData;

static DeviceInfo sg_devInfo;

static void _event_handler(void *pclient, void *handle_context, MQTTEventMsg *msg)
{
    uintptr_t       packet_id = (uintptr_t)msg->msg;
    OTAContextData *ota_ctx   = (OTAContextData *)handle_context;

    switch (msg->event_type) {
        case MQTT_EVENT_UNDEF:
            Log_i("undefined event occur.");
            break;

        case MQTT_EVENT_DISCONNECT:
            Log_i("MQTT disconnect.");
            break;

        case MQTT_EVENT_RECONNECT:
            Log_i("MQTT reconnect.");
            break;

        case MQTT_EVENT_SUBCRIBE_SUCCESS:
            Log_i("subscribe success, packet-id=%u", (unsigned int)packet_id);
            break;

        case MQTT_EVENT_SUBCRIBE_TIMEOUT:
            Log_i("subscribe wait ack timeout, packet-id=%u", (unsigned int)packet_id);
            break;

        case MQTT_EVENT_SUBCRIBE_NACK:
            Log_i("subscribe nack, packet-id=%u", (unsigned int)packet_id);
            break;

        case MQTT_EVENT_PUBLISH_SUCCESS:
            Log_i("publish success, packet-id=%u", (unsigned int)packet_id);
            if (ota_ctx->report_packet_id == packet_id)
                ota_ctx->report_pub_ack = true;
            break;

        case MQTT_EVENT_PUBLISH_TIMEOUT:
            Log_i("publish timeout, packet-id=%u", (unsigned int)packet_id);
            break;

        case MQTT_EVENT_PUBLISH_NACK:
            Log_i("publish nack, packet-id=%u", (unsigned int)packet_id);
            break;
        default:
            Log_i("Should NOT arrive here.");
            break;
    }
}

static int _setup_connect_init_params(MQTTInitParams *initParams, void *ota_ctx, DeviceInfo *device_info)
{
    initParams->region      = device_info->region;
    initParams->product_id  = device_info->product_id;
    initParams->device_name = device_info->device_name;

#ifdef AUTH_MODE_CERT
//    char  certs_dir[16] = "certs";
//    char  current_path[128];
//    char *cwd = getcwd(current_path, sizeof(current_path));
//
//    if (cwd == NULL) {
//        Log_e("getcwd return NULL");
//        return QCLOUD_ERR_FAILURE;
//    }

//#ifdef WIN32
//    HAL_Snprintf(initParams->cert_file, FILE_PATH_MAX_LEN, "%s\\%s\\%s", current_path, certs_dir,
//                 device_info->dev_cert_file_name);
//    HAL_Snprintf(initParams->key_file, FILE_PATH_MAX_LEN, "%s\\%s\\%s", current_path, certs_dir,
//                 device_info->dev_key_file_name);
//#else
//    HAL_Snprintf(initParams->cert_file, FILE_PATH_MAX_LEN, "%s/%s/%s", current_path, certs_dir,
//                 device_info->dev_cert_file_name);
//    HAL_Snprintf(initParams->key_file, FILE_PATH_MAX_LEN, "%s/%s/%s", current_path, certs_dir,
//                 device_info->dev_key_file_name);
//#endif
     sprintf(initParams->cert_file, "%s", device_info->dev_cert_file_name);
     sprintf(initParams->key_file, "%s", device_info->dev_key_file_name);

#else
    initParams->device_secret = device_info->device_secret;
#endif

    initParams->command_timeout        = QCLOUD_IOT_MQTT_COMMAND_TIMEOUT;
    initParams->keep_alive_interval_ms = QCLOUD_IOT_MQTT_KEEP_ALIVE_INTERNAL;

    initParams->auto_connect_enable  = 1;
    initParams->event_handle.h_fp    = _event_handler;
    initParams->event_handle.context = ota_ctx;

    return QCLOUD_RET_SUCCESS;
}

static void _wait_for_pub_ack(OTAContextData *ota_ctx, int packet_id)
{
    int wait_cnt              = 10;
    ota_ctx->report_pub_ack   = false;
    ota_ctx->report_packet_id = packet_id;

    while (!ota_ctx->report_pub_ack) {
        HAL_SleepMs(500);
        IOT_MQTT_Yield(ota_ctx->mqtt_client, 500);
        if (wait_cnt-- == 0) {
            Log_e("wait report pub ack timeout!");
            break;
        }
    }
    ota_ctx->report_pub_ack = false;
    return;
}

/**********************************************************************************
 * OTA file operations START
 * these are platform-dependant functions
 * POSIX FILE is used in this sample code
 **********************************************************************************/
// calculate left MD5 for resuming download from break point
static int _cal_exist_fw_md5(OTAContextData *ota_ctx)
{
    char   buff[OTA_BUF_LEN];
    size_t rlen, total_read = 0, actual_rlen = 0;
    int    ret = QCLOUD_RET_SUCCESS;
	int    eof = 0;

    ret = IOT_OTA_ResetClientMD5(ota_ctx->ota_handle);
    if (ret) {
        Log_e("reset MD5 failed: %d", ret);
        return QCLOUD_ERR_FAILURE;
    }

    QFILE fp = ql_fopen(ota_ctx->fw_file_path, "ab+");
    if (fp<0) {
        Log_e("open file %s failed", ota_ctx->fw_file_path);
        return QCLOUD_ERR_FAILURE;
    }

    // rewind(fp);
    size_t size = ota_ctx->downloaded_size;

    while ((size > 0) && (!eof)) {
        rlen = (size > OTA_BUF_LEN) ? OTA_BUF_LEN : size;
		actual_rlen = ql_fread(buff, 1, rlen, fp);
		if (actual_rlen < 0) {
            Log_e("read data len not expected");
            ret = QCLOUD_ERR_FAILURE;
            break;
		} else if (actual_rlen < rlen) {
			Log_e("read end of file");
			eof = 1;
		}
        IOT_OTA_UpdateClientMd5(ota_ctx->ota_handle, buff, actual_rlen);
        size -= actual_rlen;
        total_read += actual_rlen;
    }

    ql_fclose(fp);
    Log_d("total read: %d", total_read);
    return ret;
}

/* update local firmware info for resuming download from break point */
static int _update_local_fw_info(OTAContextData *ota_ctx)
{
    QFILE fp;
    int   wlen;
    int   ret = QCLOUD_RET_SUCCESS;
    char  data_buf[FW_INFO_FILE_DATA_LEN];

    memset(data_buf, 0, sizeof(data_buf));
    HAL_Snprintf(data_buf, sizeof(data_buf), "{\"%s\":\"%s\", \"%s\":%d}", KEY_VER, ota_ctx->remote_version, KEY_SIZE,
                 ota_ctx->downloaded_size);

    fp = ql_fopen(ota_ctx->fw_info_file_path, "w");
    if (fp<0) {
        Log_e("open file %s failed", ota_ctx->fw_info_file_path);
        ret = QCLOUD_ERR_FAILURE;
        goto exit;
    }

    wlen = ql_fwrite(data_buf, 1, strlen(data_buf), fp);
    if (wlen != strlen(data_buf)) {
        Log_e("save version to file err");
        ret = QCLOUD_ERR_FAILURE;
    }

exit:

    if (fp>=0) {
        ql_fclose(fp);
    }

    return ret;
}

static int _get_local_fw_info(char *file_name, char *local_version)
{
    int  len;
    int  rlen;
    char json_doc[FW_INFO_FILE_DATA_LEN] = {0};

    QFILE fp = ql_fopen(file_name, "r");
    if (fp<0) {
        Log_e("open file %s failed", file_name);
        return 0;
    }

    ql_fseek(fp, 0L, SEEK_END);
    len = ql_ftell(fp);
    if (len > FW_INFO_FILE_DATA_LEN) {
        Log_e("%s is too big, pls check", file_name);
        ql_fclose(fp);
        return 0;
    }

    ql_frewind(fp);
    rlen = ql_fread(json_doc, 1, len, fp);
    if (len != rlen) {
        Log_e("read data len (%d) less than needed (%d), %s", rlen, len, json_doc);
        ql_fclose(fp);
        return 0;
    }

    char *version = LITE_json_value_of(KEY_VER, json_doc);
    char *size    = LITE_json_value_of(KEY_SIZE, json_doc);

    if ((NULL == version) || (NULL == size)) {
        if (version)
            HAL_Free(version);
        if (size)
            HAL_Free(size);
        ql_fclose(fp);
        return 0;
    }

    int local_size = atoi(size);
    HAL_Free(size);

    if (local_size <= 0) {
        Log_w("local info offset invalid: %d", local_size);
        HAL_Free(version);
        local_size = 0;
    }

    strncpy(local_version, version, FW_VERSION_MAX_LEN);
    HAL_Free(version);
    ql_fclose(fp);
    return local_size;
}

/* get local firmware offset for resuming download from break point */
static int _update_fw_downloaded_size(OTAContextData *ota_ctx)
{
    int local_size = _get_local_fw_info(ota_ctx->fw_info_file_path, ota_ctx->local_version);
    if (local_size == 0) {
        ota_ctx->downloaded_size = 0;
        return 0;
    }

    if ((0 != strcmp(ota_ctx->local_version, ota_ctx->remote_version)) ||
        (ota_ctx->downloaded_size > ota_ctx->fw_file_size)) {
        ota_ctx->downloaded_size = 0;
        return 0;
    }

    ota_ctx->downloaded_size = local_size;
    Log_i("calc MD5 for resuming download from offset: %d", ota_ctx->downloaded_size);
    int ret = _cal_exist_fw_md5(ota_ctx);
    if (ret) {
        Log_e("regen OTA MD5 error: %d", ret);
        ql_remove(ota_ctx->fw_info_file_path);
        ota_ctx->downloaded_size = 0;
        return 0;
    }
    Log_d("local MD5 update done!");
    return local_size;
}

static int _delete_fw_info_file(char *file_name)
{
    return ql_remove(file_name);
}

static int _save_fw_data_to_file(char *file_name, uint32_t offset, char *buf, int len)
{
    QFILE fp;
    if (offset > 0) {
        fp = ql_fopen(file_name, "ab+");
        if(fp<0)
        {
            Log_e("open file failed");
            return QCLOUD_ERR_FAILURE;
        }
    } else {
        fp = ql_fopen(file_name, "wb+");
        if(fp<0)
        {
            Log_e("open file failed");
            return QCLOUD_ERR_FAILURE;
        }
    }

    ql_fseek(fp, offset, SEEK_SET);

    if (len != ql_fwrite(buf, 1, len, fp)) {
        Log_e("write data to file failed");
        ql_fclose(fp);
        return QCLOUD_ERR_FAILURE;
    }
    //ql_fsync(fp);
    ql_fclose(fp);

    return 0;
}

static char *_get_local_fw_running_version()
{
    // asuming the version is inside the code and binary
    // you can also get from a meta file
    Log_i("FW running version: %s", FW_RUNNING_VERSION);
    return FW_RUNNING_VERSION;
}
/**********************************************************************************
 * OTA file operations END
 **********************************************************************************/

// main OTA cycle
bool process_ota(OTAContextData *ota_ctx)
{
    bool  download_finished     = false;
    bool  upgrade_fetch_success = true;
    char  buf_ota[OTA_BUF_LEN];
    int   rc;
    void *h_ota = ota_ctx->ota_handle;

    /* Must report version first */
    if (0 > IOT_OTA_ReportVersion(h_ota, _get_local_fw_running_version())) {
        Log_e("report OTA version failed");
        return false;
    }

    do {
        IOT_MQTT_Yield(ota_ctx->mqtt_client, 200);

        Log_i("wait for ota upgrade command...");

        // recv the upgrade cmd
        if (IOT_OTA_IsFetching(h_ota)) {
            IOT_OTA_Ioctl(h_ota, IOT_OTAG_FILE_SIZE, &ota_ctx->fw_file_size, 4);
            IOT_OTA_Ioctl(h_ota, IOT_OTAG_VERSION, ota_ctx->remote_version, FW_VERSION_MAX_LEN);

            HAL_Snprintf(ota_ctx->fw_file_path, FW_FILE_PATH_MAX_LEN, FW_FILE_PATH_FORMAT, ota_ctx->remote_version);
            HAL_Snprintf(ota_ctx->fw_info_file_path, FW_FILE_PATH_MAX_LEN, FW_FILE_INFO_PATH_FORMAT, ota_ctx->remote_version);

            /* check if pre-downloading finished or not */
            /* if local FW downloaded size (ota_ctx->downloaded_size) is not zero, it
             * will do resuming download */
            _update_fw_downloaded_size(ota_ctx);

            /*set offset and start http connect*/
            rc = IOT_OTA_StartDownload(h_ota, ota_ctx->downloaded_size, ota_ctx->fw_file_size);
            if (QCLOUD_RET_SUCCESS != rc) {
                Log_e("OTA download start err,rc:%d", rc);
                upgrade_fetch_success = false;
                break;
            }

            // download and save the fw
            do {
                int len = IOT_OTA_FetchYield(h_ota, buf_ota, OTA_BUF_LEN, 1);
                if (len > 0) {
                    rc = _save_fw_data_to_file(ota_ctx->fw_file_path, ota_ctx->downloaded_size, buf_ota, len);
                    if (rc) {
                        Log_e("write data to file failed");
                        upgrade_fetch_success = false;
                        break;
                    }
                } else if (len < 0) {
                    Log_e("download fail rc=%d", len);
                    upgrade_fetch_success = false;
                    break;
                }

                /* get OTA information and update local info */
                IOT_OTA_Ioctl(h_ota, IOT_OTAG_FETCHED_SIZE, &ota_ctx->downloaded_size, 4);
                rc = _update_local_fw_info(ota_ctx);
                if (QCLOUD_RET_SUCCESS != rc) {
                    Log_e("update local fw info err,rc:%d", rc);
                }

                // quit ota process as something wrong with mqtt
                rc = IOT_MQTT_Yield(ota_ctx->mqtt_client, 100);
                if (rc != QCLOUD_RET_SUCCESS && rc != QCLOUD_RET_MQTT_RECONNECTED) {
                    Log_e("MQTT error: %d", rc);
                    return false;
                }

            } while (!IOT_OTA_IsFetchFinish(h_ota));

            /* Must check MD5 match or not */
            if (upgrade_fetch_success) {
                // download is finished, delete the fw info file
                _delete_fw_info_file(ota_ctx->fw_info_file_path);

                uint32_t firmware_valid;
                IOT_OTA_Ioctl(h_ota, IOT_OTAG_CHECK_FIRMWARE, &firmware_valid, 4);
                if (0 == firmware_valid) {
                    Log_e("The firmware is invalid");
                    upgrade_fetch_success = false;
                } else {
                    Log_i("The firmware is valid");
                    upgrade_fetch_success = true;
                }
            }

            download_finished = true;
        }

        if (!download_finished)
            HAL_SleepMs(1000);

    } while (!download_finished);

    // do some post-download stuff for your need

    // report result
    int packet_id;
    if (upgrade_fetch_success)
        packet_id = IOT_OTA_ReportUpgradeSuccess(h_ota, NULL);
    else
        packet_id = IOT_OTA_ReportUpgradeFail(h_ota, NULL);
    _wait_for_pub_ack(ota_ctx, packet_id);

    return upgrade_fetch_success;
}

//static int push_fw_to_fotaPkg_area(char * fw_file_path)
//{
//	qlFotaImgProcCtxPtr ctx = NULL;
//	QFILE fp = NULL;
//	char * file_read_buf = NULL;
//	#define FILE_READ_BUF_LEN 1024
//	int ret = 0;
//	int file_size = 0;
//	int file_read_total_len = 0;
//	int result = 0;
//
//	ctx = ql_fota_init();
//	if(!ctx)
//	{
//		Log_e("*** fota init fail ***");
//		goto exit;
//	}
//
//	Log_d("fota init successfully");
//	
//	fp = ql_fopen(fw_file_path, "r");
//	if(fp<0)
//	{
//		Log_e("*** fw file open failed ***");
//		goto exit;
//	}
//
//	file_read_buf = malloc(FILE_READ_BUF_LEN);
//	if(!file_read_buf)
//	{
//		Log_e("*** heap memory is not enough ***");
//		goto exit;
//	}
//
//	file_size = ql_fsize(fp);
//	if(file_size <= 0)
//	{
//		Log_e("*** fw file is empty or corrupted ***");
//		goto exit;
//	}
//
//	Log_d("will read fw file and write image to flash");
//	
//	while((ret = ql_fread(file_read_buf, FILE_READ_BUF_LEN, 1, fp)) > 0)
//	{
//		file_read_total_len += ret;
//		
//		ret = ql_fota_image_write(ctx, (void *)file_read_buf, ret);
//		if(ret)
//		{
//			Log_e("*** fw image write fail ***");
//			goto exit;
//		}
//
//		Log_i("fw image write progress: %d%%", file_read_total_len*100/file_size);
//	}
//
//	if(ret < 0)
//	{
//		Log_e("*** fw file read fail ***");
//		goto exit;
//	}
//	
//	if(file_read_total_len)
//	{
//		ret = ql_fota_image_flush(ctx);
//		if(ret)
//		{
//			Log_e("*** fw image flush fail ***");
//			goto exit;
//		}
//		
//		Log_d("fw image write done, verifing ...");
//
//		ret = ql_fota_image_verify(ctx);
//		if(ret)
//		{
//			Log_e("*** fw image verify fail ***");
//			goto exit;
//		}
//
//		Log_d("fw image verify ok !!!");
//
//		result = 1;
//	}
//	
//exit:
//	if(ctx) ql_fota_deinit(ctx);
//	if(fp>=0) ql_fclose(fp);
//	if(file_read_buf) free(file_read_buf);
//	return result;
//}

static int datacall_satrt(void)
{
    int ret = 0;
    int i = 0;
    ql_data_call_info_s info;
    char ip4_addr_str[16] = {0};
    uint8_t nSim = 0;

    ql_rtos_task_sleep_s(10);

    Log_e("wait for network register done");

    while ((ret = ql_network_register_wait(nSim, 120)) != 0 && i < 10)
    {
        i++;
        ql_rtos_task_sleep_s(1);
    }
    if (ret == 0)
    {
        i = 0;
        Log_e("====network registered!!!!====");
    }
    else
    {
        Log_e("====network register failure!!!!!====");
        goto exit;
    }

    ql_set_data_call_asyn_mode(nSim, PROFILE_IDX, 0);

    Log_e("===start data call====");
    ret = ql_start_data_call(nSim, PROFILE_IDX, QL_PDP_TYPE_IP, "uninet", NULL, NULL, 0);
    Log_e("===data call result:%d", ret);
    if (ret != 0)
    {
        Log_e("====data call failure!!!!=====");
    }
    memset(&info, 0x00, sizeof(ql_data_call_info_s));

    ret = ql_get_data_call_info(nSim, PROFILE_IDX, &info);
    if (ret != 0)
    {
        Log_e("ql_get_data_call_info ret: %d", ret);
        ql_stop_data_call(nSim, PROFILE_IDX);
        goto exit;
    }
    
    Log_i("info.profile_idx: %d", info.profile_idx);
    Log_i("info.ip_version: %d", info.ip_version);
    Log_i("info.v4.state: %d", info.v4.state);
    //Log_i("info.v4.reconnect: %d", info.v4.reconnect);
    
    inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
    Log_i("info.v4.addr.ip: %s", ip4_addr_str);
    
    inet_ntop(AF_INET, &info.v4.addr.pri_dns, ip4_addr_str, sizeof(ip4_addr_str));
    Log_i("info.v4.addr.pri_dns: %s", ip4_addr_str);
    
    inet_ntop(AF_INET, &info.v4.addr.sec_dns, ip4_addr_str, sizeof(ip4_addr_str));
    Log_i("info.v4.addr.sec_dns: %s", ip4_addr_str);

    return 0;
exit:
    return -1;
}

void ota_mqtt_sample(void *param)
{
    int             rc, result = 0;
    OTAContextData *ota_ctx     = NULL;
    void *          mqtt_client = NULL;
    void *          h_ota       = NULL;

    IOT_Log_Set_Level(eLOG_DEBUG);
    ota_ctx = (OTAContextData *)HAL_Malloc(sizeof(OTAContextData));
    if (ota_ctx == NULL) {
        Log_e("malloc failed");
        goto exit;
    }
    memset(ota_ctx, 0, sizeof(OTAContextData));
    
	/*执行拨号操作，设备联网*/
	if(datacall_satrt() != 0)
	{
		goto exit;
	}

#ifdef DEBUG_DEV_INFO_USED
	DeviceInfo devInfo = 
    {
		.product_id = PRODUCT_ID,
		.device_name = DEVICE_NAME,
		.client_id = ""PRODUCT_ID"_"DEVICE_NAME"",
		.region = REGION,
		.dev_type = eCOMMON_DEV,
	};
#ifndef AUTH_MODE_CERT
             device_info_copy(devInfo.device_secret, DEVICE_SECRET,MAX_SIZE_OF_DEVICE_SECRET);  // set dev cert file name,
#else
             device_info_copy(devInfo.dev_cert_file_name, DEVICE_CERT,MAX_SIZE_OF_DEVICE_CERT_FILE_NAME);  // set dev cert file name
             device_info_copy(devInfo.dev_key_file_name, DEVICE_PRIVATE,MAX_SIZE_OF_DEVICE_SECRET_FILE_NAME);  // set dev cert file name
#endif
	HAL_SetDevInfo(&devInfo);
	rc = HAL_GetDevInfo((void *)&sg_devInfo);
#else
	rc = HAL_GetDevInfoFromFile(DEVICE_INFO_JSON_DOC, (void *)&sg_devInfo);
#endif
    if (QCLOUD_RET_SUCCESS != rc) {
        Log_e("get device info failed: %d", rc);
        goto exit;
    }

    // setup MQTT init params
    MQTTInitParams init_params = DEFAULT_MQTTINIT_PARAMS;
    rc                         = _setup_connect_init_params(&init_params, ota_ctx, &sg_devInfo);
    if (rc != QCLOUD_RET_SUCCESS) {
        Log_e("init params err,rc=%d", rc);
        ql_rtos_task_delete(NULL);
    }

    // create MQTT mqtt_client and connect to server
    mqtt_client = IOT_MQTT_Construct(&init_params);
    if (mqtt_client != NULL) {
        Log_i("Cloud Device Construct Success");
    } else {
        Log_e("Cloud Device Construct Failed");
        ql_rtos_task_delete(NULL);
    }

    // init OTA handle
    h_ota = IOT_OTA_Init(init_params.profile_idx, sg_devInfo.product_id, sg_devInfo.device_name, mqtt_client);
    if (NULL == h_ota) {
        Log_e("initialize OTA failed");
        goto exit;
    }

    ota_ctx->ota_handle  = h_ota;
    ota_ctx->mqtt_client = mqtt_client;

    bool ota_success;
    do {
        // mqtt should be ready first
        rc = IOT_MQTT_Yield(mqtt_client, 500);
        if (rc == QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT) {
            HAL_SleepMs(1000);
            continue;
        } else if (rc != QCLOUD_RET_SUCCESS && rc != QCLOUD_RET_MQTT_RECONNECTED) {
            Log_e("exit with error: %d", rc);
            break;
        }

        // OTA process
        ota_success = process_ota(ota_ctx);
        if (!ota_success) {
            Log_e("OTA failed! Do it again");
            HAL_SleepMs(2000);
        }
    } while (!ota_success);

	//result = push_fw_to_fotaPkg_area(ota_ctx->fw_file_path);

exit:

    if (NULL != ota_ctx)
    {
        HAL_Free(ota_ctx);
    }
    if (NULL != h_ota)
    {
        IOT_OTA_Destroy(h_ota);
    }
    if(NULL != mqtt_client)
    {
        IOT_MQTT_Destroy(&mqtt_client);
    }
	if(result)
	{
		Log_d("will restart to update ...");
		ql_power_reset(RESET_NORMAL);
	}
    ql_rtos_task_delete(NULL);
}

//static void ql_nw_status_callback(int profile_idx, int nw_status)
//{
//	Log_i("profile(%d) status: %d", profile_idx, nw_status);
//}
//static int datacall_satrt(void)
//{
//	struct ql_data_call_info info = {0};
//	char ip4_addr_str[16] = {0};
//	
//	Log_d("wait for network register done");
//
//	if(ql_network_register_wait(120) != 0)
//	{
//		Log_e("*** network register fail ***");
//		return -1;
//	}
//	else
//	{
//		Log_d("doing network activating ...");
//		
//		ql_wan_start(ql_nw_status_callback);
//		ql_set_auto_connect(PROFILE_IDX, TRUE);
//		if(ql_start_data_call(PROFILE_IDX, 0, "3gnet.mnc001.mcc460.gprs", NULL, NULL, 0) == 0)
//		{
//			ql_get_data_call_info(PROFILE_IDX, 0, &info);
//			
//			Log_i("info.profile_idx: %d", info.profile_idx);
//			Log_i("info.ip_version: %d", info.ip_version);
//			Log_i("info.v4.state: %d", info.v4.state);
//			Log_i("info.v4.reconnect: %d", info.v4.reconnect);
//			
//			inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
//			Log_i("info.v4.addr.ip: %s", ip4_addr_str);
//			
//			inet_ntop(AF_INET, &info.v4.addr.pri_dns, ip4_addr_str, sizeof(ip4_addr_str));
//			Log_i("info.v4.addr.pri_dns: %s", ip4_addr_str);
//			
//			inet_ntop(AF_INET, &info.v4.addr.sec_dns, ip4_addr_str, sizeof(ip4_addr_str));
//			Log_i("info.v4.addr.sec_dns: %s", ip4_addr_str);
//
//			return 0;
//		}
//
//		Log_e("*** network activated fail ***");
//		return -1;
//	}
//}

//int ota_mqtt_sample_start(void)
//{
//	ql_task_t ota_mqtt_sample_task = NULL;
//
//	if(datacall_satrt() == 0)
//		return ql_rtos_task_create(&ota_mqtt_sample_task, 12*1024, 100, "ota_mqtt_sample", main_entry, NULL);
//
//	return -1;
//}
int ota_mqtt_sample_start(void)
{
    int err = 0;
    int count = 0;
   	ql_task_t ota_mqtt_sample_task = NULL;
    /* 主循环进入休眠 */
    while (count < 10)
    {
        count++;
        ql_rtos_task_sleep_s(1);
        Log_e("ql_qcloud_sdk_ota_mqtt_sample_start_init  -0x%04X\n", err);
    }
	err = ql_rtos_task_create(&ota_mqtt_sample_task, 10*1024, APP_PRIORITY_NORMAL, "ota_mqtt", ota_mqtt_sample, NULL, 5);
	
	if (err != QL_OSI_SUCCESS)
	{
        return -1;
	}
    return 0;
}