/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * 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 <gtest/gtest.h>

#include "if_system_ability_manager.h"
#include "param_stub.h"
#include "iservice_registry.h"
#include "iwatcher.h"
#include "iwatcher_manager.h"
#include "message_parcel.h"
#include "param_message.h"
#include "init_param.h"
#include "param_utils.h"
#include "parcel.h"
#include "securec.h"
#include "system_ability_definition.h"
#include "string_ex.h"
#include "watcher.h"
#include "watcher_manager.h"
#include "watcher_proxy.h"
#include "watcher_utils.h"

using namespace testing::ext;
using namespace std;
using namespace OHOS;
using namespace OHOS::init_param;

class TestWatcher final : public Watcher {
public:
    TestWatcher() {}
    ~TestWatcher() = default;

    void OnParameterChange(const std::string &prefix, const std::string &name, const std::string &value) override
    {
        printf("TestWatcher::OnParameterChange name %s %s \n", name.c_str(), value.c_str());
    }
};

using WatcherManagerPtr = WatcherManager *;
class WatcherProxyUnitTest : public ::testing::Test {
public:
    WatcherProxyUnitTest() {}
    virtual ~WatcherProxyUnitTest() {}

    void SetUp()
    {
        if (GetParamSecurityLabel() != nullptr) {
            GetParamSecurityLabel()->cred.uid = 0;
            GetParamSecurityLabel()->cred.gid = 0;
        }
        SetTestPermissionResult(0);
    }
    void TearDown() {}
    void TestBody() {}

    int TestAddRemoteWatcher(uint32_t agentId, uint32_t &watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;

        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        sptr<IWatcher> watcher = new TestWatcher();
        bool ret = data.WriteRemoteObject(watcher->AsObject());
        WATCHER_CHECK(ret, return 0, "Can not get remote");
        data.WriteUint32(agentId);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::ADD_REMOTE_AGENT), data, reply, option);
        watcherId = reply.ReadUint32();
        EXPECT_NE(watcherId, 0);

        auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
        if (remoteWatcher != nullptr) {
            EXPECT_EQ(remoteWatcher->GetAgentId(), agentId);
        } else {
            EXPECT_EQ(0, agentId);
        }
        return 0;
    }

    int TestDelRemoteWatcher(uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;

        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteUint32(watcherId);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::DEL_REMOTE_AGENT), data, reply, option);
        EXPECT_EQ(reply.ReadInt32(), 0);
        EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
        return 0;
    }

    int TestAddWatcher(const std::string &keyPrefix, uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;

        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteString(keyPrefix);
        data.WriteUint32(watcherId);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::ADD_WATCHER), data, reply, option);
        EXPECT_EQ(reply.ReadInt32(), 0);
        EXPECT_EQ(watcherManager->GetWatcherGroup(keyPrefix) != nullptr, 1);
        return 0;
    }

    int TestRefreshWatcher(const std::string &keyPrefix, uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;

        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteString(keyPrefix);
        data.WriteUint32(watcherId);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER), data, reply, option);
        EXPECT_EQ(reply.ReadInt32(), 0);
        EXPECT_EQ(watcherManager->GetWatcherGroup(keyPrefix) != nullptr, 1);
        return 0;
    }

    int TestDelWatcher(const std::string &keyPrefix, uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;
        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteString(keyPrefix);
        data.WriteUint32(watcherId);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::DEL_WATCHER), data, reply, option);
        EXPECT_EQ(reply.ReadInt32(), 0);
        return 0;
    }

    int TestProcessWatcherMessage(const std::string &name, uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
        const std::string value("test.value");
        uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + value.size();
        msgSize = PARAM_ALIGN(msgSize); // align
        std::vector<char> buffer(msgSize, 0);
        ParamMessage *msg = reinterpret_cast<ParamMessage *>(buffer.data());
        WATCHER_CHECK(msg != nullptr, return -1, "Invalid msg");
        msg->type = MSG_NOTIFY_PARAM;
        msg->msgSize = msgSize;
        msg->id.watcherId = watcherId;
        int ret = memcpy_s(msg->key, sizeof(msg->key), name.c_str(), name.size());
        WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
        uint32_t offset = 0;
        ret = FillParamMsgContent(msg, &offset, PARAM_VALUE, value.c_str(), value.size());
        WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
        watcherManager->ProcessWatcherMessage(msg);
        return 0;
    }

    int TestWatchProxy(const std::string &name, const std::string &value)
    {
        sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
        EXPECT_NE(systemMgr, nullptr);
        sptr<IRemoteObject> remoteObj = systemMgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
        EXPECT_NE(remoteObj, nullptr);
        WatcherProxy *watcher = new WatcherProxy(remoteObj);
        if (watcher != nullptr) {
            watcher->OnParameterChange(name, name, value);
            delete watcher;
        }
        return 0;
    }

    int TestWatchAgentDump(const std::string &keyPrefix)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        // dump watcher
        std::vector<std::u16string> args = {};
        watcherManager->Dump(STDOUT_FILENO, args);
        // dump parameter
        args.push_back(Str8ToStr16("-h"));
        watcherManager->Dump(STDOUT_FILENO, args);
        args.clear();
        args.push_back(Str8ToStr16("-k"));
        args.push_back(Str8ToStr16(keyPrefix.c_str()));
        watcherManager->Dump(STDOUT_FILENO, args);
        return 0;
    }

    int TestWatchAgentDied(uint32_t watcherId)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
        auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
        WATCHER_CHECK(remoteWatcher != nullptr, return -1, "Failed to get remote watcher");
        if (watcherManager->GetDeathRecipient() != nullptr) {
            watcherManager->GetDeathRecipient()->OnRemoteDied(remoteWatcher->GetWatcher()->AsObject());
        }
        EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
        return 0;
    }

    int TestInvalid(const std::string &keyPrefix)
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
        MessageParcel data;
        MessageParcel reply;
        MessageOption option;
        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteString(keyPrefix);
        data.WriteUint32(0);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER) + 1, data, reply, option);

        data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
        data.WriteString(keyPrefix);
        watcherManager->OnRemoteRequest(
            static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER) + 1, data, reply, option);
        return 0;
    }

    int TestStop()
    {
        WatcherManagerPtr watcherManager = GetWatcherManager();
        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
        watcherManager->OnStop();
        watcherManager->Clear();
        return 0;
    }

    WatcherManagerPtr GetWatcherManager()
    {
        static WatcherManagerPtr watcherManager_ = nullptr;
        if (watcherManager_ == nullptr) {
            watcherManager_ = new WatcherManager(0, true);
            if (watcherManager_ == nullptr) {
                return nullptr;
            }
            watcherManager_->OnStart();
        }
        return watcherManager_;
    }
};

HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.test1", watcherId);
    test.TestRefreshWatcher("test.permission.watcher.test1", watcherId);
    test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId);
    test.TestWatchAgentDump("test.permission.watcher.test1");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_002, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.test2", watcherId);
    test.TestAddWatcher("test.permission.watcher.test2", watcherId);
    test.TestAddWatcher("test.permission.watcher.test2", watcherId);
    test.TestRefreshWatcher("test.permission.watcher.test2", watcherId);
    test.TestWatchAgentDump("test.permission.watcher.test2");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_003, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.test3", watcherId);
    test.TestWatchAgentDump("test.permission.watcher.test3");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_004, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    SystemWriteParam("test.watcher.test4", "1101");
    SystemWriteParam("test.watcher.test4.test", "1102");
    test.TestAddWatcher("test.watcher.test4*", watcherId);
    test.TestWatchAgentDump("test.watcher.test4*");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_005, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.test5", watcherId);
    SystemWriteParam("test.permission.watcher.test5", "1101");
    test.TestWatchAgentDump("test.permission.watcher.test5");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestDelWatcher_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.testDel", watcherId);
    test.TestDelWatcher("test.permission.watcher.testDel", watcherId);
    test.TestDelRemoteWatcher(watcherId);
    test.TestWatchAgentDump("test.permission.watcher.testDel");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestDiedWatcher_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.testdied", watcherId);
    test.TestDelWatcher("test.permission.watcher.testdied", watcherId);
    test.TestWatchAgentDied(watcherId);
    test.TestWatchAgentDump("test.permission.watcher.testdied");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestSendLocalChange_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.watcher*", watcherId);
    test.TestAddWatcher("test.watcher.", watcherId);
    test.TestWatchAgentDump("test.watcher.");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestWatchProxy_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestInvalid_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    test.TestInvalid("test.permission.watcher.test1");
}

HWTEST_F(WatcherProxyUnitTest, Init_TestStop_001, TestSize.Level0)
{
    WatcherProxyUnitTest test;
    uint32_t watcherId = 0;
    test.TestAddRemoteWatcher(getpid(), watcherId);
    test.TestAddWatcher("test.permission.watcher.stop", watcherId);
    test.TestStop();
}