// 蓝牙响应处理模块
// 杭州秒寻科技有限公司
// 周涛
// 2024-5-3

#include "includes.h"

// 导入全局变量
extern WIFI_BLE_PARAM_T gWifiBle_stParam;
extern WIFI_PARAM_T gWifi_stParam;  // wifi模块参数
extern uint32 gWifi_dwSocketConnId; // socket连接ID

// AT命令响应成功
// pbyData:响应数据
void ble_resp_ok(uint8 *pbyData)
{
    char abyRespChar[AT_WIFIBLE_CMD_VALUE_LEN] = {0}; // 响应字符串
    char *pbyChar = NULL;
    int32 dwMode = 0;
    int32 dwStatus = 0;
    uint16 wPort = 0;

    // 关闭定时器
    timer_stop_timer(gWifiBle_stParam.byTimerID);

    // 当前为蓝牙初始化状态
    if (gWifiBle_stParam.byInit == 1)
    {
        // 关闭回显功能
        if (NULL != strstr(AT_BLE_ATE0, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_mode_get();             // 查询模块工作模式
        }
        // 查询蓝牙模式
        else if (NULL != strstr(AT_BLEMODE_GET, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态

            ble_resp_parse_str(pbyData, 11, 1, abyRespChar); // 解析字符串
            pbyChar = &abyRespChar[0];
            dwMode = atoi(pbyChar);
            if (dwMode != 9)
            {
                ble_cmd_mode_close_ble(); // 关闭蓝牙
            }
            else
            {
                ble_cmd_set_tx_pwr(3); // TODO，参数需要改成可配置，配置蓝牙发射功率
            }
        }
        // 关闭蓝牙成功
        else if (NULL != strstr(AT_BLEMODE_CLOSE, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_set_tx_pwr(3);          // TODO，参数改成可配置，配置蓝牙发射功率
        }
        // 配置蓝牙发射功率成功
        else if (NULL != strstr(AT_BLERFPWR, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_set_adv_intv(1600);     // TODO，参数改成可配置， 配置蓝牙发射间隔
        }
        // 配置蓝牙发射间隔成功
        else if (NULL != strstr(AT_BLEADVINTV, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_get_mac(1);             // 获得蓝牙mac
        }
        // 获得蓝牙MAC成功
        else if (NULL != strstr(AT_BLEMAC, (char *)gWifiBle_stParam.abyAtCmd))
        {
            ble_resp_parse_str(pbyData, 10, 12, abyRespChar);    // 解析字符串
            memcpy(gWifiBle_stParam.abyBleMac, abyRespChar, 12); // 保存蓝牙MAC，以便超时使用
            ble_cmd_save_name(abyRespChar);                      // 保存蓝牙名称

            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_set_name(abyRespChar);  // 配置蓝牙名称
        }
        // 配置蓝牙名称成功
        else if (NULL != strstr(AT_BLENAME, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            ble_cmd_mode_enable();          // 打开蓝牙
        }
        // 打开蓝牙成功
        else if (NULL != strstr(AT_BLEMODE_EN, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态

            // 要启用网管中心
            if (gWifi_stParam.bySwitch == 1)
            {
                gWifiBle_stParam.byInit = 2; // BLE模块初始化完成，进入wifi模块初始化阶段
                wifi_cmd_set_wmode();        // 配置wifi模块模式
            }
            // 不启用网管中心
            else
            {
                gWifiBle_stParam.byInit = 3; // WIFI蓝牙模块初始化完成，进入工作状态
            }
        }
    }
    // wifi模块初始化阶段
    else if (gWifiBle_stParam.byInit == 2)
    {
        // 配置wifi模式成功
        if (NULL != strstr(AT_WIFI_WMODE, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态
            wifi_cmd_set_wsdhcp();          // 配置dhcp参数
        }
        // 配置dhcp参数成功
        else if (NULL != strstr(AT_WIFI_WSDHCP, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status();                                                            // 更新模块状态
            wifi_cmd_connect_ap((char *)gWifi_stParam.abyApName, (char *)gWifi_stParam.abyApPassword); // 链接AP
        }
        // 连接AP成功
        else if (NULL != strstr(AT_WIFI_WJAP, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status();     // 更新模块状态
            driver_delay_nxs(2);                // 延时2秒钟，等待ap连接成功
            wifi_cmd_check_ap_connect_status(); // 检查AP连接状态
        }
        // 检查AP连接状态成功
        else if (NULL != strstr(AT_WIFI_WJAP_CHECK, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status();                         // 更新模块状态
            ble_resp_parse_str((char *)pbyData, 8, 1, abyRespChar); // 解析字符串
            pbyChar = &abyRespChar[0];
            dwStatus = atoi(pbyChar); // 连接AP状态

            // 连接到AP，并且已经获取到了IP，则创建socket连接
            if (dwStatus == 3)
            {
                gWifiBle_stParam.byWifiConnected = 1; // wifi连接成功
                SYS_MEMCPY(&wPort, gWifi_stParam.abyMonitorPort, sizeof(uint16));
                wifi_cmd_creat_udp_socket((char *)gWifi_stParam.abyMonitorIP, wPort); // 创建udp socket连接
            }
            // 没有连接上，则重新连接
            else
            {
                timer_start_timer(gWifiBle_stParam.byTimerID, 1000 * 3, (void *)wifi_cmd_check_ap_connect_status);
            }
        }
        // udp socket创建成功
        else if (NULL != strstr(AT_WIFI_SOCKET, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态

            // 检查socket连接状态
            // wifi_cmd_check_socket_connect_status();

            // socket进入透传模式
            wifi_cmd_socket_transparent();
        }
        // // socket连接成功
        // else if (NULL != strstr(AT_WIFI_SOCKET_CHECK, (char *)gWifiBle_stParam.abyAtCmd))
        // {
        //     wifi_ble_reset_module_status(); // 更新模块状态

        //     // 解析响应字符串，获得socket连接状态
        //     uint8 abyStatus[2] = {0};
        //     uint8 byStatus = 0;
        //     ble_resp_parse_str_by_split_flag(pbyData, SYS_STRLEN((char *)pbyData), 0x2C, 2, 1, abyStatus);
        //     byStatus = (uint8)atoi(abyStatus[0]);

        //     // socket连接成功
        //     if (byStatus == 3)
        //     {
        //         // socket进入透传模式
        //         wifi_cmd_socket_transparent();
        //     }
        //     else
        //     {
        //         // 继续查询socket连接状态
        //         timer_start_timer(gWifiBle_stParam.byTimerID, 1000 * 3, (void *)wifi_cmd_check_socket_connect_status);
        //     }
        // }
        // socket进入透传模式成功
        else if (NULL != strstr(AT_WIFI_SOCKETTT, (char *)gWifiBle_stParam.abyAtCmd))
        {
            wifi_ble_reset_module_status(); // 更新模块状态

            // 模块初始化阶段完成，进入工作模式
            gWifiBle_stParam.byInit = 3;
            gWifiBle_stParam.byTransparentFlag = 1; // socket进入透传模式

            // 上报心跳，保持连接
            oam_report_heart();
        }
    }

    return;
}

// 解析字符串（从字符串中截取子串）
// pbyInputChar：输入字符串
// byStartIndex：开始索引
// byLength：截取长度
// pbyOutChar：输出字符串（返回参数）
// 返回一个新分配的字符串，或者当发生错误时返回NULL
void ble_resp_parse_str(const char *pbyInputChar, uint8 byStartIndex, uint8 byLength, char *pbyOutChar)
{
    uint8 byEndIndex = byStartIndex + byLength;

    if (pbyInputChar == NULL || (byStartIndex + byLength) >= strlen(pbyInputChar) || pbyOutChar == NULL)
    {
        return;
    }

    // 复制子串到新的内存中
    for (uint8 i = 0; i < byLength; ++i)
    {
        pbyOutChar[i] = pbyInputChar[byStartIndex + i];
    }
    pbyOutChar[byLength] = '\0'; // 添加字符串结尾的'\0'

    return;
}

// 根据分割字符解析字符串
// pbyInputChar：输入字符串
// bySplitFlag:分割字符
// byLength：截取长度
// pbyOutChar：输出字符串（返回参数）
// 返回一个新分配的字符串，或者当发生错误时返回NULL
void ble_resp_parse_str_by_split_flag(char *pbyInputChar, uint8 byLen, uint8 bySplitFlag, uint8 bySplitFlagNum, uint8 byOutLen, char *pbyOutChar)
{
    uint8 byTmp = 0;
    uint8 byCounter = 0;
    uint8 byCutFlag = 0;
    uint8 byCharCounter = 0;

    // 遍历字符串，查找分割符
    for (uint8 i = 0; i < byLen; i++)
    {
        byTmp = pbyInputChar[i];

        // 当前字符是分隔符
        if (byTmp == bySplitFlag)
        {
            byCounter++;

            // 分隔符个数达到截取字符的数量
            if (byCounter == bySplitFlagNum)
            {
                byCutFlag = 1;
            }
            else
            {
                byCutFlag = 0;
            }
        }

        // 截取字符标识符为真
        if (byCutFlag)
        {
            pbyOutChar[byCharCounter] = pbyInputChar[i + 1];
            byCharCounter++;

            if (byCharCounter >= byOutLen)
            {
                pbyOutChar[byCharCounter] = '\0'; // 添加字符串结尾的'\0'
                break;
            }
        }
    }

    return;
}

// 模块广播事件
// pbyData:
void ble_resp_event(uint8 *pbyData)
{
}

// AT命令响应失败
void ble_resp_err(uint8 *pbyData)
{
    ble_expire_main(pbyData);
}