#include "XCEngine/RHI/D3D12/D3D12CommandQueue.h"
#include "XCEngine/RHI/D3D12/D3D12CommandList.h"
#include "XCEngine/RHI/D3D12/D3D12Fence.h"
#include <vector>

namespace XCEngine {
namespace RHI {

D3D12CommandQueue::D3D12CommandQueue()
    : m_timestampFrequency(0)
    , m_type(CommandQueueType::Direct) {
}

D3D12CommandQueue::~D3D12CommandQueue() {
    Shutdown();
}

bool D3D12CommandQueue::Initialize(ID3D12Device* device, CommandQueueType type) {
    D3D12_COMMAND_QUEUE_DESC queueDesc = {};
    queueDesc.Type = ToD3D12(type);
    queueDesc.Priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL;
    queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
    queueDesc.NodeMask = 0;

    HRESULT hResult = device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_commandQueue));
    if (FAILED(hResult)) {
        return false;
    }

    m_type = type;
    m_commandQueue->GetTimestampFrequency(&m_timestampFrequency);
    return true;
}

void D3D12CommandQueue::Shutdown() {
    m_commandQueue.Reset();
}

void D3D12CommandQueue::ExecuteCommandLists(uint32_t count, ICommandList** lists) {
    std::vector<ID3D12CommandList*> d3d12Lists(count);
    for (uint32_t i = 0; i < count; ++i) {
        if (lists[i]) {
            d3d12Lists[i] = reinterpret_cast<D3D12CommandList*>(lists[i])->GetCommandList();
        }
    }
    m_commandQueue->ExecuteCommandLists(count, d3d12Lists.data());
}

void D3D12CommandQueue::ExecuteCommandLists(uint32_t count, ID3D12CommandList** lists) {
    m_commandQueue->ExecuteCommandLists(count, lists);
}

void D3D12CommandQueue::Signal(IFence* fence, uint64_t value) {
    if (fence) {
        m_commandQueue->Signal(reinterpret_cast<D3D12Fence*>(fence)->GetFence(), value);
    }
}

void D3D12CommandQueue::Signal(ID3D12Fence* fence, uint64_t value) {
    if (fence) {
        m_commandQueue->Signal(fence, value);
    }
}

void D3D12CommandQueue::Wait(IFence* fence, uint64_t value) {
    if (fence) {
        m_commandQueue->Wait(reinterpret_cast<D3D12Fence*>(fence)->GetFence(), value);
    }
}

void D3D12CommandQueue::Wait(ID3D12Fence* fence, uint64_t value) {
    if (fence) {
        m_commandQueue->Wait(fence, value);
    }
}

uint64_t D3D12CommandQueue::GetCompletedValue() {
    return 0;
}

void D3D12CommandQueue::WaitForIdle() {
    ID3D12Fence* fence = nullptr;
    HRESULT hResult = m_commandQueue->GetDevice(IID_PPV_ARGS(&fence));
    if (SUCCEEDED(hResult)) {
        m_commandQueue->Wait(fence, UINT64_MAX);
        fence->Release();
    }
}

} // namespace RHI
} // namespace XCEngine