/*
 * 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 "KeyControlMock.h"
#include "ILog.h"
KeyControlTest::KeyControlTest(const std::string &keyName) : mKeyName(keyName)
{
    //
}
void KeyControlTest::SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor)
{
    //
    mMonitor = monitor;
}
void KeyControlTest::CheckKeyStatus(void)
{
    //
    TimerKeyEventTrigger(KeyHalEvent::PRESSING);
}
void KeyControlTest::KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs)
{
    LogInfo("KeyEventTrigger keyName = %s, event = %s, time = %u\n", keyName.c_str(), PrintKeyEvent(event), timeMs);
    KeyEventTriggerTrace(keyName, event, timeMs);
    auto monitor = mMonitor.lock();
    if (mMonitor.expired()) {
        LogError("monitor is nullptr.\n");
        return;
    }
    monitor->KeyEventHappened(keyName, static_cast<VirtualKeyEvent>(event), timeMs);
}
KeyControlMock::KeyControlMock(const std::string &keyName) : KeyControlTest(keyName)
{
    //
}
void KeyControlMock::SetKeyEvent(const KeyHalEvent &event)
{
    //
    KeyHalEventTrigger(event);
}
bool KeyControlMock::SetKeyClick(const unsigned int &pressingTimeMs)
{
    if (mMutex.try_lock()) {
        auto keyClickThread = [=](std::shared_ptr<KeyControlMock> key) {
            KeyEventHappendOnce(key, pressingTimeMs);
            key->KeyHalEventTrigger(KeyHalEvent::PRESSING);
            std::this_thread::sleep_for(std::chrono::milliseconds(pressingTimeMs));
            key->KeyHalEventTrigger(KeyHalEvent::NOT_PRESSING);
            mMutex.unlock();
        };
        std::shared_ptr<KeyControl> tmp = KeyControl::shared_from_this();
        std::shared_ptr<KeyControlMock> key = std::dynamic_pointer_cast<KeyControlMock>(tmp);
        std::thread clickThread = std::thread(keyClickThread, key);
        clickThread.detach();
        return true;
    }
    LogWarning("SetKeyClick failed, becase key was lock.\n");
    return false;
}
void KeyControlMock::KeyEventHappendOnce(std::shared_ptr<KeyControlMock> &mock, const unsigned int &pressingTimeMs)
{
    EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(_, _, _))
        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
    constexpr int CLICK_EVENT_HAPPENED_ONLY_ONCE = 1;
    constexpr int HOLD_UP_EVENT_HAPPENED_ONLY_ONCE = 1;
    if (KEY_ACTION_SHORT_CLICK <= pressingTimeMs && pressingTimeMs < KEY_ACTION_HOLD_DWON) {
        EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::SHORT_CLICK, _))
            .Times(CLICK_EVENT_HAPPENED_ONLY_ONCE)
            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
        return;
    }
    if (KEY_ACTION_HOLD_DWON <= pressingTimeMs) {
        EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::HOLD_DOWN, _))
            .Times(AtLeast(1))
            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
        EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::HOLD_UP, _))
            .Times(HOLD_UP_EVENT_HAPPENED_ONLY_ONCE)
            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
        return;
    }
    constexpr int KEY_SHOULD_NOT_TRIGGER_WHEN_NOBODY_SET_KEY_RESULT = 0;
    EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), _, _))
        .Times(KEY_SHOULD_NOT_TRIGGER_WHEN_NOBODY_SET_KEY_RESULT);
}