/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * 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.
 */

#define LOG_TAG "VtsHalAutomotiveRemoteAccess"

#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/automotive/remoteaccess/ApState.h>
#include <aidl/android/hardware/automotive/remoteaccess/BnRemoteTaskCallback.h>
#include <aidl/android/hardware/automotive/remoteaccess/IRemoteAccess.h>
#include <aidl/android/hardware/automotive/remoteaccess/ScheduleInfo.h>
#include <aidl/android/hardware/automotive/remoteaccess/TaskType.h>
#include <android-base/thread_annotations.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <algorithm>
#include <chrono>
#include <string>
#include <thread>
#include <vector>

using ::aidl::android::hardware::automotive::remoteaccess::ApState;
using ::aidl::android::hardware::automotive::remoteaccess::BnRemoteTaskCallback;
using ::aidl::android::hardware::automotive::remoteaccess::IRemoteAccess;
using ::aidl::android::hardware::automotive::remoteaccess::ScheduleInfo;
using ::aidl::android::hardware::automotive::remoteaccess::TaskType;
using ::android::getAidlHalInstanceNames;
using ::android::PrintInstanceNameToString;
using ::android::base::ScopedLockAssertion;
using ::ndk::ScopedAStatus;
using ::ndk::SharedRefBase;
using ::ndk::SpAIBinder;
using ::testing::UnorderedElementsAre;

namespace {

const std::string TEST_CLIENT_ID = "TEST CLIENT ID";
const std::string TEST_SCHEDULE_ID = "TEST SCHEDULE ID";
const std::string TEST_SCHEDULE_ID_1 = "TEST SCHEDULE ID 1";
const std::string TEST_SCHEDULE_ID_2 = "TEST SCHEDULE ID 2";
const std::vector<uint8_t> TEST_TASK_DATA =
        std::vector<uint8_t>({static_cast<uint8_t>(0xde), static_cast<uint8_t>(0xad),
                              static_cast<uint8_t>(0xbe), static_cast<uint8_t>(0xef)});
const int32_t JOB_DELAY_IN_SECONDS = 5;

}  // namespace

class VtsHalAutomotiveRemoteAccessTargetTest : public testing::TestWithParam<std::string> {
  public:
    virtual void SetUp() override {
        const std::string& name = GetParam();
        mHal = IRemoteAccess::fromBinder(SpAIBinder(AServiceManager_waitForService(name.c_str())));
        ASSERT_NE(mHal, nullptr) << "Failed to connect to remote access HAL: " << name;
    }

    virtual void TearDown() override {
        if (mHal != nullptr) {
            mHal->clearRemoteTaskCallback();
            mHal->unscheduleAllTasks(TEST_CLIENT_ID);
        }
    }

  protected:
    std::shared_ptr<IRemoteAccess> mHal;

    bool isTaskScheduleSupported();
    int32_t getInterfaceVersion();
    ScheduleInfo getTestScheduleInfo(int32_t delayInSeconds, int32_t count,
                                     int32_t periodicInSeconds);
    void setTaskCallbackAndReadyForTask(std::shared_ptr<BnRemoteTaskCallback> testCallback);
};

class TestRemoteTaskCallback final : public BnRemoteTaskCallback {
  public:
    ScopedAStatus onRemoteTaskRequested(const std::string& clientId,
                                        const std::vector<uint8_t>& data) override {
        {
            std::unique_lock<std::mutex> lockGuard(mLock);
            mClientIds.push_back(clientId);
            mDataList.push_back(data);
        }
        mCv.notify_one();
        return ScopedAStatus::ok();
    }

    const std::vector<std::string> getCalledClientIds() {
        std::lock_guard<std::mutex> lockGuard(mLock);
        return mClientIds;
    }

    const std::vector<std::vector<uint8_t>> getCalledDataList() {
        std::lock_guard<std::mutex> lockGuard(mLock);
        return mDataList;
    }

    bool waitForCallbacks(size_t count, int32_t timeoutInSeconds) {
        std::unique_lock lk(mLock);
        return mCv.wait_for(lk, std::chrono::seconds(timeoutInSeconds), [this, count] {
            ScopedLockAssertion lockAssertion(mLock);
            return mClientIds.size() >= count;
        });
    }

  private:
    std::mutex mLock;
    std::vector<std::string> mClientIds GUARDED_BY(mLock);
    std::vector<std::vector<uint8_t>> mDataList GUARDED_BY(mLock);
    std::condition_variable mCv;
};

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testGetVehicleId) {
    std::string vehicleId;

    ScopedAStatus status = mHal->getVehicleId(&vehicleId);

    ASSERT_TRUE(status.isOk()) << "Failed to call getVehicleId";
    ASSERT_FALSE(vehicleId.empty()) << "Vehicle ID must not be empty";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testGetWakeupServiceName) {
    std::string wakeupServiceName;

    ScopedAStatus status = mHal->getWakeupServiceName(&wakeupServiceName);

    ASSERT_TRUE(status.isOk()) << "Failed to call getWakeupServiceName";
    ASSERT_FALSE(wakeupServiceName.empty()) << "Wakeup service name must not be empty";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testGetProcessorId) {
    std::string processorId;

    ScopedAStatus status = mHal->getProcessorId(&processorId);

    ASSERT_TRUE(status.isOk()) << "Failed to call getProcessorId";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testSetClearRemoteTaskCallback) {
    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();

    ScopedAStatus status = mHal->setRemoteTaskCallback(testCallback);

    ASSERT_TRUE(status.isOk()) << "Failed to call setRemoteTaskCallback";

    status = mHal->clearRemoteTaskCallback();

    ASSERT_TRUE(status.isOk()) << "Failed to call clearRemoteTaskCallback";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testNotifyApStateChange) {
    ApState apState = ApState{
            .isReadyForRemoteTask = false,
            .isWakeupRequired = false,
    };

    ScopedAStatus status = mHal->notifyApStateChange(apState);

    ASSERT_TRUE(status.isOk()) << "Failed to call notifyApStateChange with state: "
                               << apState.toString();

    apState = ApState{
            .isReadyForRemoteTask = true,
            .isWakeupRequired = false,
    };

    ASSERT_TRUE(status.isOk()) << "Failed to call notifyApStateChange with state: "
                               << apState.toString();
}

int32_t VtsHalAutomotiveRemoteAccessTargetTest::getInterfaceVersion() {
    int32_t interfaceVersion = 0;
    mHal->getInterfaceVersion(&interfaceVersion);
    return interfaceVersion;
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testIsTaskScheduleSupported) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    bool supported;

    ScopedAStatus status = mHal->isTaskScheduleSupported(&supported);

    ASSERT_TRUE(status.isOk()) << "Failed to call isTaskScheduleSupported";
}

bool VtsHalAutomotiveRemoteAccessTargetTest::isTaskScheduleSupported() {
    bool supported = false;
    mHal->isTaskScheduleSupported(&supported);
    return supported;
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testGetSupportedTaskTypesForScheduling) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::vector<TaskType> supportedTaskTypes;

    ScopedAStatus status = mHal->getSupportedTaskTypesForScheduling(&supportedTaskTypes);

    ASSERT_TRUE(status.isOk()) << "Failed to call getSupportedTaskTypesForScheduling";

    if (!isTaskScheduleSupported()) {
        ASSERT_TRUE(supportedTaskTypes.empty())
                << "getSupportedTaskTypesForScheduling must return empty array "
                << "if isTaskScheduleSupported is false";
        return;
    }

    ASSERT_TRUE(std::find(supportedTaskTypes.begin(), supportedTaskTypes.end(), TaskType::CUSTOM) !=
                supportedTaskTypes.end())
            << "getSupportedTaskTypesForScheduling must contain TaskType::CUSTOM";
}

ScheduleInfo VtsHalAutomotiveRemoteAccessTargetTest::getTestScheduleInfo(
        int32_t delayInSeconds, int32_t count, int32_t periodicInSeconds) {
    auto nowInEpochSeconds = std::chrono::duration_cast<std::chrono::seconds>(
                                     std::chrono::system_clock::now().time_since_epoch())
                                     .count();

    return ScheduleInfo{
            .clientId = TEST_CLIENT_ID,
            .scheduleId = TEST_SCHEDULE_ID,
            .taskType = TaskType::CUSTOM,
            .taskData = TEST_TASK_DATA,
            .count = count,
            .startTimeInEpochSeconds = nowInEpochSeconds + delayInSeconds,
            .periodicInSeconds = periodicInSeconds,
    };
}

void VtsHalAutomotiveRemoteAccessTargetTest::setTaskCallbackAndReadyForTask(
        std::shared_ptr<BnRemoteTaskCallback> testCallback) {
    mHal->setRemoteTaskCallback(testCallback);
    // Notify isReadForRemoteTask to be true.
    mHal->notifyApStateChange(ApState{
            .isReadyForRemoteTask = true,
            .isWakeupRequired = false,
    });
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testScheduleTask) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();
    setTaskCallbackAndReadyForTask(testCallback);

    int32_t count = 2;
    ScheduleInfo scheduleInfo = getTestScheduleInfo(
            /*delayInSeconds=*/JOB_DELAY_IN_SECONDS, count, /*periodicInSeconds=*/1);
    ScopedAStatus status = mHal->scheduleTask(scheduleInfo);

    if (!isTaskScheduleSupported()) {
        ASSERT_FALSE(status.isOk()) << "scheduleTask must return EX_ILLEGAL_ARGUMENT "
                                    << "if isTaskScheduleSupported is false";
        ASSERT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT)
                << "scheduleTask must return EX_ILLEGAL_ARGUMENT "
                << "if isTaskScheduleSupported is false";
        return;
    }

    ASSERT_TRUE(status.isOk()) << "Failed to call scheduleTask with scheduleInfo: "
                               << scheduleInfo.toString();

    int32_t timeoutInSeconds = JOB_DELAY_IN_SECONDS + 5;
    bool gotCallbacks = testCallback->waitForCallbacks(count, timeoutInSeconds);
    // unschedule the task before checking the result.
    mHal->unscheduleTask(TEST_CLIENT_ID, TEST_SCHEDULE_ID);

    ASSERT_TRUE(gotCallbacks) << "Callbacks is not called enough times before timeout: "
                              << timeoutInSeconds << "s";
    std::vector<std::vector<uint8_t>> dataList = testCallback->getCalledDataList();
    std::vector<std::string> clientIds = testCallback->getCalledClientIds();

    for (size_t i = 0; i < dataList.size(); i++) {
        EXPECT_EQ(dataList[i], TEST_TASK_DATA) << "Must receive expected task data";
        EXPECT_EQ(clientIds[i], TEST_CLIENT_ID) << "Must receive expected client id";
    }
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testUnscheduleTask) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();
    setTaskCallbackAndReadyForTask(testCallback);

    ScheduleInfo scheduleInfo = getTestScheduleInfo(
            /*delayInSeconds=*/JOB_DELAY_IN_SECONDS, /*count=*/1, /*periodicInSeconds=*/0);
    mHal->scheduleTask(scheduleInfo);
    ScopedAStatus status = mHal->unscheduleTask(TEST_CLIENT_ID, TEST_SCHEDULE_ID);

    ASSERT_TRUE(status.isOk()) << "Failed to call unscheduleTask";

    // If not cancelled, should be called in 5s, wait for 6s and make sure no task arrives.
    std::this_thread::sleep_for(std::chrono::seconds(JOB_DELAY_IN_SECONDS + 1));

    ASSERT_TRUE(testCallback->getCalledClientIds().empty())
            << "Remote task callback must not be called if the task is cancelled";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testUnscheduleAllTasks) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();
    setTaskCallbackAndReadyForTask(testCallback);

    ScheduleInfo scheduleInfo = getTestScheduleInfo(
            /*delayInSeconds=*/JOB_DELAY_IN_SECONDS, /*count=*/1, /*periodicInSeconds=*/0);
    mHal->scheduleTask(scheduleInfo);
    ScopedAStatus status = mHal->unscheduleAllTasks(TEST_CLIENT_ID);

    ASSERT_TRUE(status.isOk()) << "Failed to call unscheduleAllTasks";

    // If not cancelled, should be called in 5s, wait for 6s and make sure no task arrives.
    std::this_thread::sleep_for(std::chrono::seconds(JOB_DELAY_IN_SECONDS + 1));

    ASSERT_TRUE(testCallback->getCalledClientIds().empty())
            << "Remote task callback must not be called if the task is cancelled";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testIsTaskScheduled) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();
    setTaskCallbackAndReadyForTask(testCallback);

    ScheduleInfo scheduleInfo = getTestScheduleInfo(
            /*delayInSeconds=*/JOB_DELAY_IN_SECONDS, /*count=*/1, /*periodicInSeconds=*/0);
    mHal->scheduleTask(scheduleInfo);

    bool scheduled;
    ScopedAStatus status = mHal->isTaskScheduled(TEST_CLIENT_ID, TEST_SCHEDULE_ID, &scheduled);

    ASSERT_TRUE(status.isOk()) << "Failed to call unscheduleTask";

    if (!isTaskScheduleSupported()) {
        ASSERT_FALSE(scheduled) << "isTaskScheduled must return false "
                                << "if isTaskScheduleSupported is false";
        return;
    }

    ASSERT_TRUE(scheduled) << "isTaskScheduled must return true if the task is scheduled";

    mHal->unscheduleAllTasks(TEST_CLIENT_ID);
    status = mHal->isTaskScheduled(TEST_CLIENT_ID, TEST_SCHEDULE_ID, &scheduled);

    ASSERT_TRUE(status.isOk()) << "Failed to call unscheduleTask";
    ASSERT_FALSE(scheduled) << "isTaskScheduled must return false if the task is not scheduled";
}

TEST_P(VtsHalAutomotiveRemoteAccessTargetTest, testGetAllPendingScheduledTasks) {
    if (getInterfaceVersion() < 2) {
        GTEST_SKIP() << "Require RemoteAccess HAL v2";
    }

    std::shared_ptr<TestRemoteTaskCallback> testCallback =
            SharedRefBase::make<TestRemoteTaskCallback>();
    setTaskCallbackAndReadyForTask(testCallback);

    auto nowInEpochSeconds = std::chrono::duration_cast<std::chrono::seconds>(
                                     std::chrono::system_clock::now().time_since_epoch())
                                     .count();

    ScheduleInfo scheduleInfo1 = ScheduleInfo{
            .clientId = TEST_CLIENT_ID,
            .scheduleId = TEST_SCHEDULE_ID_1,
            .taskType = TaskType::CUSTOM,
            .taskData = TEST_TASK_DATA,
            .count = 1,
            .startTimeInEpochSeconds = nowInEpochSeconds + 5,
            .periodicInSeconds = 0,
    };
    ScheduleInfo scheduleInfo2 = ScheduleInfo{
            .clientId = TEST_CLIENT_ID,
            .scheduleId = TEST_SCHEDULE_ID_2,
            .taskType = TaskType::CUSTOM,
            .taskData = TEST_TASK_DATA,
            .count = 10,
            .startTimeInEpochSeconds = nowInEpochSeconds + 10,
            .periodicInSeconds = 1,
    };
    mHal->scheduleTask(scheduleInfo1);
    mHal->scheduleTask(scheduleInfo2);

    std::vector<ScheduleInfo> outScheduleInfo;
    ScopedAStatus status = mHal->getAllPendingScheduledTasks(TEST_CLIENT_ID, &outScheduleInfo);

    ASSERT_TRUE(status.isOk()) << "Failed to call getAllPendingScheduledTasks";

    if (!isTaskScheduleSupported()) {
        ASSERT_TRUE(outScheduleInfo.empty())
                << "Must return empty array for getAllPendingScheduledTasks "
                << "if isTaskScheduleSupported is false";
        return;
    }

    ASSERT_THAT(outScheduleInfo, UnorderedElementsAre(scheduleInfo1, scheduleInfo2))
            << "expected all pending schedule info mismatch";

    mHal->unscheduleTask(TEST_CLIENT_ID, TEST_SCHEDULE_ID_1);

    status = mHal->getAllPendingScheduledTasks(TEST_CLIENT_ID, &outScheduleInfo);

    ASSERT_TRUE(status.isOk()) << "Failed to call getAllPendingScheduledTasks";

    ASSERT_THAT(outScheduleInfo, UnorderedElementsAre(scheduleInfo2))
            << "expected all pending schedule info mismatch";
}

// It is possible that no remote access HAL is registered.
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VtsHalAutomotiveRemoteAccessTargetTest);

INSTANTIATE_TEST_SUITE_P(PerInstance, VtsHalAutomotiveRemoteAccessTargetTest,
                         testing::ValuesIn(getAidlHalInstanceNames(IRemoteAccess::descriptor)),
                         PrintInstanceNameToString);

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    // Starts a process pool for callbacks.
    ABinderProcess_setThreadPoolMaxThreadCount(1);
    ABinderProcess_startThreadPool();
    return RUN_ALL_TESTS();
}