// Copyright 2019 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 <array>
#include <string>

#include "dawn/common/Constants.h"
#include "dawn/tests/unittests/wire/WireTest.h"

namespace dawn::wire {
namespace {

using testing::_;
using testing::AllOf;
using testing::Eq;
using testing::Field;
using testing::Return;
using testing::Sequence;

MATCHER_P2(EqBytes, bytes, size, "") {
    const char* dataToCheck = arg;
    bool isMatch = (memcmp(dataToCheck, bytes, size) == 0);
    return isMatch;
}

class WireArgumentTests : public WireTest {
  public:
    WireArgumentTests() {}
    ~WireArgumentTests() override = default;
};

// Test that the wire is able to send numerical values
TEST_F(WireArgumentTests, ValueArgument) {
    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
    wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
    pass.DispatchWorkgroups(1, 2, 3);

    WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
    EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

    WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
    EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));

    EXPECT_CALL(api, ComputePassEncoderDispatchWorkgroups(apiPass, 1, 2, 3)).Times(1);

    FlushClient();
}

// Test that the wire is able to send arrays of numerical values
TEST_F(WireArgumentTests, ValueArrayArgument) {
    // Create a bindgroup.
    wgpu::BindGroupLayoutDescriptor bglDescriptor = {};

    wgpu::BindGroupLayout bgl = device.CreateBindGroupLayout(&bglDescriptor);
    WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
    EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));

    wgpu::BindGroupDescriptor bindGroupDescriptor = {};
    bindGroupDescriptor.layout = bgl;

    wgpu::BindGroup bindGroup = device.CreateBindGroup(&bindGroupDescriptor);
    WGPUBindGroup apiBindGroup = api.GetNewBindGroup();
    EXPECT_CALL(api, DeviceCreateBindGroup(apiDevice, _)).WillOnce(Return(apiBindGroup));

    // Use the bindgroup in SetBindGroup that takes an array of value offsets.
    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
    wgpu::ComputePassEncoder pass = encoder.BeginComputePass();

    std::array<uint32_t, 4> testOffsets = {0, 42, 0xDEAD'BEEFu, 0xFFFF'FFFFu};
    pass.SetBindGroup(0, bindGroup, testOffsets.size(), testOffsets.data());

    WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
    EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

    WGPUComputePassEncoder apiPass = api.GetNewComputePassEncoder();
    EXPECT_CALL(api, CommandEncoderBeginComputePass(apiEncoder, nullptr)).WillOnce(Return(apiPass));

    EXPECT_CALL(api, ComputePassEncoderSetBindGroup(
                         apiPass, 0, apiBindGroup, testOffsets.size(),
                         MatchesLambda([testOffsets](const uint32_t* offsets) -> bool {
                             for (size_t i = 0; i < testOffsets.size(); i++) {
                                 if (offsets[i] != testOffsets[i]) {
                                     return false;
                                 }
                             }
                             return true;
                         })));

    FlushClient();
}

// Test that the wire is able to send C strings
TEST_F(WireArgumentTests, CStringArgument) {
    // Create shader module
    wgpu::ShaderModuleDescriptor vertexDescriptor = {};
    wgpu::ShaderModule vsModule = device.CreateShaderModule(&vertexDescriptor);
    WGPUShaderModule apiVsModule = api.GetNewShaderModule();
    EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));

    // Create the color state descriptor
    wgpu::BlendComponent blendComponent = {};
    wgpu::BlendState blendState = {};
    blendState.alpha = blendComponent;
    blendState.color = blendComponent;
    wgpu::ColorTargetState colorTargetState = {};
    colorTargetState.format = wgpu::TextureFormat::RGBA8Unorm;
    colorTargetState.blend = &blendState;

    // Create the depth-stencil state
    wgpu::StencilFaceState stencilFace = {};

    wgpu::DepthStencilState depthStencilState = {};
    depthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
    depthStencilState.depthCompare = wgpu::CompareFunction::Always;
    depthStencilState.stencilBack = stencilFace;
    depthStencilState.stencilFront = stencilFace;

    // Create the pipeline layout
    wgpu::PipelineLayoutDescriptor layoutDescriptor = {};
    wgpu::PipelineLayout layout = device.CreatePipelineLayout(&layoutDescriptor);
    WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();
    EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));

    // Create pipeline
    wgpu::RenderPipelineDescriptor pipelineDescriptor = {};
    pipelineDescriptor.vertex.module = vsModule;
    pipelineDescriptor.vertex.entryPoint = "main";

    wgpu::FragmentState fragment = {};
    fragment.module = vsModule;
    fragment.entryPoint = "main";
    fragment.targetCount = 1;
    fragment.targets = &colorTargetState;
    pipelineDescriptor.fragment = &fragment;

    pipelineDescriptor.layout = layout;
    pipelineDescriptor.depthStencil = &depthStencilState;

    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor);

    WGPURenderPipeline apiPlaceholderPipeline = api.GetNewRenderPipeline();
    EXPECT_CALL(api,
                DeviceCreateRenderPipeline(
                    apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {
                        return std::string_view(desc->vertex.entryPoint.data,
                                                desc->vertex.entryPoint.length) == "main";
                    })))
        .WillOnce(Return(apiPlaceholderPipeline));

    FlushClient();
}

// Test that the wire is able to send WGPUStringViews
TEST_F(WireArgumentTests, WGPUStringView) {
    // Create shader module
    wgpu::ShaderModuleDescriptor vertexDescriptor = {};
    wgpu::ShaderModule vsModule = device.CreateShaderModule(&vertexDescriptor);
    WGPUShaderModule apiVsModule = api.GetNewShaderModule();
    EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));

    const char* label = "null-terminated label\0more string";
    vsModule.SetLabel(std::string_view(label));
    EXPECT_CALL(api, ShaderModuleSetLabel(apiVsModule,
                                          AllOf(Field(&WGPUStringView::data, EqBytes(label, 21u)),
                                                Field(&WGPUStringView::length, Eq(21u)))));
    FlushClient();

    // Give it a longer, explicit length that contains the null-terminator.
    vsModule.SetLabel(std::string_view(label, 34));
    EXPECT_CALL(api, ShaderModuleSetLabel(apiVsModule,
                                          AllOf(Field(&WGPUStringView::data, EqBytes(label, 34u)),
                                                Field(&WGPUStringView::length, Eq(34u)))));
    FlushClient();

    // Give it a shorder, explicit length.
    vsModule.SetLabel(std::string_view(label, 2));
    EXPECT_CALL(api, ShaderModuleSetLabel(apiVsModule,
                                          AllOf(Field(&WGPUStringView::data, EqBytes(label, 2u)),
                                                Field(&WGPUStringView::length, Eq(2u)))));
    FlushClient();

    // Give it a zero length.
    vsModule.SetLabel(std::string_view(label, 0));
    EXPECT_CALL(
        api, ShaderModuleSetLabel(apiVsModule, AllOf(Field(&WGPUStringView::data, EqBytes("", 1u)),
                                                     Field(&WGPUStringView::length, Eq(0u)))));
    FlushClient();

    // Give it zero length and data.
    vsModule.SetLabel(std::string_view(nullptr, 0));
    EXPECT_CALL(api,
                ShaderModuleSetLabel(apiVsModule, AllOf(Field(&WGPUStringView::data, nullptr),
                                                        Field(&WGPUStringView::length, Eq(0u)))));
    FlushClient();

    // Give it the nil string with nullopt.
    vsModule.SetLabel(std::nullopt);
    EXPECT_CALL(api, ShaderModuleSetLabel(apiVsModule,
                                          AllOf(Field(&WGPUStringView::data, nullptr),
                                                Field(&WGPUStringView::length, Eq(WGPU_STRLEN)))));
    FlushClient();
}

// Test that the wire is able to send objects as value arguments
TEST_F(WireArgumentTests, ObjectAsValueArgument) {
    wgpu::CommandEncoder cmdBufEncoder = device.CreateCommandEncoder();
    WGPUCommandEncoder apiEncoder = api.GetNewCommandEncoder();
    EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr)).WillOnce(Return(apiEncoder));

    wgpu::BufferDescriptor descriptor = {};
    descriptor.size = 8;
    descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;

    wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
    WGPUBuffer apiBuffer = api.GetNewBuffer();
    EXPECT_CALL(api, DeviceCreateBuffer(apiDevice, _))
        .WillOnce(Return(apiBuffer))
        .RetiresOnSaturation();

    cmdBufEncoder.CopyBufferToBuffer(buffer, 0, buffer, 4, 4);
    EXPECT_CALL(api, CommandEncoderCopyBufferToBuffer(apiEncoder, apiBuffer, 0, apiBuffer, 4, 4));

    FlushClient();
}

// Test that the wire is able to send array of objects
TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
    wgpu::CommandBuffer cmdBufs[2];
    WGPUCommandBuffer apiCmdBufs[2];

    // Create two command buffers we need to use a GMock sequence otherwise the order of the
    // CreateCommandEncoder might be swapped since they are equivalent in term of matchers
    Sequence s;
    for (int i = 0; i < 2; ++i) {
        wgpu::CommandEncoder cmdBufEncoder = device.CreateCommandEncoder();
        cmdBufs[i] = cmdBufEncoder.Finish();

        WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
        EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
            .InSequence(s)
            .WillOnce(Return(apiCmdBufEncoder));

        apiCmdBufs[i] = api.GetNewCommandBuffer();
        EXPECT_CALL(api, CommandEncoderFinish(apiCmdBufEncoder, nullptr))
            .WillOnce(Return(apiCmdBufs[i]));

        EXPECT_CALL(api, CommandEncoderRelease(apiCmdBufEncoder));
    }

    // Submit command buffer and check we got a call with both API-side command buffers
    queue.Submit(2, cmdBufs);

    EXPECT_CALL(
        api, QueueSubmit(apiQueue, 2, MatchesLambda([=](const WGPUCommandBuffer* cmdBufs) -> bool {
                             return cmdBufs[0] == apiCmdBufs[0] && cmdBufs[1] == apiCmdBufs[1];
                         })));
    EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _));

    FlushClient();
}

// Test that the wire is able to send structures that contain pure values (non-objects)
TEST_F(WireArgumentTests, StructureOfValuesArgument) {
    wgpu::SamplerDescriptor descriptor = {};
    descriptor.magFilter = wgpu::FilterMode::Linear;
    descriptor.mipmapFilter = wgpu::MipmapFilterMode::Linear;
    descriptor.addressModeV = wgpu::AddressMode::Repeat;
    descriptor.addressModeW = wgpu::AddressMode::MirrorRepeat;
    descriptor.lodMaxClamp = kLodMax;
    descriptor.compare = wgpu::CompareFunction::Never;

    wgpu::Sampler sampler = device.CreateSampler(&descriptor);

    WGPUSampler apiPlaceholderSampler = api.GetNewSampler();
    EXPECT_CALL(api, DeviceCreateSampler(
                         apiDevice, MatchesLambda([](const WGPUSamplerDescriptor* desc) -> bool {
                             return desc->nextInChain == nullptr &&
                                    desc->magFilter == WGPUFilterMode_Linear &&
                                    desc->minFilter == WGPUFilterMode_Undefined &&
                                    desc->mipmapFilter == WGPUMipmapFilterMode_Linear &&
                                    desc->addressModeU == WGPUAddressMode_Undefined &&
                                    desc->addressModeV == WGPUAddressMode_Repeat &&
                                    desc->addressModeW == WGPUAddressMode_MirrorRepeat &&
                                    desc->compare == WGPUCompareFunction_Never &&
                                    desc->lodMinClamp == kLodMin && desc->lodMaxClamp == kLodMax;
                         })))
        .WillOnce(Return(apiPlaceholderSampler));

    FlushClient();
}

// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
    wgpu::BindGroupLayoutDescriptor bglDescriptor = {};

    wgpu::BindGroupLayout bgl = device.CreateBindGroupLayout(&bglDescriptor);
    WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
    EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _)).WillOnce(Return(apiBgl));

    wgpu::PipelineLayoutDescriptor descriptor = {};
    descriptor.bindGroupLayoutCount = 1;
    descriptor.bindGroupLayouts = &bgl;

    wgpu::PipelineLayout layout = device.CreatePipelineLayout(&descriptor);

    WGPUPipelineLayout apiPlaceholderLayout = api.GetNewPipelineLayout();
    EXPECT_CALL(api, DeviceCreatePipelineLayout(
                         apiDevice,
                         MatchesLambda([apiBgl](const WGPUPipelineLayoutDescriptor* desc) -> bool {
                             return desc->nextInChain == nullptr &&
                                    desc->bindGroupLayoutCount == 1 &&
                                    desc->bindGroupLayouts[0] == apiBgl;
                         })))
        .WillOnce(Return(apiPlaceholderLayout));

    FlushClient();
}

// Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
    static constexpr int NUM_BINDINGS = 3;
    wgpu::BindGroupLayoutEntry entries[NUM_BINDINGS]{
        {
            .binding = 0,
            .visibility = wgpu::ShaderStage::Vertex,
            .sampler = {nullptr, wgpu::SamplerBindingType::Filtering},
        },
        {
            .binding = 1,
            .visibility = wgpu::ShaderStage::Vertex,
            .texture = {nullptr, wgpu::TextureSampleType::Float, wgpu::TextureViewDimension::e2D,
                        false},
        },
        {
            .binding = 2,
            .visibility = wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Fragment,
            .buffer = {nullptr, wgpu::BufferBindingType::Uniform, false, 0},
        },
    };
    wgpu::BindGroupLayoutDescriptor bglDescriptor = {};
    bglDescriptor.entryCount = NUM_BINDINGS;
    bglDescriptor.entries = entries;

    wgpu::BindGroupLayout bgl = device.CreateBindGroupLayout(&bglDescriptor);
    WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
    EXPECT_CALL(
        api,
        DeviceCreateBindGroupLayout(
            apiDevice, MatchesLambda([entries](const WGPUBindGroupLayoutDescriptor* desc) -> bool {
                for (int i = 0; i < NUM_BINDINGS; ++i) {
                    const auto& a = desc->entries[i];
                    const auto& b = entries[i];
                    if (a.binding != b.binding ||
                        a.visibility != static_cast<WGPUShaderStage>(b.visibility) ||
                        a.buffer.type != static_cast<WGPUBufferBindingType>(b.buffer.type) ||
                        a.sampler.type != static_cast<WGPUSamplerBindingType>(b.sampler.type) ||
                        a.texture.sampleType !=
                            static_cast<WGPUTextureSampleType>(b.texture.sampleType)) {
                        return false;
                    }
                }
                return desc->nextInChain == nullptr && desc->entryCount == 3;
            })))
        .WillOnce(Return(apiBgl));

    FlushClient();
}

// Test passing nullptr instead of objects - array of objects version
TEST_F(WireArgumentTests, DISABLED_NullptrInArray) {
    wgpu::BindGroupLayout nullBGL = nullptr;

    wgpu::PipelineLayoutDescriptor descriptor = {};
    descriptor.bindGroupLayoutCount = 1;
    descriptor.bindGroupLayouts = &nullBGL;

    wgpu::PipelineLayout pl = device.CreatePipelineLayout(&descriptor);
    EXPECT_CALL(api,
                DeviceCreatePipelineLayout(
                    apiDevice, MatchesLambda([](const WGPUPipelineLayoutDescriptor* desc) -> bool {
                        return desc->nextInChain == nullptr && desc->bindGroupLayoutCount == 1 &&
                               desc->bindGroupLayouts[0] == nullptr;
                    })))
        .WillOnce(Return(nullptr));

    FlushClient();
}

}  // anonymous namespace
}  // namespace dawn::wire