/*
 * 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 "ILog.h"
#include "IMcuManager.h"
#include "McuAskBase.h"
#include "McuAskBaseTestTool.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <thread>
namespace McuManagerTest
{
class McuManagerTest : public testing::Test
{
public:
    McuManagerTest()
    {
    }
    virtual ~McuManagerTest()
    {
    }
    static void SetUpTestCase()
    {
        CreateLogModule();
        ILogInit(LOG_INSTANCE_TYPE_END);
    }
    static void TearDownTestCase()
    {
        ILogUnInit();
    }
    virtual void SetUp()
    {
        CreateMcuManager();
        IMcuManager::GetInstance()->Init();
    }
    virtual void TearDown()
    {
        IMcuManager::GetInstance()->UnInit();
        DestroyMcuManager();
    }
};
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_GetIpcMission
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_GetIpcMission)
{
    class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
    {
    public:
        McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
        {
            mDataReply = IpcMission::END;
        }
        virtual ~McuAskTest() = default;
        void ReplyFinished(const bool result) override
        {
            McuAskBaseTestTool::ReplyFinished(result);
            if (result) {
                LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
                // Do something here.
                EXPECT_GT(static_cast<int>(mDataReply), 0);
                EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(IpcMission::END));
            }
            else {
                LogError("Ask data falied.\n");
            }
        }
    };
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    IMcuManager::GetInstance()->GetIpcMission(ask);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
{
    class MonitorTest : public VMcuMonitor
    {
    public:
        MonitorTest() = default;
        virtual ~MonitorTest() = default;
        void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
        {
            LogInfo("RecvIpcMissionEvent %s\n", IMcuManager::GetInstance()->PrintIpcMissionString(mission));
            std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
            ask->mDataReply = ASK_RESULT::SUCCEED;
            recv->ReplyFinished(true);
        }
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
    IMcuManager::GetInstance()->SetMcuMonitor(monitor);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    // IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply)
{
    class McuAskTest : public McuAskBaseTestTool
    {
    public:
        McuAskTest()
            : McuAskBaseTestTool(McuAskBlock::UNRELATED,
                                 McuAskReply::NEED_NOT_REPLY) // using McuAskReply::NEED_NOT_REPLY
        {
        }
        virtual ~McuAskTest() = default;
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    StatusCode code = IMcuManager::GetInstance()->CutOffPowerSupply(ask);
    EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    // IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog)
{
    class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
    {
    public:
        McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
                                          McuAskReply::NEED_REPLY) // using McuAskBlock::BLOCK,
        {
        }
        virtual ~McuAskTest() = default;
        void ReplyFinished(const bool result) override
        {
            McuAskBaseTestTool::ReplyFinished(result);
            if (result) {
                LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
                EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
            }
            else {
                LogError("Ask data falied.\n");
            }
        }
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1);
    EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    // IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_FeedWatchDog
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_FeedWatchDog)
{
    class McuAskTest : public McuAskBaseTestTool
    {
    public:
        McuAskTest()
            : McuAskBaseTestTool(McuAskBlock::UNRELATED,
                                 McuAskReply::NEED_NOT_REPLY) // using McuAskReply::NEED_NOT_REPLY
        {
        }
        virtual ~McuAskTest() = default;
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    StatusCode code = IMcuManager::GetInstance()->FeedWatchDog(ask);
    EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    // IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetDataTime
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetDataTime)
{
    class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
    {
    public:
        McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
                                          McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
        {
        }
        virtual ~McuAskTest() = default;
        void ReplyFinished(const bool result) override
        {
            McuAskBaseTestTool::ReplyFinished(result);
            if (result) {
                LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
                EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
            }
            else {
                LogError("Ask data falied.\n");
            }
        }
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    McuAskDateTime value(2014, 1, 15, 0, 0, 0);
    StatusCode code = IMcuManager::GetInstance()->SetDateTime(ask, value);
    EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    // IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity)
{
    class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
    {
    public:
        McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
                                          McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
        {
        }
        virtual ~McuAskTest() = default;
        void ReplyFinished(const bool result) override
        {
            McuAskBaseTestTool::ReplyFinished(result);
            if (result) {
                LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
                EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
            }
            else {
                LogError("Ask data falied.\n");
            }
        }
    };
    // IMcuManager::GetInstance()->Init();
    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
    std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
    testTool->McuAskDefaultFeatures(testTool);
    StatusCode code = IMcuManager::GetInstance()->SetPirSensitivity(ask, 1);
    EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    // IMcuManager::GetInstance()->UnInit();
}
} // namespace McuManagerTest