// 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/RenderPassEncoder.h"

#include <math.h>
#include <cstring>
#include <utility>

#include "dawn/common/Constants.h"
#include "dawn/native/Buffer.h"
#include "dawn/native/CommandEncoder.h"
#include "dawn/native/CommandValidation.h"
#include "dawn/native/Commands.h"
#include "dawn/native/Device.h"
#include "dawn/native/ObjectType_autogen.h"
#include "dawn/native/QuerySet.h"
#include "dawn/native/RenderBundle.h"
#include "dawn/native/RenderPipeline.h"

namespace dawn::native {
    namespace {

        // Check the query at queryIndex is unavailable, otherwise it cannot be written.
        MaybeError ValidateQueryIndexOverwrite(QuerySetBase* querySet,
                                               uint32_t queryIndex,
                                               const QueryAvailabilityMap& queryAvailabilityMap) {
            auto it = queryAvailabilityMap.find(querySet);
            DAWN_INVALID_IF(it != queryAvailabilityMap.end() && it->second[queryIndex],
                            "Query index %u of %s is written to twice in a render pass.",
                            queryIndex, querySet);

            return {};
        }

    }  // namespace

    // The usage tracker is passed in here, because it is prepopulated with usages from the
    // BeginRenderPassCmd. If we had RenderPassEncoder responsible for recording the
    // command, then this wouldn't be necessary.
    RenderPassEncoder::RenderPassEncoder(DeviceBase* device,
                                         const RenderPassDescriptor* descriptor,
                                         CommandEncoder* commandEncoder,
                                         EncodingContext* encodingContext,
                                         RenderPassResourceUsageTracker usageTracker,
                                         Ref<AttachmentState> attachmentState,
                                         std::vector<TimestampWrite> timestampWritesAtEnd,
                                         uint32_t renderTargetWidth,
                                         uint32_t renderTargetHeight,
                                         bool depthReadOnly,
                                         bool stencilReadOnly)
        : RenderEncoderBase(device,
                            descriptor->label,
                            encodingContext,
                            std::move(attachmentState),
                            depthReadOnly,
                            stencilReadOnly),
          mCommandEncoder(commandEncoder),
          mRenderTargetWidth(renderTargetWidth),
          mRenderTargetHeight(renderTargetHeight),
          mOcclusionQuerySet(descriptor->occlusionQuerySet),
          mTimestampWritesAtEnd(std::move(timestampWritesAtEnd)) {
        mUsageTracker = std::move(usageTracker);
        TrackInDevice();
    }

    // static
    Ref<RenderPassEncoder> RenderPassEncoder::Create(
        DeviceBase* device,
        const RenderPassDescriptor* descriptor,
        CommandEncoder* commandEncoder,
        EncodingContext* encodingContext,
        RenderPassResourceUsageTracker usageTracker,
        Ref<AttachmentState> attachmentState,
        std::vector<TimestampWrite> timestampWritesAtEnd,
        uint32_t renderTargetWidth,
        uint32_t renderTargetHeight,
        bool depthReadOnly,
        bool stencilReadOnly) {
        return AcquireRef(new RenderPassEncoder(
            device, descriptor, commandEncoder, encodingContext, std::move(usageTracker),
            std::move(attachmentState), std::move(timestampWritesAtEnd), renderTargetWidth,
            renderTargetHeight, depthReadOnly, stencilReadOnly));
    }

    RenderPassEncoder::RenderPassEncoder(DeviceBase* device,
                                         CommandEncoder* commandEncoder,
                                         EncodingContext* encodingContext,
                                         ErrorTag errorTag)
        : RenderEncoderBase(device, encodingContext, errorTag), mCommandEncoder(commandEncoder) {
    }

    // static
    Ref<RenderPassEncoder> RenderPassEncoder::MakeError(DeviceBase* device,
                                                        CommandEncoder* commandEncoder,
                                                        EncodingContext* encodingContext) {
        return AcquireRef(
            new RenderPassEncoder(device, commandEncoder, encodingContext, ObjectBase::kError));
    }

    void RenderPassEncoder::DestroyImpl() {
        RenderEncoderBase::DestroyImpl();
        // Ensure that the pass has exited. This is done for passes only since validation requires
        // they exit before destruction while bundles do not.
        mEncodingContext->EnsurePassExited(this);
    }

    ObjectType RenderPassEncoder::GetType() const {
        return ObjectType::RenderPassEncoder;
    }

    void RenderPassEncoder::TrackQueryAvailability(QuerySetBase* querySet, uint32_t queryIndex) {
        DAWN_ASSERT(querySet != nullptr);

        // Track the query availability with true on render pass for rewrite validation and query
        // reset on render pass on Vulkan
        mUsageTracker.TrackQueryAvailability(querySet, queryIndex);

        // Track it again on command encoder for zero-initializing when resolving unused queries.
        mCommandEncoder->TrackQueryAvailability(querySet, queryIndex);
    }

    void RenderPassEncoder::APIEnd() {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_TRY(ValidateProgrammableEncoderEnd());

                    DAWN_INVALID_IF(
                        mOcclusionQueryActive,
                        "Render pass %s ended with incomplete occlusion query index %u of %s.",
                        this, mCurrentOcclusionQueryIndex, mOcclusionQuerySet.Get());
                }

                EndRenderPassCmd* cmd =
                    allocator->Allocate<EndRenderPassCmd>(Command::EndRenderPass);
                // The query availability has already been updated at the beginning of render
                // pass, and no need to do update here.
                cmd->timestampWrites = std::move(mTimestampWritesAtEnd);

                DAWN_TRY(mEncodingContext->ExitRenderPass(this, std::move(mUsageTracker),
                                                          mCommandEncoder.Get(),
                                                          std::move(mIndirectDrawMetadata)));
                return {};
            },
            "encoding %s.End().", this);
    }

    void RenderPassEncoder::APIEndPass() {
        GetDevice()->EmitDeprecationWarning("endPass() has been deprecated. Use end() instead.");
        APIEnd();
    }

    void RenderPassEncoder::APISetStencilReference(uint32_t reference) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                SetStencilReferenceCmd* cmd =
                    allocator->Allocate<SetStencilReferenceCmd>(Command::SetStencilReference);
                cmd->reference = reference;

                return {};
            },
            "encoding %s.SetStencilReference(%u).", this, reference);
    }

    void RenderPassEncoder::APISetBlendConstant(const Color* color) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                SetBlendConstantCmd* cmd =
                    allocator->Allocate<SetBlendConstantCmd>(Command::SetBlendConstant);
                cmd->color = *color;

                return {};
            },
            "encoding %s.SetBlendConstant(%s).", this, color);
    }

    void RenderPassEncoder::APISetViewport(float x,
                                           float y,
                                           float width,
                                           float height,
                                           float minDepth,
                                           float maxDepth) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_INVALID_IF(
                        (isnan(x) || isnan(y) || isnan(width) || isnan(height) || isnan(minDepth) ||
                         isnan(maxDepth)),
                        "A parameter of the viewport (x: %f, y: %f, width: %f, height: %f, "
                        "minDepth: %f, maxDepth: %f) is NaN.",
                        x, y, width, height, minDepth, maxDepth);

                    DAWN_INVALID_IF(
                        x < 0 || y < 0 || width < 0 || height < 0,
                        "Viewport bounds (x: %f, y: %f, width: %f, height: %f) contains a negative "
                        "value.",
                        x, y, width, height);

                    DAWN_INVALID_IF(
                        x + width > mRenderTargetWidth || y + height > mRenderTargetHeight,
                        "Viewport bounds (x: %f, y: %f, width: %f, height: %f) are not contained "
                        "in "
                        "the render target dimensions (%u x %u).",
                        x, y, width, height, mRenderTargetWidth, mRenderTargetHeight);

                    // Check for depths being in [0, 1] and min <= max in 3 checks instead of 5.
                    DAWN_INVALID_IF(minDepth < 0 || minDepth > maxDepth || maxDepth > 1,
                                    "Viewport minDepth (%f) and maxDepth (%f) are not in [0, 1] or "
                                    "minDepth was "
                                    "greater than maxDepth.",
                                    minDepth, maxDepth);
                }

                SetViewportCmd* cmd = allocator->Allocate<SetViewportCmd>(Command::SetViewport);
                cmd->x = x;
                cmd->y = y;
                cmd->width = width;
                cmd->height = height;
                cmd->minDepth = minDepth;
                cmd->maxDepth = maxDepth;

                return {};
            },
            "encoding %s.SetViewport(%f, %f, %f, %f, %f, %f).", this, x, y, width, height, minDepth,
            maxDepth);
    }

    void RenderPassEncoder::APISetScissorRect(uint32_t x,
                                              uint32_t y,
                                              uint32_t width,
                                              uint32_t height) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_INVALID_IF(
                        width > mRenderTargetWidth || height > mRenderTargetHeight ||
                            x > mRenderTargetWidth - width || y > mRenderTargetHeight - height,
                        "Scissor rect (x: %u, y: %u, width: %u, height: %u) is not contained in "
                        "the render target dimensions (%u x %u).",
                        x, y, width, height, mRenderTargetWidth, mRenderTargetHeight);
                }

                SetScissorRectCmd* cmd =
                    allocator->Allocate<SetScissorRectCmd>(Command::SetScissorRect);
                cmd->x = x;
                cmd->y = y;
                cmd->width = width;
                cmd->height = height;

                return {};
            },
            "encoding %s.SetScissorRect(%u, %u, %u, %u).", this, x, y, width, height);
    }

    void RenderPassEncoder::APIExecuteBundles(uint32_t count,
                                              RenderBundleBase* const* renderBundles) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    const AttachmentState* attachmentState = GetAttachmentState();
                    bool depthReadOnlyInPass = IsDepthReadOnly();
                    bool stencilReadOnlyInPass = IsStencilReadOnly();
                    for (uint32_t i = 0; i < count; ++i) {
                        DAWN_TRY(GetDevice()->ValidateObject(renderBundles[i]));

                        DAWN_INVALID_IF(attachmentState != renderBundles[i]->GetAttachmentState(),
                                        "Attachment state of renderBundles[%i] (%s) is not "
                                        "compatible with %s.\n"
                                        "%s expects an attachment state of %s.\n"
                                        "renderBundles[%i] (%s) has an attachment state of %s.",
                                        i, renderBundles[i], this, this, attachmentState, i,
                                        renderBundles[i], renderBundles[i]->GetAttachmentState());

                        bool depthReadOnlyInBundle = renderBundles[i]->IsDepthReadOnly();
                        DAWN_INVALID_IF(
                            depthReadOnlyInPass && !depthReadOnlyInBundle,
                            "DepthReadOnly (%u) of renderBundle[%i] (%s) is not compatible "
                            "with DepthReadOnly (%u) of %s.",
                            depthReadOnlyInBundle, i, renderBundles[i], depthReadOnlyInPass, this);

                        bool stencilReadOnlyInBundle = renderBundles[i]->IsStencilReadOnly();
                        DAWN_INVALID_IF(stencilReadOnlyInPass && !stencilReadOnlyInBundle,
                                        "StencilReadOnly (%u) of renderBundle[%i] (%s) is not "
                                        "compatible with StencilReadOnly (%u) of %s.",
                                        stencilReadOnlyInBundle, i, renderBundles[i],
                                        stencilReadOnlyInPass, this);
                    }
                }

                mCommandBufferState = CommandBufferStateTracker{};

                ExecuteBundlesCmd* cmd =
                    allocator->Allocate<ExecuteBundlesCmd>(Command::ExecuteBundles);
                cmd->count = count;

                Ref<RenderBundleBase>* bundles =
                    allocator->AllocateData<Ref<RenderBundleBase>>(count);
                for (uint32_t i = 0; i < count; ++i) {
                    bundles[i] = renderBundles[i];

                    const RenderPassResourceUsage& usages = bundles[i]->GetResourceUsage();
                    for (uint32_t i = 0; i < usages.buffers.size(); ++i) {
                        mUsageTracker.BufferUsedAs(usages.buffers[i], usages.bufferUsages[i]);
                    }

                    for (uint32_t i = 0; i < usages.textures.size(); ++i) {
                        mUsageTracker.AddRenderBundleTextureUsage(usages.textures[i],
                                                                  usages.textureUsages[i]);
                    }

                    if (IsValidationEnabled()) {
                        mIndirectDrawMetadata.AddBundle(renderBundles[i]);
                    }
                }

                return {};
            },
            "encoding %s.ExecuteBundles(%u, ...).", this, count);
    }

    void RenderPassEncoder::APIBeginOcclusionQuery(uint32_t queryIndex) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_INVALID_IF(mOcclusionQuerySet.Get() == nullptr,
                                    "The occlusionQuerySet in RenderPassDescriptor is not set.");

                    // The type of querySet has been validated by ValidateRenderPassDescriptor

                    DAWN_INVALID_IF(queryIndex >= mOcclusionQuerySet->GetQueryCount(),
                                    "Query index (%u) exceeds the number of queries (%u) in %s.",
                                    queryIndex, mOcclusionQuerySet->GetQueryCount(),
                                    mOcclusionQuerySet.Get());

                    DAWN_INVALID_IF(mOcclusionQueryActive,
                                    "An occlusion query (%u) in %s is already active.",
                                    mCurrentOcclusionQueryIndex, mOcclusionQuerySet.Get());

                    DAWN_TRY_CONTEXT(
                        ValidateQueryIndexOverwrite(mOcclusionQuerySet.Get(), queryIndex,
                                                    mUsageTracker.GetQueryAvailabilityMap()),
                        "validating the occlusion query index (%u) in %s", queryIndex,
                        mOcclusionQuerySet.Get());
                }

                // Record the current query index for endOcclusionQuery.
                mCurrentOcclusionQueryIndex = queryIndex;
                mOcclusionQueryActive = true;

                BeginOcclusionQueryCmd* cmd =
                    allocator->Allocate<BeginOcclusionQueryCmd>(Command::BeginOcclusionQuery);
                cmd->querySet = mOcclusionQuerySet.Get();
                cmd->queryIndex = queryIndex;

                return {};
            },
            "encoding %s.BeginOcclusionQuery(%u).", this, queryIndex);
    }

    void RenderPassEncoder::APIEndOcclusionQuery() {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_INVALID_IF(!mOcclusionQueryActive, "No occlusion queries are active.");
                }

                TrackQueryAvailability(mOcclusionQuerySet.Get(), mCurrentOcclusionQueryIndex);

                mOcclusionQueryActive = false;

                EndOcclusionQueryCmd* cmd =
                    allocator->Allocate<EndOcclusionQueryCmd>(Command::EndOcclusionQuery);
                cmd->querySet = mOcclusionQuerySet.Get();
                cmd->queryIndex = mCurrentOcclusionQueryIndex;

                return {};
            },
            "encoding %s.EndOcclusionQuery().", this);
    }

    void RenderPassEncoder::APIWriteTimestamp(QuerySetBase* querySet, uint32_t queryIndex) {
        mEncodingContext->TryEncode(
            this,
            [&](CommandAllocator* allocator) -> MaybeError {
                if (IsValidationEnabled()) {
                    DAWN_TRY(ValidateTimestampQuery(GetDevice(), querySet, queryIndex));
                    DAWN_TRY_CONTEXT(
                        ValidateQueryIndexOverwrite(querySet, queryIndex,
                                                    mUsageTracker.GetQueryAvailabilityMap()),
                        "validating the timestamp query index (%u) of %s", queryIndex, querySet);
                }

                TrackQueryAvailability(querySet, queryIndex);

                WriteTimestampCmd* cmd =
                    allocator->Allocate<WriteTimestampCmd>(Command::WriteTimestamp);
                cmd->querySet = querySet;
                cmd->queryIndex = queryIndex;

                return {};
            },
            "encoding %s.WriteTimestamp(%s, %u).", this, querySet, queryIndex);
    }

}  // namespace dawn::native