// Copyright 2021 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <memory>
#include <optional>
#include <utility>
#include <vector>

#include "dawn/dawn_proc.h"
#include "dawn/native/Adapter.h"
#include "dawn/native/DawnNative.h"
#include "dawn/native/Device.h"
#include "dawn/native/Toggles.h"
#include "dawn/native/dawn_platform.h"
#include "dawn/tests/MockCallback.h"
#include "dawn/tests/StringViewMatchers.h"
#include "dawn/utils/SystemUtils.h"
#include "dawn/utils/WGPUHelpers.h"
#include "gtest/gtest.h"

namespace dawn::native {
namespace {

using testing::_;
using testing::Contains;
using testing::EmptySizedString;
using testing::IsNull;
using testing::MockCppCallback;
using testing::NonEmptySizedString;
using testing::StrEq;
using testing::WithArg;

class DeviceCreationTest : public testing::Test {
  protected:
    void SetUp() override {
        dawnProcSetProcs(&GetProcs());

        static constexpr auto kMultipleDevicesPerAdapter =
            wgpu::InstanceFeatureName::MultipleDevicesPerAdapter;
        // Create an instance with default toggles and create an adapter from it.
        wgpu::InstanceDescriptor safeInstanceDesc = {
            .requiredFeatureCount = 1,
            .requiredFeatures = &kMultipleDevicesPerAdapter,
        };
        instance = std::make_unique<Instance>(&safeInstanceDesc);

        wgpu::RequestAdapterOptions options = {};
        options.backendType = wgpu::BackendType::Null;

        // Get the null adapter with default toggles.
        adapter = instance->EnumerateAdapters(&options)[0];

        // Create an instance with toggle AllowUnsafeAPIs enabled, and create an unsafe adapter
        // from it.
        const char* allowUnsafeApisToggle = "allow_unsafe_apis";
        wgpu::DawnTogglesDescriptor unsafeInstanceTogglesDesc = {};
        unsafeInstanceTogglesDesc.enabledToggleCount = 1;
        unsafeInstanceTogglesDesc.enabledToggles = &allowUnsafeApisToggle;
        wgpu::InstanceDescriptor unsafeInstanceDesc = {
            .requiredFeatureCount = 1,
            .requiredFeatures = &kMultipleDevicesPerAdapter,
        };
        unsafeInstanceDesc.nextInChain = &unsafeInstanceTogglesDesc;

        unsafeInstance = std::make_unique<Instance>(&unsafeInstanceDesc);
        unsafeAdapter = unsafeInstance->EnumerateAdapters(&options)[0];

        ASSERT_NE(adapter.Get(), nullptr);
        ASSERT_NE(unsafeAdapter.Get(), nullptr);
    }

    void TearDown() override {
        adapter = nullptr;
        unsafeAdapter = nullptr;
        instance = nullptr;
        unsafeInstance = nullptr;
        dawnProcSetProcs(nullptr);
    }

    static constexpr size_t kTotalFeaturesCount = static_cast<size_t>(kEnumCount<Feature>);

    std::unique_ptr<Instance> instance;
    std::unique_ptr<Instance> unsafeInstance;
    Adapter adapter;
    Adapter unsafeAdapter;
};

// Test successful call to CreateDevice with no descriptor
TEST_F(DeviceCreationTest, CreateDeviceNoDescriptorSuccess) {
    wgpu::Device device = adapter.CreateDevice();
    EXPECT_NE(device, nullptr);
}

// Test successful call to CreateDevice with descriptor.
TEST_F(DeviceCreationTest, CreateDeviceSuccess) {
    wgpu::DeviceDescriptor desc = {};
    wgpu::Device device = adapter.CreateDevice(&desc);
    EXPECT_NE(device, nullptr);
}

// Test successful call to CreateDevice with allocator descriptor.
TEST_F(DeviceCreationTest, CreateDeviceWithAllocatorSuccess) {
    wgpu::DawnDeviceAllocatorControl allocationDesc = {};
    allocationDesc.allocatorHeapBlockSize = 4 * 1024;

    wgpu::DeviceDescriptor desc = {};
    wgpu::FeatureName feature = wgpu::FeatureName::DawnDeviceAllocatorControl;
    desc.requiredFeatures = &feature;
    desc.requiredFeatureCount = 1;
    desc.nextInChain = &allocationDesc;

    wgpu::Device device = unsafeAdapter.CreateDevice(&desc);
    EXPECT_NE(device, nullptr);
}

// Test failed call to CreateDevice with allocator descriptor. This is using an adapter that does
// not have DawnDeviceAllocatorControl feature enabled.
TEST_F(DeviceCreationTest, CreateDeviceWithAllocatorFailedMissingFeature) {
    wgpu::DawnDeviceAllocatorControl allocationDesc = {};
    allocationDesc.allocatorHeapBlockSize = 4 * 1024;

    wgpu::DeviceDescriptor desc = {};
    desc.nextInChain = &allocationDesc;

    wgpu::Device device = adapter.CreateDevice(&desc);
    EXPECT_EQ(device, nullptr);
}

// Test failed call to CreateDevice with allocator descriptor. The heap block size provided is not a
// power of two.
TEST_F(DeviceCreationTest, CreateDeviceWithAllocatorFailedHeapBlockSize) {
    wgpu::DawnDeviceAllocatorControl allocationDesc = {};
    allocationDesc.allocatorHeapBlockSize = 4 * 1024 + 1;

    wgpu::DeviceDescriptor desc = {};
    wgpu::FeatureName feature = wgpu::FeatureName::DawnDeviceAllocatorControl;
    desc.requiredFeatures = &feature;
    desc.requiredFeatureCount = 1;
    desc.nextInChain = &allocationDesc;

    wgpu::Device device = unsafeAdapter.CreateDevice(&desc);
    EXPECT_EQ(device, nullptr);
}

// Test successful call to CreateDevice with toggle descriptor.
TEST_F(DeviceCreationTest, CreateDeviceWithTogglesSuccess) {
    wgpu::DeviceDescriptor desc = {};
    wgpu::DawnTogglesDescriptor deviceTogglesDesc = {};
    desc.nextInChain = &deviceTogglesDesc;

    const char* toggle = "skip_validation";
    deviceTogglesDesc.enabledToggles = &toggle;
    deviceTogglesDesc.enabledToggleCount = 1;

    wgpu::Device device = adapter.CreateDevice(&desc);
    EXPECT_NE(device, nullptr);

    auto toggles = GetTogglesUsed(device.Get());
    EXPECT_THAT(toggles, Contains(StrEq(toggle)));
}

// Test experimental features are guarded by DisallowUnsafeApis adapter toggle, it is inherited from
// instance but can be overriden by device toggles.
TEST_F(DeviceCreationTest, CreateDeviceRequiringExperimentalFeatures) {
    // Ensure that unsafe apis are disallowed on safe adapter.
    ASSERT_FALSE(FromAPI(adapter.Get())->GetTogglesState().IsEnabled(Toggle::AllowUnsafeAPIs));
    // Ensure that unsafe apis are allowed unsafe adapter(s).
    ASSERT_TRUE(FromAPI(unsafeAdapter.Get())->GetTogglesState().IsEnabled(Toggle::AllowUnsafeAPIs));

    for (size_t i = 0; i < kTotalFeaturesCount; i++) {
        Feature feature = static_cast<Feature>(i);
        wgpu::FeatureName featureName = ToAPI(feature);

        // Only test experimental features.
        if (kFeatureNameAndInfoList[feature].featureState == FeatureInfo::FeatureState::Stable) {
            continue;
        }

        // wgpu::FeatureName::CoreFeaturesAndLimits is required implicitly in core mode
        static constexpr uint32_t kDefaultExpectedFeatureCount = 1u;

        wgpu::DeviceDescriptor deviceDescriptor;
        deviceDescriptor.requiredFeatures = &featureName;
        deviceDescriptor.requiredFeatureCount = 1;

        // Test creating device on default adapter would fail.
        {
            wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
            EXPECT_EQ(device, nullptr);
        }

        // Test creating device on the adapter with AllowUnsafeApis toggle enabled would succeed.
        {
            deviceDescriptor.nextInChain = nullptr;

            wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
            EXPECT_NE(device, nullptr);

            wgpu::SupportedFeatures supportedFeatures;
            device.GetFeatures(&supportedFeatures);
            uint32_t expectedFeatureCount = kDefaultExpectedFeatureCount +
                                            utils::FeatureAndImplicitlyEnabled(featureName).size();

            ASSERT_EQ(expectedFeatureCount, supportedFeatures.featureCount);

            bool foundFeatureName = false;
            for (uint32_t fi = 0; fi < supportedFeatures.featureCount; ++fi) {
                if (featureName == supportedFeatures.features[fi]) {
                    foundFeatureName = true;
                    break;
                }
            }
            EXPECT_TRUE(foundFeatureName);
        }

        // Test creating device with AllowUnsafeApis enabled in device toggle descriptor will
        // success on both adapter, as device toggles will override the inherited adapter toggles.
        {
            const char* const enableToggles[] = {"allow_unsafe_apis"};
            wgpu::DawnTogglesDescriptor deviceTogglesDesc;
            deviceTogglesDesc.enabledToggles = enableToggles;
            deviceTogglesDesc.enabledToggleCount = 1;
            deviceDescriptor.nextInChain = &deviceTogglesDesc;

            // Test on adapter with AllowUnsafeApis disabled.
            {
                wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
                EXPECT_NE(device, nullptr);

                wgpu::SupportedFeatures supportedFeatures;
                device.GetFeatures(&supportedFeatures);
                uint32_t expectedFeatureCount =
                    kDefaultExpectedFeatureCount +
                    utils::FeatureAndImplicitlyEnabled(featureName).size();

                ASSERT_EQ(expectedFeatureCount, supportedFeatures.featureCount);

                bool foundFeatureName = false;
                for (uint32_t fi = 0; fi < supportedFeatures.featureCount; ++fi) {
                    if (featureName == supportedFeatures.features[fi]) {
                        foundFeatureName = true;
                        break;
                    }
                }
                EXPECT_TRUE(foundFeatureName);
            }

            // Test on adapter with AllowUnsafeApis disabled.
            {
                wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
                EXPECT_NE(device, nullptr);

                wgpu::SupportedFeatures supportedFeatures;
                device.GetFeatures(&supportedFeatures);
                uint32_t expectedFeatureCount =
                    kDefaultExpectedFeatureCount +
                    utils::FeatureAndImplicitlyEnabled(featureName).size();

                ASSERT_EQ(expectedFeatureCount, supportedFeatures.featureCount);

                bool foundFeatureName = false;
                for (uint32_t fi = 0; fi < supportedFeatures.featureCount; ++fi) {
                    if (featureName == supportedFeatures.features[fi]) {
                        foundFeatureName = true;
                        break;
                    }
                }
                EXPECT_TRUE(foundFeatureName);
            }
        }

        // Test creating device with AllowUnsafeApis disabled in device toggle descriptor will fail
        // on both adapter, as device toggles will override the inherited adapter toggles.
        {
            const char* const disableToggles[] = {"allow_unsafe_apis"};
            wgpu::DawnTogglesDescriptor deviceToggleDesc;
            deviceToggleDesc.disabledToggles = disableToggles;
            deviceToggleDesc.disabledToggleCount = 1;
            deviceDescriptor.nextInChain = &deviceToggleDesc;

            // Test on adapter with DisallowUnsafeApis enabled.
            {
                wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
                EXPECT_EQ(device, nullptr);
            }

            // Test on adapter with DisallowUnsafeApis disabled.
            {
                wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
                EXPECT_EQ(device, nullptr);
            }
        }
    }
}

TEST_F(DeviceCreationTest, CreateDeviceWithCacheSuccess) {
    // Default device descriptor should have the same cache key as a device descriptor with a
    // default cache descriptor.
    {
        wgpu::DeviceDescriptor desc = {};
        wgpu::Device device1 = adapter.CreateDevice(&desc);
        EXPECT_NE(device1, nullptr);

        wgpu::DawnCacheDeviceDescriptor cacheDesc = {};
        desc.nextInChain = &cacheDesc;
        wgpu::Device device2 = adapter.CreateDevice(&desc);

        EXPECT_EQ(FromAPI(device1.Get())->GetCacheKey(), FromAPI(device2.Get())->GetCacheKey());
    }
    // Default device descriptor should not have the same cache key as a device descriptor with
    // a non-default cache descriptor.
    {
        wgpu::DeviceDescriptor desc = {};
        wgpu::Device device1 = adapter.CreateDevice(&desc);
        EXPECT_NE(device1, nullptr);

        wgpu::DawnCacheDeviceDescriptor cacheDesc = {};
        desc.nextInChain = &cacheDesc;
        const char* isolationKey = "isolation key";
        cacheDesc.isolationKey = isolationKey;
        wgpu::Device device2 = adapter.CreateDevice(&desc);
        EXPECT_NE(device2, nullptr);

        EXPECT_NE(FromAPI(device1.Get())->GetCacheKey(), FromAPI(device2.Get())->GetCacheKey());
    }
    // Two non-default cache descriptors should not have the same cache key.
    {
        wgpu::DawnCacheDeviceDescriptor cacheDesc = {};
        const char* isolationKey1 = "isolation key 1";
        const char* isolationKey2 = "isolation key 2";
        wgpu::DeviceDescriptor desc = {};
        desc.nextInChain = &cacheDesc;

        cacheDesc.isolationKey = isolationKey1;
        wgpu::Device device1 = adapter.CreateDevice(&desc);
        EXPECT_NE(device1, nullptr);

        cacheDesc.isolationKey = isolationKey2;
        wgpu::Device device2 = adapter.CreateDevice(&desc);
        EXPECT_NE(device2, nullptr);

        EXPECT_NE(FromAPI(device1.Get())->GetCacheKey(), FromAPI(device2.Get())->GetCacheKey());
    }
}

// Test that maxImmediateSize is available iff the adapter has AllowUnsafeAPIs.
TEST_F(DeviceCreationTest, AdapterMaxImmediateSize) {
    wgpu::Limits requiredLimits{.maxImmediateSize = 1};
    wgpu::DeviceDescriptor deviceDesc;
    deviceDesc.requiredLimits = &requiredLimits;

    {
        wgpu::Adapter wgpuAdapter{adapter.Get()};
        wgpu::Limits limits;
        wgpuAdapter.GetLimits(&limits);
        EXPECT_EQ(limits.maxImmediateSize, 0u);

        wgpuAdapter.RequestDevice(
            &deviceDesc, wgpu::CallbackMode::AllowSpontaneous,
            [](wgpu::RequestDeviceStatus status, wgpu::Device device, wgpu::StringView message) {
                EXPECT_EQ(status, wgpu::RequestDeviceStatus::Error);
                EXPECT_EQ(device.Get(), nullptr);
            });
    }

    // The null backend always supports immediates.
    {
        wgpu::Adapter wgpuAdapter{unsafeAdapter.Get()};
        wgpu::Limits limits;
        wgpuAdapter.GetLimits(&limits);
        EXPECT_GT(limits.maxImmediateSize, 0u);
        wgpuAdapter.RequestDevice(
            &deviceDesc, wgpu::CallbackMode::AllowSpontaneous,
            [](wgpu::RequestDeviceStatus status, wgpu::Device device, wgpu::StringView message) {
                EXPECT_EQ(status, wgpu::RequestDeviceStatus::Success);
                EXPECT_NE(device.Get(), nullptr);
            });
    }
}

// Test failed call to CreateDevice when adapter has been consumed because instance has not the
// MultipleDevicesPerAdapter feature.
TEST_F(DeviceCreationTest, AdapterIsConsumedWithoutMultipleDevicesPerAdapterFeature) {
    auto instance = std::make_unique<Instance>();

    wgpu::RequestAdapterOptions options = {};
    options.backendType = wgpu::BackendType::Null;

    auto adapter = instance->EnumerateAdapters(&options)[0];

    wgpu::Device device1 = adapter.CreateDevice();
    EXPECT_NE(device1, nullptr);

    wgpu::Device device2 = adapter.CreateDevice();
    EXPECT_EQ(device2, nullptr);
}

// Test failed call to CreateDevice when adapter has been explicitly asked to be consumed.
TEST_F(DeviceCreationTest, AdapterIsConsumedWithConsumeAdapterDescriptor) {
    wgpu::DawnConsumeAdapterDescriptor consumeAdapterDesc = {};
    consumeAdapterDesc.consumeAdapter = true;
    wgpu::DeviceDescriptor desc = {};
    desc.nextInChain = &consumeAdapterDesc;
    wgpu::Device device1 = adapter.CreateDevice(&desc);
    EXPECT_NE(device1, nullptr);

    desc.nextInChain = nullptr;
    wgpu::Device device2 = adapter.CreateDevice(&desc);
    EXPECT_EQ(device2, nullptr);
}

class DeviceCreationFutureTest : public DeviceCreationTest,
                                 public ::testing::WithParamInterface<wgpu::CallbackMode> {
  protected:
    void RequestDevice(const wgpu::DeviceDescriptor* descriptor) {
        wgpu::Adapter wgpuAdapter(adapter.Get());
        wgpu::Future future = wgpuAdapter.RequestDevice(descriptor, GetParam(), mMockCb.Callback());
        wgpu::Instance wgpuInstance(instance->Get());
        switch (GetParam()) {
            case wgpu::CallbackMode::WaitAnyOnly: {
                // Callback should complete as soon as poll once.
                EXPECT_EQ(wgpuInstance.WaitAny(future, 0), wgpu::WaitStatus::Success);
                break;
            }
            case wgpu::CallbackMode::AllowSpontaneous:
                // Callback should already be called.
                break;
            case wgpu::CallbackMode::AllowProcessEvents:
                wgpuInstance.ProcessEvents();
                break;
        }
    }

    MockCppCallback<wgpu::RequestDeviceCallback<void>*> mMockCb;
};

INSTANTIATE_TEST_SUITE_P(,
                         DeviceCreationFutureTest,
                         ::testing::ValuesIn(std::initializer_list<wgpu::CallbackMode>{
                             wgpu::CallbackMode::WaitAnyOnly,
                             wgpu::CallbackMode::AllowProcessEvents,
                             wgpu::CallbackMode::AllowSpontaneous}));

// Test successful call to RequestDevice with descriptor
TEST_P(DeviceCreationFutureTest, RequestDeviceSuccess) {
    wgpu::Device device;
    EXPECT_CALL(mMockCb, Call(wgpu::RequestDeviceStatus::Success, _, EmptySizedString()))
        .WillOnce(WithArg<1>([&](wgpu::Device result) { device = std::move(result); }));

    wgpu::DeviceDescriptor desc = {};
    RequestDevice(&desc);
    EXPECT_NE(device, nullptr);
}

// Test successful call to RequestDevice with a null descriptor
TEST_P(DeviceCreationFutureTest, RequestDeviceNullDescriptorSuccess) {
    wgpu::Device device;
    EXPECT_CALL(mMockCb, Call(wgpu::RequestDeviceStatus::Success, _, EmptySizedString()))
        .WillOnce(WithArg<1>([&](wgpu::Device result) { device = std::move(result); }));

    RequestDevice(nullptr);
    EXPECT_NE(device, nullptr);
}

// Test failing call to RequestDevice with invalid feature
TEST_P(DeviceCreationFutureTest, RequestDeviceFailure) {
    wgpu::Device device;
    EXPECT_CALL(mMockCb, Call(wgpu::RequestDeviceStatus::Error, IsNull(), NonEmptySizedString()))
        .WillOnce(WithArg<1>([&](wgpu::Device result) { device = std::move(result); }));

    wgpu::DeviceDescriptor desc = {};
    wgpu::FeatureName invalidFeature = static_cast<wgpu::FeatureName>(WGPUFeatureName_Force32);
    desc.requiredFeatures = &invalidFeature;
    desc.requiredFeatureCount = 1;
    RequestDevice(&desc);
}

}  // anonymous namespace
}  // namespace dawn::native