//
// Created by atdunbg on 2026/9/20.
//


#include <Engine/Vulkan/SyncManager.h>
#include <Engine/Vulkan/Device.h>
#include <Engine/Core/Log.h>

#include <limits>

namespace Engine {

    SyncManager::SyncManager(Device& device, u32 maxFramesInFlight, u32 imageCount)
        : m_Device(device)
    {
        vk::SemaphoreCreateInfo semInfo;

        // 每帧一个 ImageAvailable
        m_ImageAvailable.resize(maxFramesInFlight);
        for (auto& sem : m_ImageAvailable) {
            sem = m_Device.GetDevice().createSemaphore(semInfo);
        }

        // 每张交换链 image 一个 RenderFinished
        m_RenderFinished.resize(imageCount);
        for (auto& sem : m_RenderFinished) {
            sem = m_Device.GetDevice().createSemaphore(semInfo);
        }

        // 每帧一个 Fence，初始 signaled
        vk::FenceCreateInfo fenceInfo;
        fenceInfo.setFlags(vk::FenceCreateFlagBits::eSignaled);
        m_FrameFences.resize(maxFramesInFlight);
        for (auto& fence : m_FrameFences) {
            fence = m_Device.GetDevice().createFence(fenceInfo);
        }

        ENGINE_INFO("SyncManager created ({} frames, {} images)",
                    maxFramesInFlight, imageCount);
    }

    SyncManager::~SyncManager()
    {
        const auto& vkDevice = m_Device.GetDevice();
        for (auto f : m_FrameFences) vkDevice.destroyFence(f);
        for (auto s : m_ImageAvailable) vkDevice.destroySemaphore(s);
        for (auto s : m_RenderFinished) vkDevice.destroySemaphore(s);
    }

    void SyncManager::WaitFence(u32 frameIndex)
    {
        auto result = m_Device.GetDevice().waitForFences(
            m_FrameFences[frameIndex], VK_TRUE, std::numeric_limits<u64>::max());
        if (result != vk::Result::eSuccess) {
            ENGINE_ERROR("waitForFences failed");
        }
    }

    void SyncManager::ResetFence(u32 frameIndex)
    {
        m_Device.GetDevice().resetFences(m_FrameFences[frameIndex]);
    }
} // namespace Engine