/**
 *!
 * \file        b_drv_esp12f.c
 * \version     v0.0.1
 * \date        2020/02/05
 * \author      Bean(notrynohigh@outlook.com)
 *******************************************************************************
 * @attention
 *
 * Copyright (c) 2020 Bean
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *******************************************************************************
 */

/*Includes ----------------------------------------------*/
#include "drivers/inc/b_drv_esp12f.h"

#include <stdio.h>

#include "core/inc/b_task.h"
#include "utils/inc/b_util_at.h"
#include "utils/inc/b_util_log.h"
#include "utils/inc/b_util_memp.h"
/**
 * \addtogroup BABYOS
 * \{
 */

/**
 * \addtogroup B_DRIVER
 * \{
 */

/**
 * \addtogroup ESP12F
 * \{
 */

/**
 * \defgroup ESP12F_Private_Defines
 * \{
 */
#define DRIVER_NAME ESP12F

#ifndef ESP12F_CMD_BUF_LEN
#define ESP12F_CMD_BUF_LEN (128)
#endif  // !ESP12F_CMD_BUF_LEN

#ifndef ESP12F_CMD_TIMEOUT
#define ESP12F_CMD_TIMEOUT (5000)
#endif

#define ESP12F_CONN_NUM_MAX (5)

#define ESP12F_CMD_RESET_BIT (0x01)
#define ESP12F_CMD_INIT_BIT (0x02)

#define ESP12F_CMD_RESULT_OK (0x01)
#define ESP12F_CMD_RESULT_FAIL (0x02)

#ifndef CONNECT_RECVBUF_MAX
#define CONNECT_RECVBUF_MAX (1024)
#endif

/**
 * \}
 */

/**
 * \defgroup ESP12F_Private_TypesDefinitions
 * \{
 */

typedef char *(*pbAtCmdFunc_t)(void *prv);
typedef void (*pbRelease_t)(void *p);
typedef struct
{
    char         *pcmd;
    char         *resp;
    uint16_t      timeout;
    pbAtCmdFunc_t cmd_f;
} bEsp12fCmd_t;

typedef struct
{
    bWifiDrvEvent_t ok_event;
    bWifiDrvEvent_t fail_event;
} bEsp12fCtlEvent_t;

typedef struct
{
    uint8_t busy;
    struct
    {
        bTcpUdpInfo_t info;
        uint8_t       connected;
    } conn[ESP12F_CONN_NUM_MAX];
    uint8_t             conn_id;
    uint8_t             cmd;
    const bEsp12fCmd_t *pcmd;
    uint8_t             cmd_num;
    uint8_t             cmd_index;
    uint8_t             result;
    uint8_t             step;
    uint8_t             uart_buf[CONNECT_RECVBUF_MAX];
    char                cmd_tmp[ESP12F_CMD_BUF_LEN + 1];
    union
    {
        bApInfo_t     ap;
        bTcpUdpInfo_t tcpudp;
        char          remote[WIFI_REMOTE_ADDR_LEN_MAX + 1];
        bTcpUdpData_t dat;
    } param;
    bAtStruct_t        at;
    bHalUartIdleAttr_t uart_attr;
    bTaskAttr_t        task_attr;
    bWifiDrvCallback_t cb;
} bEsp12fPrivate_t;

/**
 * \}
 */

/**
 * \defgroup ESP12F_Private_Macros
 * \{
 */

/**
 * \}
 */

/**
 * \defgroup ESP12F_Private_FunctionPrototypes
 * \{
 */
static char *_bSetApInfo(void *arg);
static char *_bJoinAp(void *arg);
static char *_bPing(void *arg);
static char *_bLocalTcpServer(void *arg);
static char *_bRemoteTcpServer(void *arg);
static char *_bRemoteUdpServer(void *arg);
static char *_bCloseTcpUdp(void *arg);
static char *_bTcpUdpSend(void *arg);
/**
 * \}
 */

/**
 * \defgroup ESP12F_Private_Variables
 * \{
 */

bDRIVER_HALIF_TABLE(bESP12F_HalIf_t, DRIVER_NAME);

static bEsp12fPrivate_t bEspRunInfo[bDRIVER_HALIF_NUM(bESP12F_HalIf_t, DRIVER_NAME)];

const static bEsp12fCtlEvent_t bEsp12fCtlEvent[] = {
    {0, 0},                                       // reserved
    {B_EVT_MODE_STA_OK, B_EVT_MODE_STA_FAIL},     // bCMD_WIFI_MODE_STA
    {B_EVT_MODE_AP_OK, B_EVT_MODE_STA_FAIL},      // bCMD_WIFI_MODE_AP
    {B_EVT_MODE_STA_AP_OK, B_EVT_MODE_STA_FAIL},  // bCMD_WIFI_MODE_STA_AP
    {B_EVT_JOIN_AP_OK, B_EVT_MODE_STA_FAIL},      // bCMD_WIFI_JOIN_AP
    {B_EVT_PING_OK, B_EVT_PING_FAIL},             // bCMD_WIFI_PING

    {B_EVT_LOCAL_TCP_SERVER_OK, B_EVT_LOCAL_TCP_SERVER_FAIL},  // bCMD_WIFI_LOCAL_TCP_SERVER
    {B_EVT_LOCAL_UDP_SERVER_OK, B_EVT_LOCAL_UDP_SERVER_FAIL},  // bCMD_WIFI_LOCAL_UDP_SERVER
    {B_EVT_CONN_TCP_SERVER_OK, B_EVT_CONN_TCP_SERVER_FAIL},    // bCMD_WIFI_REMOT_TCP_SERVER
    {B_EVT_CONN_UDP_SERVER_OK, B_EVT_CONN_UDP_SERVER_FAIL},    // bCMD_WIFI_REMOT_UDP_SERVER
    {B_EVT_CLOSE_CONN_OK, B_EVT_CLOSE_CONN_FAIL},              // bCMD_WIFI_TCPUDP_CLOSE
    {B_EVT_CONN_SEND_OK, B_EVT_CONN_SEND_FAIL},                // bCMD_WIFI_TCPUDP_SEND
};

const static bEsp12fCmd_t bEspCmdReset             = {"AT+RST\r\n", "OK", 300, NULL};
const static bEsp12fCmd_t bEspCmdInit[2]           = {{"AT\r\n", "OK", 300, NULL},
                                                      {"ATE0\r\n", "OK", 300, NULL}};
const static bEsp12fCmd_t bEspCmdStaMode[2]        = {{"AT+CWMODE=1\r\n", "OK", 300, NULL},
                                                      {"AT+CIPMUX=1\r\n", "OK", 300, NULL}};
const static bEsp12fCmd_t bEspCmdApMode[3]         = {{"AT+CWMODE=2\r\n", "OK", 300, NULL},
                                                      {NULL, NULL, 300, _bSetApInfo},
                                                      {"AT+CIPMUX=1\r\n", "OK", 300, NULL}};
const static bEsp12fCmd_t bEspCmdApStaMode[3]      = {{"AT+CWMODE=3\r\n", "OK", 300, NULL},
                                                      {NULL, NULL, 300, _bSetApInfo},
                                                      {"AT+CIPMUX=1\r\n", "OK", 300, NULL}};
const static bEsp12fCmd_t bEspCmdJoinAp[1]         = {{NULL, "OK", 15000, _bJoinAp}};
const static bEsp12fCmd_t bEspCmdPing[1]           = {{NULL, "OK", 3000, _bPing}};
const static bEsp12fCmd_t bEspCmdLocalTcpServer[1] = {{NULL, "OK", 300, _bLocalTcpServer}};
const static bEsp12fCmd_t bEspCmdRemotTcpServer[1] = {{NULL, "OK", 1000, _bRemoteTcpServer}};
const static bEsp12fCmd_t bEspCmdRemotUdpServer[1] = {{NULL, "OK", 1000, _bRemoteUdpServer}};
const static bEsp12fCmd_t bEspCmdCloseTcpUdp[1]    = {{NULL, "OK", 300, _bCloseTcpUdp}};
const static bEsp12fCmd_t bEspCmdSendData[1]       = {{NULL, ">", 300, _bTcpUdpSend}};
/**
 * \}
 */

/**
 * \defgroup ESP12F_Private_Functions
 * \{
 */
//----------------------------------------------------------------------------------------------------
//------------------------注册到其他模块的回调等接口----------------------------------------------------
//----------------------------------------------------------------------------------------------------
static void _bAtCmdCb(uint8_t isok, void *user_data)
{
    bDriverInterface_t *pdrv = (bDriverInterface_t *)user_data;
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, pdrv);
    _priv->result = (isok) ? ESP12F_CMD_RESULT_OK : ESP12F_CMD_RESULT_FAIL;
    b_log_w("at result:%d\r\n", isok);
}

static void _bEsp12fFree(void *addr)
{
    bFree(addr);
}
static void *_bAtNewDataMalloc(uint8_t *pbuf, uint16_t len)
{
    if (len == 0 || pbuf == NULL)
    {
        return NULL;
    }
    bTcpUdpData_t *pdat = bMalloc(sizeof(bTcpUdpData_t));
    if (pdat == NULL)
    {
        return NULL;
    }
    uint8_t *ptmp = bMalloc(len + 1);
    if (ptmp == NULL)
    {
        bFree(pdat);
        return NULL;
    }
    memset(ptmp, 0, len + 1);
    memcpy(ptmp, pbuf, len);
    pdat->len     = len;
    pdat->pbuf    = ptmp;
    pdat->release = _bEsp12fFree;
    return pdat;
}

static void _bAtNewDataFree(void *p)
{
    bTcpUdpData_t *dat = (bTcpUdpData_t *)p;
    if (dat == NULL)
    {
        return;
    }
    if (dat->release)
    {
        if (dat->pbuf)
        {
            dat->release(dat->pbuf);
            dat->pbuf = NULL;
        }
    }
    bFree(dat);
}

static void _bAtNewDataCb(uint8_t *pbuf, uint16_t len, void (*pfree)(void *), void *user_data)
{
    bDriverInterface_t *pdrv = (bDriverInterface_t *)user_data;
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, pdrv);
    bTcpUdpData_t *pdat    = NULL;
    char          *p       = NULL;
    char          *tmp_p   = NULL;
    int            conn_id = 0;
    int            rlen    = 0;
    int            retval  = -1;
    //+IPD,0,16:12312312312313
    tmp_p = (char *)pbuf;
    while (1)
    {
        p = strstr((const char *)tmp_p, "+IPD,");
        if (p != NULL)
        {
            retval = sscanf(p, "+IPD,%d,%d:%*s", &conn_id, &rlen);
            if (retval == 2 && rlen > 0)
            {
                if (conn_id >= 0 && conn_id < ESP12F_CONN_NUM_MAX)
                {
                    p = strstr(p, ":");
                    p = p + 1;
                    b_log("read:%p, %d\r\n", p, rlen);

#if 1
                    bTcpUdpData_t new_data;
                    new_data.pbuf    = (uint8_t *)p;
                    new_data.len     = rlen;
                    new_data.release = NULL;
                    memcpy(&new_data.conn, &_priv->conn[conn_id].info, sizeof(bTcpUdpInfo_t));
                    _priv->cb.cb(B_EVT_CONN_NEW_DATA, &new_data, NULL, _priv->cb.user_data);
#else
                    pdat = (bTcpUdpData_t *)_bAtNewDataMalloc((uint8_t *)p, rlen);
                    if (pdat != NULL)
                    {
                        memcpy(&pdat->conn, &_priv->conn[conn_id].info, sizeof(bTcpUdpInfo_t));
                        _priv->cb.cb(B_EVT_CONN_NEW_DATA, pdat, _bAtNewDataFree,
                                     _priv->cb.user_data);
                    }
#endif
                }
                tmp_p = p + rlen;
                if (((uint32_t)tmp_p) >= ((uint32_t)(pbuf + len)))
                {
                    break;
                }
            }
            else
            {
                b_log_e("sscanf error %d %d \r\n", retval, rlen);
                break;
            }
        }
        else
        {
            break;
        }
    }

    if (pfree)
    {
        if (pbuf)
        {
            pfree(pbuf);
            pbuf = NULL;
        }
    }
}

static void _bAtSendData(const uint8_t *pbuf, uint16_t len, void *user_data)
{
    bDRIVER_GET_HALIF(phal, bESP12F_HalIf_t, (bDriverInterface_t *)user_data);
    bHalUartSend(*phal, pbuf, len);
    b_log(">>%s\r\n", pbuf);
}

static int _bHalUartIdleCb(uint8_t *pbuf, uint16_t len, void *user_data)
{
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, (bDriverInterface_t *)user_data);
    bAtFeedData(&_priv->at, pbuf, len);
    return 0;
}

//--------------------------------------------------------------------------------------------------
// ---------------------通过函数拼装AT指令-----------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static char *_bSetApInfo(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CWSAP=\"%s\",\"%s\",5,%d\r\n",
             prv->param.ap.ssid, prv->param.ap.passwd, prv->param.ap.encryption);
    return &prv->cmd_tmp[0];
}

static char *_bJoinAp(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CWJAP=\"%s\",\"%s\"\r\n", prv->param.ap.ssid,
             prv->param.ap.passwd);
    return &prv->cmd_tmp[0];
}

static char *_bPing(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+PING=\"%s\"\r\n", prv->param.remote);
    return &prv->cmd_tmp[0];
}

static char *_bLocalTcpServer(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CIPSERVER=1,%d\r\n", prv->param.tcpudp.port);
    return &prv->cmd_tmp[0];
}

static char *_bRemoteTcpServer(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CIPSTART=%d,\"TCP\",\"%s\",%d\r\n", prv->conn_id,
             prv->param.tcpudp.ip, prv->param.tcpudp.port);
    return &prv->cmd_tmp[0];
}

static char *_bRemoteUdpServer(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CIPSTART=%d,\"UDP\",\"%s\",%d\r\n", prv->conn_id,
             prv->param.tcpudp.ip, prv->param.tcpudp.port);
    return &prv->cmd_tmp[0];
}

static char *_bCloseTcpUdp(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CIPCLOSE=%d\r\n", prv->conn_id);
    return &prv->cmd_tmp[0];
}

static char *_bTcpUdpSend(void *arg)
{
    bEsp12fPrivate_t *prv = (bEsp12fPrivate_t *)arg;
    memset(prv->cmd_tmp, 0, ESP12F_CMD_BUF_LEN);
    snprintf(prv->cmd_tmp, ESP12F_CMD_BUF_LEN, "AT+CIPSEND=%d,%d\r\n", prv->conn_id,
             prv->param.dat.len);
    return &prv->cmd_tmp[0];
}

//--------------------------------------------------------------------------------------------------

static void _bEsp12fCtlResult(uint8_t cmd, uint8_t isok, bDriverInterface_t *pdrv)
{
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, pdrv);
    if (cmd == bCMD_WIFI_TCPUDP_SEND)
    {
        b_log("send data...\r\n");
        if (isok)
        {
            _bAtSendData(_priv->param.dat.pbuf, _priv->param.dat.len, pdrv);
        }
        if (_priv->param.dat.release)
        {
            _priv->param.dat.release(_priv->param.dat.pbuf);
            _priv->param.dat.pbuf = NULL;
        }
    }
    _priv->busy      = 0;
    _priv->cmd_index = 0;
    _priv->cmd_num   = 0;
    _priv->pcmd      = NULL;
    _priv->cb.cb(isok ? bEsp12fCtlEvent[cmd].ok_event : bEsp12fCtlEvent[cmd].fail_event, NULL, NULL,
                 _priv->cb.user_data);
}

PT_THREAD(bEsp12fTask)(struct pt *pt, void *arg)
{
    bDriverInterface_t *pdrv = (bDriverInterface_t *)arg;
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, pdrv);
    if (_priv->busy == 0)
    {
        return 0;
    }
    PT_BEGIN(pt);
    while (1)
    {
        if (_priv->step & ESP12F_CMD_RESET_BIT)
        {
            _priv->result = 0;
            bAtSendCmd(&_priv->at, bEspCmdReset.pcmd, bEspCmdReset.resp, bEspCmdReset.timeout);
            PT_WAIT_UNTIL(pt, _priv->result != 0, ESP12F_CMD_TIMEOUT);
            if (_priv->result == ESP12F_CMD_RESULT_OK)
            {
                bTaskDelayMs(pt, 4000);
                _priv->step &= ~(ESP12F_CMD_RESET_BIT);
            }
            else
            {
                _bEsp12fCtlResult(_priv->cmd, 0, pdrv);
            }
        }
        else if (_priv->step & ESP12F_CMD_INIT_BIT)
        {
            _priv->result = 0;
            if (bEspCmdInit[_priv->cmd_index].pcmd)
            {
                bAtSendCmd(&_priv->at, bEspCmdInit[_priv->cmd_index].pcmd,
                           bEspCmdInit[_priv->cmd_index].resp,
                           bEspCmdInit[_priv->cmd_index].timeout);
            }
            else
            {
                bAtSendCmd(&_priv->at, bEspCmdInit[_priv->cmd_index].cmd_f(_priv),
                           bEspCmdInit[_priv->cmd_index].resp,
                           bEspCmdInit[_priv->cmd_index].timeout);
            }
            PT_WAIT_UNTIL(pt, _priv->result != 0, ESP12F_CMD_TIMEOUT);
            if (_priv->result == ESP12F_CMD_RESULT_OK)
            {
                _priv->cmd_index += 1;
                if (_priv->cmd_index >= sizeof(bEspCmdInit) / sizeof(bEsp12fCmd_t))
                {
                    _priv->cmd_index = 0;
                    _priv->step &= ~(ESP12F_CMD_INIT_BIT);
                }
            }
            else
            {
                _bEsp12fCtlResult(_priv->cmd, 0, pdrv);
            }
        }
        else if (_priv->pcmd != NULL && _priv->cmd_num > 0 && _priv->cmd_index < _priv->cmd_num)
        {
            _priv->result = 0;

            if (_priv->pcmd[_priv->cmd_index].pcmd)
            {
                bAtSendCmd(&_priv->at, _priv->pcmd[_priv->cmd_index].pcmd,
                           _priv->pcmd[_priv->cmd_index].resp,
                           _priv->pcmd[_priv->cmd_index].timeout);
            }
            else
            {
                bAtSendCmd(&_priv->at, _priv->pcmd[_priv->cmd_index].cmd_f(_priv),
                           _priv->pcmd[_priv->cmd_index].resp,
                           _priv->pcmd[_priv->cmd_index].timeout);
            }
            PT_WAIT_UNTIL(pt, _priv->result != 0, ESP12F_CMD_TIMEOUT);
            if (_priv->result == ESP12F_CMD_RESULT_OK)
            {
                _priv->cmd_index += 1;
                if (_priv->cmd_index >= _priv->cmd_num)
                {
                    _bEsp12fCtlResult(_priv->cmd, 1, pdrv);
                }
            }
            else
            {
                _bEsp12fCtlResult(_priv->cmd, 0, pdrv);
            }
        }
        bTaskYield(pt);
    }
    PT_END(pt);
}
//--------------------------------------------------------------------------------------------------
//  私有功能函数
//--------------------------------------------------------------------------------------------------
static void _bEsp12fProcessCmd(bEsp12fPrivate_t *_priv, uint8_t cmd, const bEsp12fCmd_t *pcmdtable,
                               uint8_t cmdtable_size, uint8_t reset, uint8_t init)
{
    _priv->cmd_index = 0;
    _priv->step      = 0;
    _priv->busy      = 1;
    _priv->cmd       = cmd;
    _priv->pcmd      = pcmdtable;
    _priv->cmd_num   = cmdtable_size;
    if (reset)
    {
        _priv->step |= ESP12F_CMD_RESET_BIT;
    }
    if (init)
    {
        _priv->step |= ESP12F_CMD_INIT_BIT;
    }
}

static int _bEsp12fGetConn(bEsp12fPrivate_t *_priv, bTcpUdpInfo_t *pinfo, uint8_t *unused_connid)
{
    int i      = 0;
    int retval = -1;
    for (i = 0; i < ESP12F_CONN_NUM_MAX; i++)
    {
        if (_priv->conn[i].connected == 1)
        {
            if (_priv->conn[i].info.port == pinfo->port &&
                strcmp(_priv->conn[i].info.ip, pinfo->ip) == 0)
            {
                return i;
            }
        }
        else if (unused_connid)
        {
            *unused_connid = i;
        }
    }
    return retval;
}

//--------------------------------------------------------------------------------------------------
static int _bESP12FCtl(bDriverInterface_t *pdrv, uint8_t cmd, void *param)
{
    int     retval  = -1;
    uint8_t conn_id = 0;
    bDRIVER_GET_PRIVATE(_priv, bEsp12fPrivate_t, pdrv);
    if (_priv->busy)
    {
        return -1;
    }
    b_log("ctl:%d\r\n", cmd);
    _priv->cmd = cmd;
    switch (cmd)
    {
        case bCMD_WIFI_REG_CALLBACK:
        {
            if (param == NULL)
            {
                return -1;
            }
            bWifiDrvCallback_t *pcb = (bWifiDrvCallback_t *)param;
            _priv->cb.cb            = pcb->cb;
            _priv->cb.user_data     = pcb->user_data;
        }
        break;
        case bCMD_WIFI_SET_CALLBACK_ARG:
        {
            _priv->cb.user_data = param;
        }
        break;
        case bCMD_WIFI_MODE_STA:
        {
            _bEsp12fProcessCmd(_priv, cmd, &bEspCmdStaMode[0],
                               sizeof(bEspCmdStaMode) / sizeof(bEsp12fCmd_t), 1, 1);
        }
        break;
        case bCMD_WIFI_MODE_AP:
        case bCMD_WIFI_MODE_STA_AP:
        case bCMD_WIFI_JOIN_AP:
        {
            if (param == NULL)
            {
                return -1;
            }
            memcpy(&_priv->param.ap, param, sizeof(bApInfo_t));
            if (cmd == bCMD_WIFI_MODE_AP)
            {
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdApMode[0],
                                   sizeof(bEspCmdApMode) / sizeof(bEsp12fCmd_t), 1, 1);
            }
            else if (cmd == bCMD_WIFI_MODE_STA_AP)
            {
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdApStaMode[0],
                                   sizeof(bEspCmdApStaMode) / sizeof(bEsp12fCmd_t), 1, 1);
            }
            else if (cmd == bCMD_WIFI_JOIN_AP)
            {
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdJoinAp[0],
                                   sizeof(bEspCmdJoinAp) / sizeof(bEsp12fCmd_t), 0, 0);
            }
        }
        break;
        case bCMD_WIFI_PING:
        {
            if (param == NULL || strlen(param) > WIFI_REMOTE_ADDR_LEN_MAX)
            {
                return -1;
            }
            memset(&_priv->param.remote[0], 0, sizeof(_priv->param.remote));
            memcpy(&_priv->param.remote[0], param, strlen(param));
            _bEsp12fProcessCmd(_priv, cmd, &bEspCmdPing[0],
                               sizeof(bEspCmdPing) / sizeof(bEsp12fCmd_t), 0, 0);
        }
        break;
        case bCMD_WIFI_LOCAL_TCP_SERVER:
        case bCMD_WIFI_LOCAL_UDP_SERVER:
        case bCMD_WIFI_REMOT_TCP_SERVER:
        case bCMD_WIFI_REMOT_UDP_SERVER:
        case bCMD_WIFI_TCPUDP_CLOSE:
        {
            if (param == NULL)
            {
                return -1;
            }
            memcpy(&_priv->param.tcpudp, param, sizeof(bTcpUdpInfo_t));
            conn_id = 0xff;
            retval  = _bEsp12fGetConn(_priv, &_priv->param.tcpudp, &conn_id);
            b_log_w("retval %d cnn_id %02x \r\n", retval, conn_id);
            if (cmd == bCMD_WIFI_LOCAL_TCP_SERVER)
            {
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdLocalTcpServer[0],
                                   sizeof(bEspCmdLocalTcpServer) / sizeof(bEsp12fCmd_t), 0, 0);
            }
            else if (cmd == bCMD_WIFI_REMOT_TCP_SERVER)
            {
                if (conn_id == 0xff)
                {
                    b_log_e("conn full, use conn_id 0\r\n");
                    return -2;
                }
                _priv->conn_id = conn_id;
                memcpy(&_priv->conn[conn_id], &_priv->param.tcpudp, sizeof(bTcpUdpInfo_t));
                _priv->conn[conn_id].connected = 1;
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdRemotTcpServer[0],
                                   sizeof(bEspCmdRemotTcpServer) / sizeof(bEsp12fCmd_t), 0, 0);
            }
            else if (cmd == bCMD_WIFI_REMOT_UDP_SERVER)
            {
                if (conn_id == 0xff)
                {
                    b_log_e("conn full\r\n");
                    return -2;
                }
                _priv->conn_id = conn_id;
                memcpy(&_priv->conn[conn_id], &_priv->param.tcpudp, sizeof(bTcpUdpInfo_t));
                _priv->conn[conn_id].connected = 1;
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdRemotUdpServer[0],
                                   sizeof(bEspCmdRemotUdpServer) / sizeof(bEsp12fCmd_t), 0, 0);
            }
            else if (cmd == bCMD_WIFI_TCPUDP_CLOSE)
            {
                if (retval < 0)
                {
                    b_log_e("cannt find..\r\n");
                    return -2;
                }
                _priv->conn_id                = retval;
                _priv->conn[retval].connected = 0;
                _bEsp12fProcessCmd(_priv, cmd, &bEspCmdCloseTcpUdp[0],
                                   sizeof(bEspCmdCloseTcpUdp) / sizeof(bEsp12fCmd_t), 0, 0);
            }
        }
        break;
        case bCMD_WIFI_TCPUDP_SEND:
        {
            if (param == NULL)
            {
                return -1;
            }
            bTcpUdpData_t *pdat = (bTcpUdpData_t *)param;
            if (pdat->pbuf == NULL)
            {
                return -1;
            }
            retval = _bEsp12fGetConn(_priv, &_priv->param.tcpudp, NULL);
            if (retval < 0)
            {
                b_log_e("cannt find..\r\n");
                return -2;
            }
            memcpy(&_priv->param.dat, param, sizeof(bTcpUdpData_t));
            _priv->conn_id = retval;
            _bEsp12fProcessCmd(_priv, cmd, &bEspCmdSendData[0],
                               sizeof(bEspCmdSendData) / sizeof(bEsp12fCmd_t), 0, 0);
        }
        break;
        default:
            break;
    }
    return 0;
}
/**
 * \}
 */

/**
 * \addtogroup ESP12F_Exported_Functions
 * \{
 */
int bESP12F_Init(bDriverInterface_t *pdrv)
{
    bDRIVER_STRUCT_INIT(pdrv, DRIVER_NAME, bESP12F_Init);
    pdrv->ctl         = _bESP12FCtl;
    pdrv->_private._p = &bEspRunInfo[pdrv->drv_no];
    memset(pdrv->_private._p, 0, sizeof(bEsp12fPrivate_t));
    // 创建异步消息处理任务
    bTaskCreate("esp12f", bEsp12fTask, pdrv, &bEspRunInfo[pdrv->drv_no].task_attr);
    // AT初始化，注册回调和发送函数
    bAtInit(&bEspRunInfo[pdrv->drv_no].at, _bAtCmdCb, _bAtNewDataCb, _bAtSendData, pdrv);
    // 串口接收初始化，注册接收空闲回调
    bHAL_UART_INIT_ATTR(&bEspRunInfo[pdrv->drv_no].uart_attr,
                        &(bEspRunInfo[pdrv->drv_no].uart_buf[0]), CONNECT_RECVBUF_MAX, 50,
                        _bHalUartIdleCb, pdrv);
    bHalUartReceiveIdle(*((bESP12F_HalIf_t *)pdrv->hal_if), &bEspRunInfo[pdrv->drv_no].uart_attr);
    return 0;
}

#ifdef BSECTION_NEED_PRAGMA
#pragma section driver_init
#endif
bDRIVER_REG_INIT(B_DRIVER_ESP12F, bESP12F_Init);
#ifdef BSECTION_NEED_PRAGMA
#pragma section
#endif

/**
 * \}
 */

/**
 * \}
 */

/**
 * \}
 */

/**
 * \}
 */
// https://docs.ai-thinker.com/固件汇总  MQTT透传AT固件 （固件号：1112）
/**
################################################
[00:15:04.169]发→◇AT
□
[00:15:04.181]收←◆AT

OK

[00:15:12.066]发→◇ATE0
□
[00:15:12.076]收←◆ATE0

OK

[00:15:17.475]发→◇AT+CWMODE=1
□
[00:15:17.484]收←◆
OK

[00:15:21.314]发→◇AT+CIPMUX=1
□
[00:15:21.327]收←◆
OK

[00:15:56.405]发→◇AT+CWJAP="12345xxx","55667788"
□
[00:15:58.342]收←◆WIFI CONNECTED

[00:16:01.707]收←◆WIFI GOT IP

OK

[00:18:01.185]发→◇AT+CIPSTART=0,"TCP","192.168.169.161",666
□
[00:18:01.387]收←◆0,CONNECT

OK

[00:18:20.018]收←◆
+IPD,0,16:12312312312313


[00:18:30.771]收←◆
+IPD,0,16:12312312312313
 */
/************************ Copyright (c) 2019 Bean *****END OF FILE********/