// Copyright 2018 The Dawn Authors
//
// 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 "dawn_native/ProgrammablePassEncoder.h"

#include "common/BitSetIterator.h"
#include "common/ityp_array.h"
#include "dawn_native/BindGroup.h"
#include "dawn_native/Buffer.h"
#include "dawn_native/CommandBuffer.h"
#include "dawn_native/Commands.h"
#include "dawn_native/Device.h"
#include "dawn_native/ObjectType_autogen.h"
#include "dawn_native/ValidationUtils_autogen.h"

#include <cstring>

namespace dawn_native {

    ProgrammablePassEncoder::ProgrammablePassEncoder(DeviceBase* device,
                                                     EncodingContext* encodingContext)
        : ApiObjectBase(device, kLabelNotImplemented),
          mEncodingContext(encodingContext),
          mValidationEnabled(device->IsValidationEnabled()) {
    }

    ProgrammablePassEncoder::ProgrammablePassEncoder(DeviceBase* device,
                                                     EncodingContext* encodingContext,
                                                     ErrorTag errorTag)
        : ApiObjectBase(device, errorTag),
          mEncodingContext(encodingContext),
          mValidationEnabled(device->IsValidationEnabled()) {
    }

    bool ProgrammablePassEncoder::IsValidationEnabled() const {
        return mValidationEnabled;
    }

    MaybeError ProgrammablePassEncoder::ValidateProgrammableEncoderEnd() const {
        if (mDebugGroupStackSize != 0) {
            return DAWN_VALIDATION_ERROR("Each Push must be balanced by a corresponding Pop.");
        }
        return {};
    }

    void ProgrammablePassEncoder::APIInsertDebugMarker(const char* groupLabel) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                InsertDebugMarkerCmd* cmd =
                    allocator->Allocate<InsertDebugMarkerCmd>(Command::InsertDebugMarker);
                cmd->length = strlen(groupLabel);

                char* label = allocator->AllocateData<char>(cmd->length + 1);
                memcpy(label, groupLabel, cmd->length + 1);

                return {};
            },
            "encoding InsertDebugMarker(\"%s\")", groupLabel);
    }

    void ProgrammablePassEncoder::APIPopDebugGroup() {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    if (mDebugGroupStackSize == 0) {
                        return DAWN_VALIDATION_ERROR(
                            "Pop must be balanced by a corresponding Push.");
                    }
                }
                allocator->Allocate<PopDebugGroupCmd>(Command::PopDebugGroup);
                mDebugGroupStackSize--;
                mEncodingContext->PopDebugGroupLabel();

                return {};
            },
            "encoding PopDebugGroup()");
    }

    void ProgrammablePassEncoder::APIPushDebugGroup(const char* groupLabel) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                PushDebugGroupCmd* cmd =
                    allocator->Allocate<PushDebugGroupCmd>(Command::PushDebugGroup);
                cmd->length = strlen(groupLabel);

                char* label = allocator->AllocateData<char>(cmd->length + 1);
                memcpy(label, groupLabel, cmd->length + 1);

                mDebugGroupStackSize++;
                mEncodingContext->PushDebugGroupLabel(groupLabel);

                return {};
            },
            "encoding PushDebugGroup(\"%s\")", groupLabel);
    }

    MaybeError ProgrammablePassEncoder::ValidateSetBindGroup(
        BindGroupIndex index,
        BindGroupBase* group,
        uint32_t dynamicOffsetCountIn,
        const uint32_t* dynamicOffsetsIn) const {
        DAWN_TRY(GetDevice()->ValidateObject(group));

        if (index >= kMaxBindGroupsTyped) {
            return DAWN_VALIDATION_ERROR("Setting bind group over the max");
        }

        ityp::span<BindingIndex, const uint32_t> dynamicOffsets(dynamicOffsetsIn,
                                                                BindingIndex(dynamicOffsetCountIn));

        // Dynamic offsets count must match the number required by the layout perfectly.
        const BindGroupLayoutBase* layout = group->GetLayout();
        if (layout->GetDynamicBufferCount() != dynamicOffsets.size()) {
            return DAWN_VALIDATION_ERROR("dynamicOffset count mismatch");
        }

        for (BindingIndex i{0}; i < dynamicOffsets.size(); ++i) {
            const BindingInfo& bindingInfo = layout->GetBindingInfo(i);

            // BGL creation sorts bindings such that the dynamic buffer bindings are first.
            // ASSERT that this true.
            ASSERT(bindingInfo.bindingType == BindingInfoType::Buffer);
            ASSERT(bindingInfo.buffer.hasDynamicOffset);

            uint64_t requiredAlignment;
            switch (bindingInfo.buffer.type) {
                case wgpu::BufferBindingType::Uniform:
                    requiredAlignment = GetDevice()->GetLimits().v1.minUniformBufferOffsetAlignment;
                    break;
                case wgpu::BufferBindingType::Storage:
                case wgpu::BufferBindingType::ReadOnlyStorage:
                case kInternalStorageBufferBinding:
                    requiredAlignment = GetDevice()->GetLimits().v1.minStorageBufferOffsetAlignment;
                    break;
                case wgpu::BufferBindingType::Undefined:
                    UNREACHABLE();
            }

            if (!IsAligned(dynamicOffsets[i], requiredAlignment)) {
                return DAWN_VALIDATION_ERROR("Dynamic Buffer Offset need to be aligned");
            }

            BufferBinding bufferBinding = group->GetBindingAsBufferBinding(i);

            // During BindGroup creation, validation ensures binding offset + binding size
            // <= buffer size.
            ASSERT(bufferBinding.buffer->GetSize() >= bufferBinding.size);
            ASSERT(bufferBinding.buffer->GetSize() - bufferBinding.size >= bufferBinding.offset);

            if ((dynamicOffsets[i] >
                 bufferBinding.buffer->GetSize() - bufferBinding.offset - bufferBinding.size)) {
                if ((bufferBinding.buffer->GetSize() - bufferBinding.offset) ==
                    bufferBinding.size) {
                    return DAWN_VALIDATION_ERROR(
                        "Dynamic offset out of bounds. The binding goes to the end of the "
                        "buffer even with a dynamic offset of 0. Did you forget to specify "
                        "the binding's size?");
                } else {
                    return DAWN_VALIDATION_ERROR("Dynamic offset out of bounds");
                }
            }
        }

        return {};
    }

    void ProgrammablePassEncoder::RecordSetBindGroup(CommandAllocator* allocator,
                                                     BindGroupIndex index,
                                                     BindGroupBase* group,
                                                     uint32_t dynamicOffsetCount,
                                                     const uint32_t* dynamicOffsets) const {
        SetBindGroupCmd* cmd = allocator->Allocate<SetBindGroupCmd>(Command::SetBindGroup);
        cmd->index = index;
        cmd->group = group;
        cmd->dynamicOffsetCount = dynamicOffsetCount;
        if (dynamicOffsetCount > 0) {
            uint32_t* offsets = allocator->AllocateData<uint32_t>(cmd->dynamicOffsetCount);
            memcpy(offsets, dynamicOffsets, dynamicOffsetCount * sizeof(uint32_t));
        }
    }

}  // namespace dawn_native