#include "Threading/TaskSystem.h"
#include "Threading/LambdaTask.h"

namespace XCEngine {
namespace Threading {

TaskGroup::TaskGroup() = default;

TaskGroup::~TaskGroup() = default;

uint64_t TaskGroup::AddTask(std::unique_ptr<ITask> task) {
    std::lock_guard<std::mutex> lock(m_mutex);
    
    TaskNode node;
    node.task = task.get();
    node.pendingDepCount = static_cast<int>(node.dependencies.size());
    
    uint64_t taskId = m_tasks.size();
    m_tasks.emplace_back(std::move(node));
    m_pendingCount++;
    
    task.release();
    return taskId;
}

uint64_t TaskGroup::AddTask(Callback&& func, TaskPriority priority) {
    auto task = std::make_unique<LambdaTask<Callback>>(std::move(func), priority);
    return AddTask(std::move(task));
}

void TaskGroup::AddDependency(uint64_t taskId, uint64_t dependsOn) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (taskId < m_tasks.size() && dependsOn < m_tasks.size()) {
        m_tasks[taskId].dependencies.push_back(dependsOn);
    }
}

void TaskGroup::Wait() {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_condition.wait(lock, [this] { return m_pendingCount.load() == 0; });
}

bool TaskGroup::WaitFor(std::chrono::milliseconds timeout) {
    std::unique_lock<std::mutex> lock(m_mutex);
    return m_condition.wait_for(lock, timeout, [this] { return m_pendingCount.load() == 0; });
}

void TaskGroup::SetCompleteCallback(Callback&& callback) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_completeCallback = std::move(callback);
}

bool TaskGroup::IsComplete() const {
    return m_pendingCount.load() == 0;
}

float TaskGroup::GetProgress() const {
    int total = m_tasks.size();
    if (total == 0) return 1.0f;
    return static_cast<float>(m_completedCount.load()) / static_cast<float>(total);
}

void TaskGroup::Cancel() {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_canceled = true;
    for (auto& node : m_tasks) {
        if (node.task && !node.completed) {
            node.task->OnCancel();
        }
    }
}

} // namespace Threading
} // namespace XCEngine