/*
 * Copyright 2020 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/gpu/d3d/GrD3DTextureRenderTarget.h"

#include "src/gpu/GrTexturePriv.h"
#include "src/gpu/d3d/GrD3DGpu.h"

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(GrD3DGpu* gpu,
                                                   SkBudgeted budgeted,
                                                   SkISize dimensions,
                                                   int sampleCnt,
                                                   const GrD3DTextureResourceInfo& info,
                                                   sk_sp<GrD3DResourceState> state,
                                                   const GrD3DTextureResourceInfo& msaaInfo,
                                                   sk_sp<GrD3DResourceState> msaaState,
                                                   GrMipMapsStatus mipMapsStatus)
        : GrSurface(gpu, dimensions, info.fProtected)
        , GrD3DTextureResource(info, state, GrBackendObjectOwnership::kOwned)
        , GrD3DTexture(gpu, dimensions, info, state, mipMapsStatus,
                       GrBackendObjectOwnership::kOwned)
        , GrD3DRenderTarget(gpu, dimensions, sampleCnt, info, state, msaaInfo,
                           std::move(msaaState), GrBackendObjectOwnership::kOwned) {
    SkASSERT(info.fProtected == msaaInfo.fProtected);
    this->registerWithCache(budgeted);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(GrD3DGpu* gpu,
                                                   SkBudgeted budgeted,
                                                   SkISize dimensions,
                                                   const GrD3DTextureResourceInfo& info,
                                                   sk_sp<GrD3DResourceState> state,
                                                   GrMipMapsStatus mipMapsStatus)
        : GrSurface(gpu, dimensions, info.fProtected)
        , GrD3DTextureResource(info, state, GrBackendObjectOwnership::kOwned)
        , GrD3DTexture(gpu, dimensions, info, state, mipMapsStatus,
                      GrBackendObjectOwnership::kOwned)
        , GrD3DRenderTarget(gpu, dimensions, info, state, GrBackendObjectOwnership::kOwned) {
    this->registerWithCache(budgeted);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(GrD3DGpu* gpu,
                                                   SkISize dimensions,
                                                   int sampleCnt,
                                                   const GrD3DTextureResourceInfo& info,
                                                   sk_sp<GrD3DResourceState> state,
                                                   const GrD3DTextureResourceInfo& msaaInfo,
                                                   sk_sp<GrD3DResourceState> msaaState,
                                                   GrMipMapsStatus mipMapsStatus,
                                                   GrBackendObjectOwnership ownership,
                                                   GrWrapCacheable cacheable)
        : GrSurface(gpu, dimensions, info.fProtected)
        , GrD3DTextureResource(info, state, ownership)
        , GrD3DTexture(gpu, dimensions, info, state, mipMapsStatus, ownership)
        , GrD3DRenderTarget(gpu, dimensions, sampleCnt, info, state, msaaInfo,
                            std::move(msaaState), ownership) {
    SkASSERT(info.fProtected == msaaInfo.fProtected);
    this->registerWithCacheWrapped(cacheable);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(GrD3DGpu* gpu,
                                                   SkISize dimensions,
                                                   const GrD3DTextureResourceInfo& info,
                                                   sk_sp<GrD3DResourceState> state,
                                                   GrMipMapsStatus mipMapsStatus,
                                                   GrBackendObjectOwnership ownership,
                                                   GrWrapCacheable cacheable)
        : GrSurface(gpu, dimensions, info.fProtected)
        , GrD3DTextureResource(info, state, ownership)
        , GrD3DTexture(gpu, dimensions, info, state, mipMapsStatus, ownership)
        , GrD3DRenderTarget(gpu, dimensions, info, state, ownership) {
    this->registerWithCacheWrapped(cacheable);
}

static std::pair<GrD3DTextureResourceInfo, sk_sp<GrD3DResourceState>> create_msaa_resource(
        GrD3DGpu* gpu, SkISize dimensions, int sampleCnt, const GrD3DTextureResourceInfo& info) {
    GrD3DTextureResourceInfo msInfo;
    sk_sp<GrD3DResourceState> msState;

    // create msaa surface
    D3D12_RESOURCE_DESC msTextureDesc;
    msTextureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    msTextureDesc.Alignment = 0;  // Default alignment (64KB)
    msTextureDesc.Width = dimensions.fWidth;
    msTextureDesc.Height = dimensions.fHeight;
    msTextureDesc.DepthOrArraySize = 1;
    msTextureDesc.MipLevels = 1;
    msTextureDesc.Format = info.fFormat;
    msTextureDesc.SampleDesc.Count = sampleCnt;
    msTextureDesc.SampleDesc.Quality = 0;  // TODO: only valid for tiled renderers
    msTextureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;  // Use default for dxgi format
    msTextureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;

    if (!GrD3DTextureResource::InitTextureResourceInfo(gpu, msTextureDesc, info.fProtected,
                                                       &msInfo)) {
        return {};
    }

    msState.reset(new GrD3DResourceState(
                              static_cast<D3D12_RESOURCE_STATES>(msInfo.fResourceState)));

    return std::make_pair(msInfo, msState);
}

sk_sp<GrD3DTextureRenderTarget> GrD3DTextureRenderTarget::MakeNewTextureRenderTarget(
        GrD3DGpu* gpu,
        SkBudgeted budgeted,
        SkISize dimensions,
        int sampleCnt,
        const D3D12_RESOURCE_DESC& resourceDesc,
        GrProtected isProtected,
        GrMipMapsStatus mipMapsStatus) {

    GrD3DTextureResourceInfo info;
    if (!GrD3DTextureResource::InitTextureResourceInfo(gpu, resourceDesc, isProtected,
                                                       &info)) {
        return nullptr;
    }
    sk_sp<GrD3DResourceState> state(new GrD3DResourceState(
                                          static_cast<D3D12_RESOURCE_STATES>(info.fResourceState)));

    if (sampleCnt > 1) {
        GrD3DTextureResourceInfo msInfo;
        sk_sp<GrD3DResourceState> msState;

        std::tie(msInfo, msState) = create_msaa_resource(gpu, dimensions, sampleCnt, info);

        return sk_sp<GrD3DTextureRenderTarget>(new GrD3DTextureRenderTarget(
                gpu, budgeted, dimensions, sampleCnt, info, std::move(state),
                msInfo, std::move(msState), mipMapsStatus));
    } else {
        return sk_sp<GrD3DTextureRenderTarget>(new GrD3DTextureRenderTarget(
                gpu, budgeted, dimensions, info, std::move(state), mipMapsStatus));
    }
}

sk_sp<GrD3DTextureRenderTarget> GrD3DTextureRenderTarget::MakeWrappedTextureRenderTarget(
        GrD3DGpu* gpu,
        SkISize dimensions,
        int sampleCnt,
        GrWrapOwnership wrapOwnership,
        GrWrapCacheable cacheable,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state) {
    // TODO: If a client uses their own heap to allocate, how do we manage that?
    // Adopted textures require both image and allocation because we're responsible for freeing
    //SkASSERT(VK_NULL_HANDLE != info.fImage &&
    //         (kBorrow_GrWrapOwnership == wrapOwnership || VK_NULL_HANDLE != info.fAlloc.fMemory));

    GrMipMapsStatus mipMapsStatus = info.fLevelCount > 1 ? GrMipMapsStatus::kDirty
                                                         : GrMipMapsStatus::kNotAllocated;

    GrBackendObjectOwnership ownership = kBorrow_GrWrapOwnership == wrapOwnership
            ? GrBackendObjectOwnership::kBorrowed : GrBackendObjectOwnership::kOwned;
    if (sampleCnt > 1) {
        GrD3DTextureResourceInfo msInfo;
        sk_sp<GrD3DResourceState> msState;

        std::tie(msInfo, msState) = create_msaa_resource(gpu, dimensions, sampleCnt, info);
        return sk_sp<GrD3DTextureRenderTarget>(new GrD3DTextureRenderTarget(
                gpu, dimensions, sampleCnt, info, std::move(state), msInfo, msState, mipMapsStatus,
                ownership, cacheable));
    } else {
        return sk_sp<GrD3DTextureRenderTarget>(new GrD3DTextureRenderTarget(
                gpu, dimensions, info, std::move(state), mipMapsStatus, ownership, cacheable));
    }
}

size_t GrD3DTextureRenderTarget::onGpuMemorySize() const {
    int numColorSamples = this->numSamples();
    if (numColorSamples > 1) {
        // Add one to account for the resolve VkImage.
        ++numColorSamples;
    }
    const GrCaps& caps = *this->getGpu()->caps();
    return GrSurface::ComputeSize(caps, this->backendFormat(), this->dimensions(),
                                  numColorSamples,  // TODO: this still correct?
                                  this->texturePriv().mipMapped());
}