/*
 * Copyright (c) 2022 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 <iremote_broker.h>
#include <iremote_object.h>

#include "agent_death_recipient.h"
#include "color_parser.h"
#include "iremote_object_mocker.h"
#include "perform_reporter.h"
#include "singleton_container.h"
#include "surface_reader_handler_impl.h"
#include "sys_cap_util.h"
#include "wm_common.h"

using namespace testing;
using namespace testing::ext;

namespace OHOS {
namespace Rosen {
class TestClass {
public:
    std::string name = "testClass";
};

class UtilsAllTest : public testing::Test {
public:
    static void SetUpTestCase();
    static void TearDownTestCase();
    void SetUp() override;
    void TearDown() override;

    std::map<std::string, int32_t> oldStringMap_;
    std::map<int32_t, SingletonContainer::Singleton> oldSingletonMap_;
    std::map<int32_t, std::set<int32_t>> oldDependencySetMap_;
};

void UtilsAllTest::SetUpTestCase() {}

void UtilsAllTest::TearDownTestCase() {}

void UtilsAllTest::SetUp() {}

void UtilsAllTest::TearDown() {}

namespace {
/**
 * @tc.name: ADROnRemoteDied01
 * @tc.desc: test AgentDeathRecipient::OnRemoteDied
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, ADROnRemoteDied01, TestSize.Level1)
{
    sptr<AgentDeathRecipient> deathRecipient = new AgentDeathRecipient(nullptr);

    deathRecipient->OnRemoteDied(nullptr);

    sptr<MockIRemoteObject> remoteObj = new MockIRemoteObject();
    deathRecipient->OnRemoteDied(remoteObj);
    ASSERT_EQ(0, remoteObj->count_);

    deathRecipient->callback_ = [&remoteObj](sptr<IRemoteObject>& remote) { remoteObj->count_ = 1; };
    deathRecipient->OnRemoteDied(remoteObj);
    ASSERT_EQ(1, remoteObj->count_);
}

/**
 * @tc.name: PRCount01
 * @tc.desc: test PerformReporter::count
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, PRCount01, TestSize.Level1)
{
    std::vector<int64_t> timeSpiltsMs = { 0, 1, 2 };
    PerformReporter reporter = PerformReporter("test", timeSpiltsMs);

    reporter.count(0);
    ASSERT_EQ(1, reporter.totalCount_);
    reporter.timeSplitCount_.clear();
    ASSERT_EQ(1, reporter.totalCount_);
}

/**
 * @tc.name: SCAddSingleton01
 * @tc.desc: test SingletonContainer::AddSingleton
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SCAddSingleton01, TestSize.Level1)
{
    auto& singletonContainer = SingletonContainer::GetInstance();

    singletonContainer.AddSingleton("test", nullptr);
    auto testId = singletonContainer.stringMap["test"];
    singletonContainer.AddSingleton("test", nullptr);
    ASSERT_EQ(testId, singletonContainer.stringMap["test"]);
    singletonContainer.AddSingleton("test2", nullptr);
    ASSERT_EQ(testId + 1, singletonContainer.stringMap["test2"]);

    auto testId2 = singletonContainer.stringMap["test2"];
    singletonContainer.singletonMap.erase(testId);
    singletonContainer.singletonMap.erase(testId2);
    singletonContainer.stringMap.erase("test");
    singletonContainer.stringMap.erase("test2");
}

/**
 * @tc.name: SCSetSingleton01
 * @tc.desc: test SingletonContainer::AddSingleton
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SCSetSingleton01, TestSize.Level1)
{
    auto& singletonContainer = SingletonContainer::GetInstance();

    TestClass* testObj = new TestClass();

    singletonContainer.SetSingleton("test", testObj);
    auto testId = singletonContainer.stringMap["test"];
    auto instance = singletonContainer.GetSingleton("test2");
    ASSERT_EQ(instance, nullptr);

    instance = singletonContainer.GetSingleton("test");
    ASSERT_NE(instance, nullptr);
    ASSERT_EQ(static_cast<TestClass*>(instance)->name, "testClass");

    singletonContainer.SetSingleton("test", nullptr);
    instance = singletonContainer.GetSingleton("test");
    ASSERT_EQ(instance, nullptr);

    singletonContainer.singletonMap.erase(testId);
    singletonContainer.stringMap.erase("test");
    delete testObj;
}

/**
 * @tc.name: SCDependOn01
 * @tc.desc: test SingletonContainer::DependOn
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SCDependOn01, TestSize.Level1)
{
    auto& singletonContainer = SingletonContainer::GetInstance();

    singletonContainer.AddSingleton("test", nullptr);

    ASSERT_EQ(nullptr, singletonContainer.DependOn("test", "test"));

    auto id = singletonContainer.stringMap["test"];
    auto& testSet = singletonContainer.dependencySetMap[id];
    ASSERT_EQ(1, testSet.size());

    ASSERT_EQ(nullptr, singletonContainer.DependOn("test", "test"));
    id = singletonContainer.stringMap["test"];
    auto& testSet2 = singletonContainer.dependencySetMap[id];
    ASSERT_EQ(1, testSet2.size());

    singletonContainer.singletonMap.erase(id);
    singletonContainer.stringMap.erase("test");
    id = singletonContainer.dependencySetMap.erase(id);
}

/**
 * @tc.name: SRHOnImageAvailable01
 * @tc.desc: test SurfaceReaderHandlerImpl::OnImageAvailable
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SRHOnImageAvailable, TestSize.Level1)
{
    sptr<SurfaceReaderHandlerImpl> surfaceReaderHandlerImpl = new (std::nothrow) SurfaceReaderHandlerImpl();
    surfaceReaderHandlerImpl->flag_ = false;
    surfaceReaderHandlerImpl->OnImageAvailable(nullptr);
    ASSERT_EQ(true, surfaceReaderHandlerImpl->flag_);
    surfaceReaderHandlerImpl->flag_ = true;
    surfaceReaderHandlerImpl->OnImageAvailable(nullptr);
    ASSERT_EQ(true, surfaceReaderHandlerImpl->flag_);
}

/**
 * @tc.name: SRHGetPixelMap01
 * @tc.desc: test SurfaceReaderHandlerImpl::GetPixelMap
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SRHGetPixelMap, TestSize.Level1)
{
    sptr<SurfaceReaderHandlerImpl> surfaceReaderHandlerImpl = new (std::nothrow) SurfaceReaderHandlerImpl();
    surfaceReaderHandlerImpl->flag_ = false;
    surfaceReaderHandlerImpl->GetPixelMap();
    ASSERT_EQ(false, surfaceReaderHandlerImpl->flag_);
    surfaceReaderHandlerImpl->flag_ = true;
    surfaceReaderHandlerImpl->GetPixelMap();
}

/**
 * @tc.name: SysCapUtilGetClientName
 * @tc.desc: test SysCapUtil::GetClientName
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, SysCapUtilGetClientName, TestSize.Level1)
{
    ASSERT_NE("", SysCapUtil::GetClientName());
}

/**
 * @tc.name: ConvertErrorToCode
 * @tc.desc: test ConvertErrorToCode
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, ConvertErrorToCode, TestSize.Level1)
{
    EXPECT_EQ(ConvertErrorToCode(WMError::WM_OK), WmErrorCode::WM_OK);
    EXPECT_EQ(ConvertErrorToCode(WMError::WM_ERROR_FB_RESTORE_MAIN_WINDOW_FAILED),
        WmErrorCode::WM_ERROR_FB_RESTORE_MAIN_WINDOW_FAILED);
    WMError error = static_cast<WMError>(-1);
    EXPECT_EQ(ConvertErrorToCode(error), WmErrorCode::WM_ERROR_SYSTEM_ABNORMALLY);
}

/**
 * @tc.name: IsValidColorNoAlpha
 * @tc.desc: test IsValidColorNoAlpha
 * @tc.type: FUNC
 */
HWTEST_F(UtilsAllTest, IsValidColorNoAlpha, TestSize.Level1)
{
    EXPECT_TRUE(ColorParser::IsValidColorNoAlpha("#008EF5"));
    EXPECT_TRUE(ColorParser::IsValidColorNoAlpha("#FF008EF5"));
    EXPECT_FALSE(ColorParser::IsValidColorNoAlpha("InvalidColor"));
    EXPECT_FALSE(ColorParser::IsValidColorNoAlpha("#009HG5"));
    EXPECT_FALSE(ColorParser::IsValidColorNoAlpha("##009FF5"));
    EXPECT_FALSE(ColorParser::IsValidColorNoAlpha("#08EF5"));
    EXPECT_FALSE(ColorParser::IsValidColorNoAlpha("#80008EF5"));
}
} // namespace
} // namespace Rosen
} // namespace OHOS