/*
 * Copyright (c) 2023 Fancy Code.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */
#include "McuProtocolTestTool.h"
#include "ILog.h"
#include "ModBusCRC16.h"
#include "ProtocolHandle.h"
#include "ProtocolMonitor.h"
#include <netinet/in.h>
#include <string.h>
#include <thread>
#include <unistd.h>
using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
using std::placeholders::_4;
constexpr int PIPE_READ_FD_INDEX = 0;
constexpr int PIPE_WRITE_FD_INDEX = 1;
constexpr int INVALID_FD = -1;
const char *gPipeBuf = "nothing";
constexpr size_t PROTOCOL_HEAD_LENGTH = 2;
constexpr size_t PROTOCOL_SERIAL_NUMBER_LENGTH = sizeof(unsigned int);
constexpr size_t PROTOCOL_SERIAL_NUMBER_OFFSET = PROTOCOL_HEAD_LENGTH;
constexpr size_t PROTOCOL_COMMAND_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_COMMAND_OFFSET = PROTOCOL_SERIAL_NUMBER_OFFSET + PROTOCOL_SERIAL_NUMBER_LENGTH;
constexpr size_t PROTOCOL_DATA_LENGTH_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_DATA_LENGTH_OFFSET = PROTOCOL_COMMAND_OFFSET + PROTOCOL_DATA_LENGTH_LENGTH;
constexpr size_t PROTOCOL_CHECK_CODE_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_DATA_KEY_HEAD_LENGTH =
    PROTOCOL_HEAD_LENGTH + PROTOCOL_SERIAL_NUMBER_LENGTH + PROTOCOL_COMMAND_LENGTH + PROTOCOL_DATA_LENGTH_LENGTH;
unsigned char ASK_IPC_MISSION_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_IPC_MISSION_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_CUT_OFF_POWER_SUPPLY_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char ASK_FEED_WATCH_DOG_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char ASK_SET_FEEDING_CYCLE_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x04, 0x00, 0x0F, 0x01, 0x01, 0x01, 0xFF, 0xFF};
unsigned char REPLY_SET_FEEDING_CYCLE_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_DATE_TIME_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x07, 0x00, 0x13, 0xDE, 0x07, 0x01, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char REPLY_SET_DATE_TIME_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_PIR_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x08, 0x00, 0x0D, 0x09, 0xFF, 0xFF};
unsigned char REPLY_SET_PIR_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_CONTORL_INFRARED_LIGHT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x0A, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char REPLY_ASK_CONTORL_INFRARED_LIGHT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0A, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_GET_PHOTOSENSITIVITY_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x0B, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_ASK_GET_PHOTOSENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0B, 0x00, 0x0D, 0x0A, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x01, 0x00, 0x0D, 0x0A, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_SEND_IPC_MISSION_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x01, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
McuProtocolTestTool::McuProtocolTestTool()
{
    mThreadRuning = false;
    mPipeFdMockSelectInit = false;
    mPipeFdMockSelect[PIPE_READ_FD_INDEX] = -1;
    mPipeFdMockSelect[PIPE_WRITE_FD_INDEX] = -1;
    mUartFd = INVALID_FD;
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::MonitorProtocolPacket, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::IpcMissionProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::CutOffPowerSupplyProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::FeedWatchDogProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::FeedingCycleProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::SetDataTimeProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::SetPirSensitivityProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::ContorlInfraredLightHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::GetPhotosensitivityValueHandle, this, _1, _2, _3, _4));
}
void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo &uart)
{
    std::shared_ptr<ProtocolMonitor> test = std::make_shared<ProtocolMonitorTest>();
    std::shared_ptr<ProtocolMonitorTest> tmp = std::dynamic_pointer_cast<ProtocolMonitorTest>(test);
    ProtocolMonitorTest::Init(tmp);
    ProtocolMonitor::GetInstance(&test);
    if (pipe(mPipeFdMockSelect) == 0) {
        mPipeFdMockSelectInit = true;
    }
    else {
        LogWarning("pipe failed, mPipeFdMockSelect willn,t work.\n");
    }
    int uartFd = GetDeviceMockFd(uart);
    mUartFd = uartFd;
    static size_t WRITE_COUNT = -1;
    auto api_write = [=, &mock](int fd, const void *buf, size_t count) {
        McuProtocolTestTool::PrintHexadecimalData(buf, count, "app write :");
        CheckSerialNumber(buf, count);
        ChecCRC16Code(buf, count);
        for (auto iter = mProtocolHandle.begin(); iter != mProtocolHandle.end(); ++iter) {
            if ((*iter)(mock, uartFd, buf, count) == PROTOCOL_HANDLED) {
                return;
            }
        }
        LogWarning("Can't find protocol handle function.\n");
    };
    EXPECT_CALL(*mock.get(), fx_write(uartFd, _, _))
        .WillRepeatedly(
            DoAll(SaveArg<2>(&WRITE_COUNT), WithArgs<0, 1, 2>(Invoke(api_write)), ReturnPointee(&WRITE_COUNT)));
}
void McuProtocolTestTool::UnInit(void)
{
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    if (mUnLockThread.joinable()) {
        mUnLockThread.join();
    }
    mSerialNumberList.clear();
    if (mPipeFdMockSelectInit) {
        close(mPipeFdMockSelect[PIPE_READ_FD_INDEX]);
        close(mPipeFdMockSelect[PIPE_WRITE_FD_INDEX]);
        mPipeFdMockSelect[PIPE_READ_FD_INDEX] = -1;
        mPipeFdMockSelect[PIPE_WRITE_FD_INDEX] = -1;
    }
    mPipeFdMockSelectInit = false;
    mUartFd = INVALID_FD;
    std::shared_ptr<ProtocolMonitor> monitor = std::make_shared<ProtocolMonitor>();
    ProtocolMonitor::GetInstance(&monitor);
}
void McuProtocolTestTool::OtherSideAskIpcMission(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber)
{
    OtherSideAskIpcMissionHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::CheckSerialNumber(const void *buf, const size_t &count)
{
    unsigned int serialNumber = 0;
    if (count > PROTOCOL_COMMAND_OFFSET + PROTOCOL_CHECK_CODE_LENGTH) {
        memcpy(&serialNumber, (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET, PROTOCOL_SERIAL_NUMBER_LENGTH);
        for (auto iter = mSerialNumberList.begin(); iter != mSerialNumberList.end(); ++iter) {
            EXPECT_NE(*iter, serialNumber);
        }
        mSerialNumberList.push_back(serialNumber);
    }
}
void McuProtocolTestTool::ChecCRC16Code(const void *buf, const size_t &count)
{
    short code = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
    EXPECT_EQ(memcmp((unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &code, PROTOCOL_CHECK_CODE_LENGTH), 0);
}
void McuProtocolTestTool::ResetCheckCode(const void *buf, const size_t &count)
{
    short checkCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
    // checkCode = htons(checkCode);
    memcpy((unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &checkCode, PROTOCOL_CHECK_CODE_LENGTH);
}
void McuProtocolTestTool::ReplySelectSucceed(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
{
    auto selectReadable =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            FD_ZERO(readfds);
            FD_SET(uartFd, readfds);
        };
    auto selectTimeOut =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            if (false == mPipeFdMockSelectInit) {
                long long timeMs = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
                std::this_thread::sleep_for(std::chrono::milliseconds(timeMs));
            }
            else {
                constexpr int READ_BUF_LENGTH = 256;
                constexpr int READ_FAILD = -1;
                char buf[READ_BUF_LENGTH] = {0};
                int selectResult = -1;
                fd_set fdsRead;
                FD_ZERO(&fdsRead);
                FD_SET(mPipeFdMockSelect[PIPE_READ_FD_INDEX], &fdsRead);
                selectResult = select(mPipeFdMockSelect[PIPE_READ_FD_INDEX] + 1, &fdsRead, NULL, NULL, timeout);
                if (selectResult) {
                    // Do nothing here.
                    ssize_t length = read(mPipeFdMockSelect[PIPE_READ_FD_INDEX], buf, READ_BUF_LENGTH);
                    if (READ_FAILD == length) {
                        LogError("mPipeFdMockSelect failed.\n");
                        return;
                    }
                    if ((size_t)length != strlen(gPipeBuf)) {
                        LogWarning("Something wrong happened.\n");
                    }
                }
            }
        };
    EXPECT_CALL(*mock.get(), fx_select(uartFd + 1, _, _, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
        .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
        .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
    PipeSelectTimeoutForProtocolHandleImmediately();
}
bool McuProtocolTestTool::MonitorProtocolPacket(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                size_t count)
{
    short head;
    unsigned int serialNumber;
    short command;
    void *data;
    short packetLength;
    memcpy(&head, buf, PROTOCOL_HEAD_LENGTH);
    memcpy(&serialNumber, (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET, PROTOCOL_SERIAL_NUMBER_LENGTH);
    memcpy(&command, (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET, PROTOCOL_COMMAND_LENGTH);
    memcpy(&packetLength, (unsigned char *)buf + PROTOCOL_DATA_LENGTH_OFFSET, PROTOCOL_DATA_LENGTH_LENGTH);
    data = (unsigned char *)buf + PROTOCOL_DATA_KEY_HEAD_LENGTH;
    head = ntohs(head);
    serialNumber = ntohl(serialNumber);
    command = ntohs(command);
    packetLength = ntohs(packetLength);
    ProtocolMonitor::GetInstance()->MonitorWriteProtocolData(head, serialNumber, command, data, packetLength);
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    if (sizeof(ASK_IPC_MISSION_X) == count && memcmp(ASK_IPC_MISSION_X + PROTOCOL_COMMAND_OFFSET,
                                                     (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                     PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set REPLY_IPC_MISSION_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->IpcMissionProtocolInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                 size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_IPC_MISSION_X, sizeof(REPLY_IPC_MISSION_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "IpcMissionProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_IPC_MISSION_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "IpcMissionProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
bool McuProtocolTestTool::CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                          const void *buf, size_t count)
{
    if (sizeof(ASK_CUT_OFF_POWER_SUPPLY_X) == count && memcmp(ASK_CUT_OFF_POWER_SUPPLY_X + PROTOCOL_COMMAND_OFFSET,
                                                              (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                              PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set ASK_CUT_OFF_POWER_SUPPLY_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        // IpcMissionProtocolInit(mock, uartFd);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::FeedWatchDogProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_FEED_WATCH_DOG_X) == count && memcmp(ASK_FEED_WATCH_DOG_X + PROTOCOL_COMMAND_OFFSET,
                                                        (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                        PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set ASK_FEED_WATCH_DOG_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        // IpcMissionProtocolInit(mock, uartFd);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_SET_FEEDING_CYCLE_X) == count && memcmp(ASK_SET_FEEDING_CYCLE_X + PROTOCOL_COMMAND_OFFSET,
                                                           (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                           PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(REPLY_SET_FEEDING_CYCLE_X,
                                                   sizeof(REPLY_SET_FEEDING_CYCLE_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_FEEDING_CYCLE_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->FeedingCycleProtocolInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        // FeedingCycleProtocolInit(mock, uartFd);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_SET_FEEDING_CYCLE_X, sizeof(REPLY_SET_FEEDING_CYCLE_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_FEEDING_CYCLE_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_FEEDING_CYCLE_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "FeedingCycleProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "FeedingCycleProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
bool McuProtocolTestTool::SetDataTimeProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                    const void *buf, size_t count)
{
    if (sizeof(ASK_SET_DATE_TIME_X) == count && memcmp(ASK_SET_DATE_TIME_X + PROTOCOL_COMMAND_OFFSET,
                                                       (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                       PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode =
            calculate_check_sum(REPLY_SET_DATE_TIME_X, sizeof(REPLY_SET_DATE_TIME_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_DATE_TIME_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                  size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_SET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_SET_DATE_TIME_X, sizeof(REPLY_SET_DATE_TIME_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_DATE_TIME_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_DATE_TIME_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "SetDataTimeProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_DATE_TIME_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "SetDataTimeProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
bool McuProtocolTestTool::SetPirSensitivityProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                          const void *buf, size_t count)
{
    if (sizeof(ASK_SET_PIR_SENSITIVITY_X) == count && memcmp(ASK_SET_PIR_SENSITIVITY_X + PROTOCOL_COMMAND_OFFSET,
                                                             (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                             PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(REPLY_SET_PIR_SENSITIVITY_X,
                                                   sizeof(REPLY_SET_PIR_SENSITIVITY_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_PIR_SENSITIVITY_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::SetPirSensitivityProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                        const void *buf, size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_SET_PIR_SENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_SET_PIR_SENSITIVITY_X, sizeof(REPLY_SET_PIR_SENSITIVITY_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_PIR_SENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_PIR_SENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "SetPirSensitivityProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_PIR_SENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "SetPirSensitivityProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
bool McuProtocolTestTool::ContorlInfraredLightHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_CONTORL_INFRARED_LIGHT_X) == count && memcmp(ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_COMMAND_OFFSET,
                                                                (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                                PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode =
            calculate_check_sum(REPLY_ASK_CONTORL_INFRARED_LIGHT_X,
                                sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_CONTORL_INFRARED_LIGHT_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->ContorlInfraredLightInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_ASK_CONTORL_INFRARED_LIGHT_X, sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_CONTORL_INFRARED_LIGHT_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "ContorlInfraredLightInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "ContorlInfraredLightInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
bool McuProtocolTestTool::GetPhotosensitivityValueHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                         const void *buf, size_t count)
{
    if (sizeof(ASK_GET_PHOTOSENSITIVITY_X) == count && memcmp(ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_COMMAND_OFFSET,
                                                              (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                              PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(
            REPLY_ASK_GET_PHOTOSENSITIVITY_X, sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_GET_PHOTOSENSITIVITY_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->GetPhotosensitivityValueInit(mock, uartFd, buf, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                       const void *buf, size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_ASK_GET_PHOTOSENSITIVITY_X, sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_GET_PHOTOSENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "GetPhotosensitivityValueInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "GetPhotosensitivityValueInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
}
void McuProtocolTestTool::UnlockProtocolHandle(void)
{
    auto unlockThread = [=](McuProtocolTestTool *testTool) { testTool->UnlockThread(); };
    if (mUnLockThread.joinable()) {
        mUnLockThread.join();
    }
    mUnLockThread = std::thread(unlockThread, this);
}
void McuProtocolTestTool::LockProtocolHandle(void)
{
    //
    mMutex.lock();
}
void McuProtocolTestTool::UnlockThread(void)
{
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
    mMutex.unlock();
}
void McuProtocolTestTool::PipeSelectTimeoutForProtocolHandleImmediately(void)
{
    constexpr int WRITE_FAILD = -1;
    if (true == mPipeFdMockSelectInit) {
        ssize_t length = write(mPipeFdMockSelect[PIPE_WRITE_FD_INDEX], gPipeBuf, strlen(gPipeBuf));
        if (WRITE_FAILD == length) {
            LogError("mPipeFdMockSelect failed.\n");
            return;
        }
        if ((size_t)length != strlen(gPipeBuf)) {
            LogWarning("Something wrong happened.\n");
        }
    }
}
void McuProtocolTestTool::OtherSideAskIpcMissionHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                       const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskIpcMissionHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskIpcMissionInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskIpcMissionInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const unsigned int &serialNumber)
{
    LockProtocolHandle();
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(
        OTHER_SIDE_ASK_SEND_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_SEND_IPC_MISSION_X, sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X));
    ReplySelectSucceed(mock, uartFd);
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskIpcMissionInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_IPC_MISSION_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskIpcMissionInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION,
                                           nullptr,
                                           sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X));
    }
}
void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log)
{
    printf("%s { 0x%02X", log, *(unsigned char *)buf);
    for (size_t i = 1; i < bufLength; i++) {
        printf(", 0x%02X", *((unsigned char *)buf + i));
    }
    printf(" }\n");
}