/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  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.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */

#pragma once

/// \file
/// Declaration of Diligent::SwapChainVkImpl class

#include "EngineVkImplTraits.hpp"
#include "SwapChainVk.h"
#include "SwapChainBase.hpp"
#include "VulkanUtilities/VulkanInstance.hpp"
#include "VulkanUtilities/VulkanObjectWrappers.hpp"
#include "ManagedVulkanObject.hpp"
#include "../interface/EngineFactoryVk.h"

namespace Diligent
{

/// Swap chain implementation in Vulkan backend.
class SwapChainVkImpl final : public SwapChainBase<ISwapChainVk>
{
public:
    using TSwapChainBase = SwapChainBase<ISwapChainVk>;

    SwapChainVkImpl(IReferenceCounters*        pRefCounters,
                    const SwapChainDesc&       SwapChainDesc,
                    class RenderDeviceVkImpl*  pRenderDeviceVk,
                    class DeviceContextVkImpl* pDeviceContextVk,
                    uint32_t                   SwapChainImageCount,
                    const VkImage*             pSwapChainImages,
                    SwapChainImageCallbacks    SwapChainCallbacks);
    ~SwapChainVkImpl();

    IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_SwapChainVk, TSwapChainBase)

    /// Implementation of ISwapChain::Present() in Vulkan backend.
    virtual void DILIGENT_CALL_TYPE Present(Uint32 SyncInterval) override final;

    /// Implementation of ISwapChain::Present() in Vulkan backend.
    virtual void DILIGENT_CALL_TYPE PresentImage() override final;

    /// Implementation of ISwapChainVk::AcquireNextImage() in Vulkan backend.
    virtual VkResult DILIGENT_CALL_TYPE AcquireNextImage() override final;

    /// Implementation of ISwapChain::Resize() in Vulkan backend.
    virtual void DILIGENT_CALL_TYPE Resize(Uint32 NewWidth, Uint32 NewHeight, SURFACE_TRANSFORM NewPreTransform) override final;

    /// Implementation of ISwapChain::SetFullscreenMode() in Vulkan backend.
    virtual void DILIGENT_CALL_TYPE SetFullscreenMode(const DisplayModeAttribs& DisplayMode) override final;

    /// Implementation of ISwapChain::SetWindowedMode() in Vulkan backend.
    virtual void DILIGENT_CALL_TYPE SetWindowedMode() override final;

    /// Implementation of ISwapChain::GetCurrentBackBufferRTV() in Vulkan backend.
    virtual ITextureViewVk* DILIGENT_CALL_TYPE GetCurrentBackBufferRTV() override final
    {
        VERIFY_EXPR(m_BackBufferIndex >= 0 && m_BackBufferIndex < m_SwapChainDesc.BufferCount);
        return m_pBackBufferRTV[m_BackBufferIndex];
    }

    /// Implementation of ISwapChain::GetDepthBufferDSV() in Vulkan backend.
    virtual ITextureViewVk* DILIGENT_CALL_TYPE GetDepthBufferDSV() override final { return m_pDepthBufferDSV; }

private:
    void     InitBuffersAndViews(uint32_t SwapChainImageCount, const VkImage *SwapChainImages);
    void     ReleaseSwapChainResources(DeviceContextVkImpl* pImmediateCtxVk);

    std::shared_ptr<const VulkanUtilities::VulkanInstance> m_VulkanInstance;
    std::vector<RefCntAutoPtr<ITextureViewVk>, STDAllocatorRawMem<RefCntAutoPtr<ITextureViewVk>>> m_pBackBufferRTV;
    std::vector<bool, STDAllocatorRawMem<bool>> m_SwapChainImagesInitialized;

    RefCntAutoPtr<ITextureViewVk> m_pDepthBufferDSV;

    void*      m_Cookie;
    VkResult (*m_AcquireImageCallback)(void* Cookie, uint32_t* Image);
    void     (*m_ReleaseImageCallback)(void* Cookie);

    uint32_t m_BackBufferIndex = 0;
    bool     m_IsMinimized     = false;
    bool     m_VSyncEnabled    = true;
};

} // namespace Diligent