#include <XCEngine/Core/Asset/AsyncLoader.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>

namespace XCEngine {
namespace Resources {

Core::uint64 LoadRequest::GenerateRequestId() {
    static std::atomic<Core::uint64> s_requestId{0};
    return ++s_requestId;
}

AsyncLoader& AsyncLoader::Get() {
    static AsyncLoader instance;
    return instance;
}

void AsyncLoader::Initialize(Core::uint32 workerThreadCount) {
    (void)workerThreadCount;
}

void AsyncLoader::Shutdown() {
    CancelAll();
}

void AsyncLoader::Submit(const Containers::String& path, ResourceType type,
                        std::function<void(LoadResult)> callback) {
    Submit(path, type, nullptr, std::move(callback));
}

void AsyncLoader::Submit(const Containers::String& path, ResourceType type, ImportSettings* settings,
                        std::function<void(LoadResult)> callback) {
    LoadRequest request(path, type, std::move(callback), settings);
    SubmitInternal(std::move(request));
}

void AsyncLoader::SubmitInternal(LoadRequest request) {
    IResourceLoader* loader = FindLoader(request.type);
    
    if (!loader) {
        if (request.callback) {
            LoadResult result(Containers::String("No loader for type: ") + 
                           GetResourceTypeName(request.type));
            request.callback(result);
        }
        return;
    }
    
    {
        std::lock_guard lock(m_queueMutex);
        m_pendingQueue.PushBack(std::move(request));
        m_pendingCount++;
        m_totalRequested++;
    }
}

void AsyncLoader::Update() {
    Containers::Array<LoadRequest> completed;
    
    {
        std::lock_guard lock(m_completedMutex);
        completed = std::move(m_completedQueue);
        m_completedQueue.Clear();
    }
    
    for (auto& request : completed) {
        m_pendingCount--;
        
        if (request.callback) {
            LoadResult result(true);
            request.callback(result);
        }
    }
}

float AsyncLoader::GetProgress() const {
    if (m_totalRequested == 0) return 1.0f;
    return static_cast<float>(m_totalRequested - m_pendingCount.load()) / m_totalRequested;
}

void AsyncLoader::CancelAll() {
    std::lock_guard lock(m_queueMutex);
    m_pendingQueue.Clear();
    m_pendingCount = 0;
}

void AsyncLoader::Cancel(Core::uint64 requestId) {
    std::lock_guard lock(m_queueMutex);
    (void)requestId;
}

IResourceLoader* AsyncLoader::FindLoader(ResourceType type) const {
    return ResourceManager::Get().GetLoader(type);
}

void AsyncLoader::QueueCompleted(LoadRequest request, LoadResult result) {
    std::lock_guard lock(m_completedMutex);
    (void)request;
    (void)result;
}

} // namespace Resources
} // namespace XCEngine