/*==========================================================================================================
  Copyright (c) 2025, Quectel Wireless Solutions Co., Ltd. All rights reserved.
  Quectel Wireless Solutions Proprietary and Confidential.
===========================================================================================================*/
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include "ql_wifi.h"
#include "ql_application.h"
#include "ql_log.h"
#include "ql_rtos.h"
#include "ql_nw.h"
#include "ql_uart.h"
#include "ql_gpio.h"
#include "ql_spi.h"
#include "sockets.h"
#include "ip4_addr.h"
#include "ql_data_call.h"
#include "ql_ping.h"
#include "ql_fs.h"
#include "ql_http_client.h"

#if 0
// EC800MCNLE+FGM842D
#define QL_WIFI_LDO_GPIO            GPIO_PIN_NO_27     
#define QL_WIFI_CHIP_EN_GPIO        GPIO_PIN_NO_31     
#define QL_WIFI_SPI_PORT            QL_SPI_PORT0
#define QL_WIFI_SPI_CS_GPIO         GPIO_PIN_NO_17
#define QL_WIFI_SPI_SLAVE_CTS_GPIO  GPIO_PIN_NO_53
#define QL_WIFI_SPI_SLAVE_RDY_GPIO  GPIO_PIN_NO_54
#define QL_WIFI_SPI_CLK             QL_SPI_CLK_13MHZ
#define QL_WIFI_SPI_MODE            QL_SPI_MODE0
#else
// EG800AKCN91LC+FGM842D
#define QL_WIFI_LDO_GPIO             GPIO_PIN_NO_84   
#define QL_WIFI_CHIP_EN_GPIO         GPIO_PIN_NO_85   
#define QL_WIFI_SPI_PORT             SPI_PORT2
#define QL_WIFI_SPI_CS_GPIO          GPIO_PIN_NO_13
#define QL_WIFI_SPI_SLAVE_CTS_GPIO   GPIO_PIN_NO_90
#define QL_WIFI_SPI_SLAVE_RDY_GPIO   GPIO_PIN_NO_89
#define QL_WIFI_SPI_CLK              SPI_CLK_13MHZ
#define QL_WIFI_SPI_MODE             SPI_MODE0
#endif
#define QL_WIFI_UART_PORT            QL_MAIN_UART_PORT

#define QL_WIFI_DEMO_SOCKET_BUF_SIZE (128)
#define QL_WIFI_STA_MODE_CID 2

static char send_buf[QL_WIFI_DEMO_SOCKET_BUF_SIZE] = {0};
static int send_len = 0;
static char recv_buf[QL_WIFI_DEMO_SOCKET_BUF_SIZE] = {0};
static int recv_len = 0;

static ql_queue_t wifi_msg_queue = NULL;
static ql_task_t wifi_tcp_task = NULL;

typedef struct
{
	char ssid[QL_WIFI_SSID_MAX_LEN];
	char password[QL_WIFI_PASSWORD_MAX_LEN];
} ql_wifi_app_user_ap_info_s;

#include "ql_wifi_ble.h"

#define QL_WIFI_BLE_COMMAND_DELAY_MS  1000
static ql_queue_t wifi_ble_msg_queue = NULL;
static ql_wifi_ble_send_data_info_s ql_wifi_ble_send_data_info = {0};

typedef enum
{
    QL_WIFI_DEMO_BLE_OPEN = 0,
    QL_WIFI_DEMO_BLE_CLOSE,
    QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN,
    QL_WIFI_DEMO_BLE_WIFI_OPEN,
    QL_WIFI_DEMO_BLE_DATA_SEND,
    QL_WIFI_DEMO_BLE_ADV_RESTART,
} ql_wifi_demo_ble_state_e;

typedef struct
{
    ql_wifi_demo_ble_state_e state;
} ql_wifi_demo_ble_msg_s;

static void ql_wifi_demo_ble_send_msg(ql_wifi_demo_ble_state_e state)
{
    ql_wifi_demo_ble_msg_s msg = 
    {
        .state = state,
    };
    if (wifi_ble_msg_queue)
    {
        ql_rtos_queue_release(wifi_ble_msg_queue, sizeof(ql_wifi_demo_ble_msg_s), (uint8 *)&msg, QL_NO_WAIT);
    }
    return;
}

static void ql_wifi_hardware_reset(void)
{
    ql_gpio_set_level(QL_WIFI_CHIP_EN_GPIO, PIN_LEVEL_HIGH);
    ql_rtos_task_sleep_ms(100);
    ql_gpio_set_level(QL_WIFI_CHIP_EN_GPIO, PIN_LEVEL_LOW);

}

static void ql_wifi_callback(ql_wifi_ind_t *ctx)
{
    ql_wifi_ind_t wifi_ind = {0};
    memcpy(&wifi_ind, ctx, sizeof(ql_wifi_ind_t));
    if (wifi_msg_queue)
    {
        ql_rtos_queue_release(wifi_msg_queue, sizeof(ql_wifi_ind_t), (uint8 *)&wifi_ind, QL_NO_WAIT);
    }
    return;
}

static void ql_wifi_link_info_callback(void *ctx)
{
    ql_wifi_link_info_t *info = (ql_wifi_link_info_t *)ctx;
    
    printf("\r\nconne_state:%d, wifi_strength:%d", info->conn_state, info->wifi_strength);
    
    printf("\r\nssid:%s, bssid=%02X:%02X:%02X:%02X:%02X:%02X", info->ssid, \
                     info->bssid[0], info->bssid[1], info->bssid[2], \
                     info->bssid[3], info->bssid[4], info->bssid[5]);
    printf("\r\naid:%hu, channel:%d, security:%d\r\n", info->aid, info->channel, info->security);
}


static void ql_wifi_scan_callback(void *ctx)
{
    ql_wifi_scan_result_s *scan_result = (ql_wifi_scan_result_s *)ctx;
    ql_wifi_ap_info_s *ApList = scan_result->ApList;
    printf("scan_result->ApNum:%d\n", scan_result->ApNum);
    for (int i = 0; i < scan_result->ApNum; i++)
    {
        printf("ssid:%s,ap_power:%d,bssid=%02X:%02X:%02X:%02X:%02X:%02X,channel=%d,security=%s\n",
               ApList->ssid,
               ApList->ap_power,
               ApList->bssid[0],ApList->bssid[1],ApList->bssid[2],ApList->bssid[3],ApList->bssid[4],ApList->bssid[5],
               ApList->channel,
               ApList->security);

        ApList++;
    }
}

void ql_wifi_ldo_ctrl(int val)
{
    ql_gpio_init(QL_WIFI_LDO_GPIO,     PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
	ql_gpio_init(QL_WIFI_CHIP_EN_GPIO, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
    ql_gpio_set_level(QL_WIFI_LDO_GPIO, val);
    ql_rtos_task_sleep_ms(100);
}

static void ql_wifi_tcp_client_thread(void)
{
	int ret = 0;
    int i = 0;
    int flags = 0;
    int connected = 0;
    int socket_fd = -1;
    fd_set read_fds;
    fd_set write_fds;
    fd_set exp_fds;
    int fd_changed = 0;
    int closing = false;
    struct sockaddr_in local4, server_ipv4;
    ip_addr_t ip = {0};
    char ip4_addr_str[16] = {0};
    struct ql_data_call_info info = {0};

    uint8_t destip[] = {112, 31, 84, 164};
    uint16_t destport = 8305;
    ip_addr_t int_destip;
    IP4_ADDR(&int_destip, destip[0], destip[1], destip[2], destip[3]);

    ql_get_data_call_info(QL_WIFI_STA_MODE_CID, 0, &info);
    inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
    printf("info.v4.addr.ip: %s\r\n", ip4_addr_str);

    inet_aton(ip4_addr_str, &ip);

    memset(&local4, 0x00, sizeof(struct sockaddr_in));
    local4.sin_family = AF_INET;
    local4.sin_port = 2345;
    memcpy(&local4.sin_addr, &ip.addr, sizeof(ip_addr_t));

    FD_ZERO(&read_fds);
    FD_ZERO(&write_fds);
    FD_ZERO(&exp_fds);

    printf("socket start!\r\n");
    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd < 0)
    {
        printf("*** socket create fail ***\r\n");
        goto exit;
    }
    ret = bind(socket_fd, (struct sockaddr *)&local4, sizeof(struct sockaddr));
    if (ret < 0)
    {
        printf("*** bind fail ***\r\n");
        close(socket_fd);
        socket_fd = -1;
        goto exit;
    }
    flags |= O_NONBLOCK; // set nonblock
    fcntl(socket_fd, F_SETFL, flags);
    memset(&server_ipv4, 0x00, sizeof(struct sockaddr_in));
    server_ipv4.sin_family = AF_INET;
    server_ipv4.sin_port = htons(destport);
    memcpy(&(server_ipv4.sin_addr), &int_destip, sizeof(int_destip));
    ret = connect(socket_fd, (struct sockaddr *)&server_ipv4, sizeof(server_ipv4));
    if (ret == 0)
    {
        connected = 1;
        printf("\r\n[%s][%d]tcp connected\r\n", __func__, __LINE__);
    }
    else
    {
        if (ql_get_soc_errno() != EINPROGRESS) // 115
        {
            printf("\r\n[%s][%d]tcp connect failed\r\n", __func__, __LINE__);
            close(socket_fd);
            socket_fd = -1;
            goto exit;
        }

        FD_SET(socket_fd, &write_fds); // write_fds
    }

    FD_SET(socket_fd, &exp_fds); // exp_fds

    printf("\r\n[%s][%d]into while\r\n", __func__, __LINE__);
    while (1)
    {
        fd_changed = select(socket_fd + 1, &read_fds, &write_fds, &exp_fds, NULL);  // &tv
        printf("\r\n[%s][%d]select\r\n", __func__, __LINE__);
        if (fd_changed > 0)
        {
            if (FD_ISSET(socket_fd, &write_fds))
            {
                FD_CLR(socket_fd, &write_fds);
                if (connected == 0)
                {
                    int value = 0;
                    char con[128] = {0};
                    u32_t len = sizeof(value);
                    getsockopt(socket_fd, SOL_SOCKET, SO_ERROR, &value, &len);
                    if (value == 0 || value == EISCONN)
                    {
                        printf("\r\n[%s][%d]tcp connected\r\n", __func__, __LINE__);
                        connected = 1;
                        FD_SET(socket_fd, &read_fds); // read_fds
                        len = snprintf(con, 128, "tcp connected\r\n");
                        write(socket_fd, con, len);
                    }
                    else
                    {
                        printf("\r\n[%s][%d]tcp connect failed\r\n", __func__, __LINE__);
                        close(socket_fd);
                        socket_fd = -1;
                        break;
                    }
                }
                else // seldom go here
                {
                    printf("\r\n[%s][%d]1234\r\n", __func__, __LINE__);
                    memset(send_buf, 0x00, 128);
                    send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "#!&*1234end", i);
                    write(socket_fd, send_buf, send_len);
                    i++;
                }
            } // write_fds
            else if (FD_ISSET(socket_fd, &read_fds))
            {
                FD_CLR(socket_fd, &read_fds);
                memset(recv_buf, 0x00, 128);
                recv_len = read(socket_fd, recv_buf, 128);
                if (recv_len > 0)
                {
                    printf("\r\n[%s][%d]recv: %s\r\n", __func__, __LINE__, recv_buf);
                    if(i++ > 1) 
                        goto exit;
                    memset(send_buf, 0x00, 128);
                    send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "]Quectel[", i);
                    write(socket_fd, send_buf, send_len);
                    ql_rtos_task_sleep_s(2);
                    FD_SET(socket_fd, &read_fds);
                }
                else if (recv_len == 0)
                {
                    if (closing == false)
                    {
                        printf("\r\n[%s][%d]shut down\r\n", __func__, __LINE__);
                        shutdown(socket_fd, SHUT_WR);
                        closing = true;
                        FD_SET(socket_fd, &read_fds);
                    }
                    else
                    {
                        printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
                        close(socket_fd);
                        socket_fd = -1;
                        break;
                    }
                }
                else
                {
                    if (ql_get_soc_errno() == EAGAIN)
                    {
                        FD_SET(socket_fd, &read_fds);
                    }
                    else
                    {
                        printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
                        close(socket_fd);
                        socket_fd = -1;
                        break;
                    }
                }
            } // read_fds
            else if (FD_ISSET(socket_fd, &exp_fds))
            {
                FD_CLR(socket_fd, &exp_fds);
                printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
                close(socket_fd);
                socket_fd = -1;
                break;
            } // exp_fds
        } // if (fd_changed > 0)
    } // while(1)
    printf("\r\n[%s][%d]next to exit\r\n", __func__, __LINE__);
exit:
    printf("wifi tcp client end\r\n");
    close(socket_fd);

    ql_wifi_psm_info wifi_psm_cfg = {0};
    wifi_psm_cfg.mode   = 2;
    wifi_psm_cfg.enable = 1;
    wifi_psm_cfg.para   = 10;
    ret = ql_wifi_app_psm(&wifi_psm_cfg);
    printf("\r\n[ql_wifi_app_psm]ret[%d]\r\n", ret);

    wifi_tcp_task = NULL;
    ql_rtos_task_delete(NULL);
}

static void ql_842d_sta_test(void *argv)
{
    int ret = 0;
    char *ssid = "Visitor-QuecteK";
    char *password = "v@quectel";
    ql_wifi_ind_t ql_wifi_status = {0};
    char wifi_version[64] = {0};
	
    ql_wifi_config_t wifi_config = {0};
    /* Hardware-related configuration*/
    wifi_config.port_cfg = QL_WIFI_PORT_SPI_UART;
    wifi_config.spi_config.port = QL_WIFI_SPI_PORT;
    wifi_config.spi_config.clk = QL_WIFI_SPI_CLK;
    wifi_config.spi_config.mode = QL_WIFI_SPI_MODE;
    wifi_config.spi_config.cs = QL_WIFI_SPI_CS_GPIO;
    wifi_config.spi_config.slave_rdy = QL_WIFI_SPI_SLAVE_RDY_GPIO;
    wifi_config.spi_config.slave_cts = QL_WIFI_SPI_SLAVE_CTS_GPIO;
    wifi_config.uart_port = QL_WIFI_UART_PORT;

    /* Software-related configuration */
    wifi_config.mode = QL_WIFI_MODE_STA;
    wifi_config.simid = 0;
    wifi_config.cid = QL_WIFI_STA_MODE_CID;
    wifi_config.auth_type = QL_WIFI_AUTH_TYPE_WPA_WPA2;
    memcpy(wifi_config.ssid, ssid, strlen(ssid) + 1);
    memcpy(wifi_config.password, password, strlen(password) + 1);     // QL_WIFI_AUTH_TYPE_WPA_WPA2 
    // memset(wifi_config.password, 0, sizeof(wifi_config.password)); // QL_WIFI_AUTH_TYPE_NONE
    printf("\r\n[%s][%d]passwd strlen[%d]\r\n", __func__, __LINE__, strlen(wifi_config.password));

    // Set log port
    ql_log_mask_set(QL_LOG_APP_MASK, QL_LOG_PORT_UART);
    printf("ql_wifi_sta_test\n");

    /* Create msg queue. */
    if (0 != ql_rtos_queue_create(&wifi_msg_queue, sizeof(ql_wifi_ind_t), 10))
    {
        printf("ql_rtos_queue_create failed");
    }

    ql_uart_close(QL_WIFI_UART_PORT);

    ret = ql_wifi_set_config(&wifi_config);
    if (ret == -1)
    {
        printf("ql_wifi_set_config failed\n");
        return;
    }

    ql_wifi_ldo_ctrl(true);
    ql_wifi_hardware_reset();

    printf("reset wifi\n");
    // wait wifi reset ok
    ql_rtos_task_sleep_s(1);

    ql_wifi_get_version(wifi_version, sizeof(wifi_version));
    printf("wifi version=%s\n", wifi_version);

    // Start wifi as station mode
    ret = ql_wifi_open(ql_wifi_callback);
    printf("ql_wifi_open %d\n", ret);

    ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
    ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_OPEN);    // enable ble

    while (1)
    {
        ret = ql_rtos_queue_wait(wifi_msg_queue, (uint8_t *)&ql_wifi_status, sizeof(ql_wifi_ind_t), 5*1000); // 5*1000 QL_WAIT_FOREVER
        if (ret != 0)
        {
            printf("\r\n[%s][%d]queue ret[%d]\r\n", __func__, __LINE__, ret);
            ql_wifi_app_sta_link_info(ql_wifi_link_info_callback);
            continue;
        }

        printf("ind_type=%d, wifi status=%d, mac=%s\n", ql_wifi_status.ind_type ,ql_wifi_status.state, ql_wifi_status.mac_str);
        switch (ql_wifi_status.state)
        {
            case QL_WIFI_IND_STATE_CONNECTED:
            {
                if (wifi_tcp_task == NULL)
                {
                    ret = ql_rtos_task_create(&wifi_tcp_task, 4096, 100, "wifi_tcp", ql_wifi_tcp_client_thread, NULL, 0);
                }
                break;
            }
            case QL_WIFI_IND_STATE_DISCONNECT:
            default:
            {
                break;
            }
        }
    }
}


static int ql_wifi_demo_ble_gatt_data_parse(void* in_info,ql_wifi_app_user_ap_info_s *out_info)
{
    if(!in_info || !out_info)
    {
        return -1;
    }

    uint8_t *ptr = (uint8_t*)in_info;
    uint8_t uuid_len = *(uint8_t*)ptr;
    printf("wifi ble uuid_len %d",uuid_len);
    if(2 != uuid_len && 16 != uuid_len)
    {
        return -1;
    }
    ptr += sizeof(uuid_len);

    uint8_t uuid[16] = {0};
    char uuid_str[32] = {0};
    memcpy((void*)uuid,(void*)ptr,uuid_len);
    for(uint8_t i = 0; i < uuid_len;i++)
    {
        sprintf((char*)uuid_str,"%02X",uuid[i]);
    }
    printf("wifi ble uuid %s",uuid_str);

    ptr += uuid_len;
    /* Move to data_len */
    uint16_t data_len = *(uint16_t*)ptr;
    printf("wifi ble data_len %d",data_len);
    if(data_len > QL_WIFI_SSID_MAX_LEN + QL_WIFI_PASSWORD_MAX_LEN)
    {
        return -1;
    }

    ptr += sizeof(data_len);
    printf("wifi ble peek %02x %02x %02x %02x",ptr[0],ptr[1],ptr[2],ptr[3]);

    ql_wifi_app_user_ap_info_s ap_info = {0};
    uint8_t ssid_len = ptr[0];
    uint8_t password_len = ptr[0 + 1 + ssid_len];
    printf("wifi ble len %d/%d/%d/%d",data_len,ssid_len,password_len,ssid_len + password_len + 2);
    if(data_len != ssid_len + password_len + 2)
    {
        return -1;
    }
    memcpy((void*)ap_info.ssid,(void*)(&ptr[1]),ssid_len);
    memcpy((void*)ap_info.password,(void*)(&ptr[1 + ssid_len + 1]),password_len);
    *out_info = ap_info;

    return 0;
}

static void ql_wifi_demo_ble_gatt_data_callback(void* ctx)
{
    uint8_t *ptr = (uint8_t*)ctx;
    uint8_t uuid_len = *(uint8_t*)ptr;
    ptr += sizeof(uuid_len);
    ptr += uuid_len;
    uint16_t data_len = *(uint16_t*)ptr;

    printf("\r\n[%s][%d]data_len[%d]\r\n", __func__, __LINE__,data_len);

    ql_wifi_app_user_ap_info_s ap_user_info = {0};
    
    ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_DATA_SEND);

    // Visitor-Quectel          56697369746f722d5175656374656c
    // v@quectel                76407175656374656c
    // 0f56697369746f722d5175656374656c0976407175656374656c
    if(0 != ql_wifi_demo_ble_gatt_data_parse(ctx,&ap_user_info))
    {
        printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
        return;
    }
    printf("ssid = [%s], pwd = [%s]", ap_user_info.ssid, ap_user_info.password);

    ql_wifi_config_t wifi_config = {0};
    /* Software-related config */ 
    wifi_config.mode = QL_WIFI_MODE_STA;
    wifi_config.simid = 0;
    wifi_config.cid = QL_WIFI_STA_MODE_CID;
    wifi_config.auth_type = QL_WIFI_AUTH_TYPE_WPA_WPA2; 
    memcpy(wifi_config.ssid, ap_user_info.ssid, strlen(ap_user_info.ssid) + 1);
    memcpy(wifi_config.password, ap_user_info.password, strlen(ap_user_info.password) + 1);
    if ((ql_wifi_set_config(&wifi_config)) == -1)
    {
        printf("ql_wifi_set_config failed\n");
        return;
    }
    ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN);

    return;
}

static void ql_wifi_demo_ble_gatt_link_callback(void* ctx)
{
    ql_wifi_ble_msg_e msg = *(ql_wifi_ble_msg_e*)ctx;
    switch(msg)
    {
        case QL_WIFI_BLE_MSG_CONNECTED:
        {
            printf("wifi ble conn"); 
            break;
        }
        case QL_WIFI_BLE_MSG_DISCONNECTED:
        {
            printf("wifi ble disconn");
            ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_ADV_RESTART); 
            break;
        }
        case QL_WIFI_BLE_MSG_MTU_UPDATED:
        {
            uint16_t mtu = *((uint16_t*)(((ql_wifi_ble_gatt_link_ctx_s*)ctx)->value));
            printf("wifi ble mtu updated %d",mtu);
            break;
        }
        default:
        {
            printf("link unknown msg");
            break;
        };
    }
    return;
}

static void ql_wifi_demo_ble_init()
{
    int ret = 0;
    ql_wifi_ble_service_info_s ble_service = {0};
    ble_service.uuid_len = 2;
    ble_service.uuid[0] = 0xFF;
    ble_service.uuid[1] = 0xF1;
    ret = ql_wifi_ble_init(&ble_service);
    printf("ql_wifi_ble_init ret = %x",ret);

    ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
    ql_wifi_ble_service_info_s ble_characteristic = {0};
    ble_characteristic.uuid_len = 2;
    ble_characteristic.uuid[0] = 0xFF;
    ble_characteristic.uuid[1] = 0xF2;
    ret = ql_wifi_ble_set_characteristic(&ble_characteristic);
    printf("ql_wifi_ble_set_characteristic ret = %x", ret);

    /* Update uuid16_data_buf */
    if(2 == ble_characteristic.uuid_len)
    {
        ql_wifi_ble_send_data_info.uuid_len = ble_characteristic.uuid_len;
        memcpy((void*)ql_wifi_ble_send_data_info.uuid,(void*)ble_characteristic.uuid,ble_characteristic.uuid_len);
    }

    ql_wifi_ble_register_gatt_data_cb(ql_wifi_demo_ble_gatt_data_callback);
    ql_wifi_ble_register_gatt_link_cb(ql_wifi_demo_ble_gatt_link_callback);

    ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
    ql_wifi_ble_set_name("quectel_wifi_ble");
    ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
    ql_wifi_ble_adv_start(NULL);
}

static void ql_wifi_ble_test(void *argv)
{
    ql_task_t taskRef  =NULL;
    u8 wifi_ble_task_priority;

    /* Create msg queue. */
    if (0 != ql_rtos_queue_create(&wifi_ble_msg_queue, sizeof(ql_wifi_ind_t), 10))
    {
        printf("ql_rtos_queue_create failed");
    }else
    {
        ql_rtos_task_get_current_ref(&taskRef);
        ql_rtos_task_get_priority(taskRef, &wifi_ble_task_priority);
        printf("\r\n[%s][%d]priority[%d]\r\n", __func__, __LINE__,wifi_ble_task_priority);
    }

    int ret = 0;
    ql_wifi_demo_ble_msg_s ql_wifi_demo_ble_msg = {0};
    ql_wifi_link_info_t info = {0};

    while (1)
    {
        ret = ql_rtos_queue_wait(wifi_ble_msg_queue, (uint8_t *)&ql_wifi_demo_ble_msg, sizeof(ql_wifi_demo_ble_msg_s), QL_WAIT_FOREVER);
        switch (ql_wifi_demo_ble_msg.state)
        {
            case QL_WIFI_DEMO_BLE_OPEN: 
            {
                ql_wifi_demo_ble_init();
                ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
                break;
            }
            case QL_WIFI_DEMO_BLE_CLOSE: 
            {
                ql_wifi_ble_adv_stop(NULL);
                ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
                ql_wifi_ble_deinit(NULL);
                break;
            }
            case QL_WIFI_DEMO_BLE_ADV_RESTART:
            {
                ql_wifi_ble_adv_start(NULL);;
                break;
            }
            case QL_WIFI_DEMO_BLE_WIFI_OPEN:
            {
                ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
                ret = ql_wifi_open(ql_wifi_callback);
                printf("ql_wifi_open %d", ret);
                break;
            }
            case QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN:
            {
                ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
                ret = ql_wifi_close();
                printf("ql_wifi_close %d", ret);
                ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_WIFI_OPEN);
                break;
            }
            case QL_WIFI_DEMO_BLE_DATA_SEND:
            {
                /* Data test */
                ql_wifi_ble_data_info_s ble_data = {0};
                ble_data.data_len = strlen("wifi ble send data");
                /* MAX:MTU-3, default: 20 */
                uint32_t mtu_3 = 20;
                if(ble_data.data_len > mtu_3)
                {
                    printf("wifi ble data overflow");
                    break;
                }
                strcpy((char *)ble_data.data, "wifi ble send data");

                /* uuid has been set in ql_wifi_demo_ble_init. */
                ql_wifi_ble_send_data_info.data_len = ble_data.data_len;
                ql_wifi_ble_send_data_info.data = (uint8_t *)ble_data.data;
                printf("\r\ndata info:%d/0x%X%X/%d/%s/0x%x\r\n",ql_wifi_ble_send_data_info.uuid_len
                                                        ,ql_wifi_ble_send_data_info.uuid[0],ql_wifi_ble_send_data_info.uuid[1]
                                                        ,ql_wifi_ble_send_data_info.data_len
                                                        ,(char*)ql_wifi_ble_send_data_info.data
                                                        ,       ql_wifi_ble_send_data_info.data);
                ql_wifi_ble_sent_gatt_data(&ql_wifi_ble_send_data_info);
                break;
            }
            default:
            {
                printf("\r\nble_msg[%d] is not define\r\n", ql_wifi_demo_ble_msg.state);
                break;
            }
        }
    }

}

// application_init(ql_842d_sta_test, "842d_sta", 10, 100);
// application_init(ql_wifi_ble_test, "wifi_ble", 10, 100);