#pragma once

#include "VoxelForgeCore/VoxelForgeCore.h"
#include "StandaloneWorkerThread.h"

#include <algorithm>
#include <atomic>
#include <chrono>
#include <thread>
#include <vector>

// This executor belongs to the standalone host. VoxelForgeCore submits indexed work but never
// creates or owns worker threads.
class FStandaloneCoreScheduler final : public VoxelForgeCore::JobScheduler
{
public:
    explicit FStandaloneCoreScheduler(std::size_t helperLimit=12)
        :HelperLimit(std::clamp<std::size_t>(helperLimit,1,12)){}

    double parallel_for(std::size_t count,std::size_t batchSize,std::size_t workerLimit,
                        void* context,Task task,double* workerActiveSeconds,
                        std::size_t workerActiveCapacity) const override
    {
        if(count==0)return 0.0;
        const std::size_t workers=std::clamp<std::size_t>(workerLimit,1,
            std::min<std::size_t>(HelperLimit,std::max<std::size_t>(1,count)));
        const std::size_t grain=std::max<std::size_t>(1,batchSize);
        std::atomic<std::size_t> next{0};
        std::vector<double> active(workers,0.0);
        std::vector<FStandaloneWorkerThread> threads;
        threads.reserve(workers);
        for(std::size_t worker=0;worker<workers;++worker)
            threads.emplace_back([&,worker]
            {
                const auto started=std::chrono::steady_clock::now();
                for(;;)
                {
                    const std::size_t first=next.fetch_add(grain,std::memory_order_relaxed);
                    if(first>=count)break;
                    const std::size_t end=first+std::min(grain,count-first);
                    for(std::size_t index=first;index<end;++index)task(context,index,worker);
                }
                active[worker]=std::chrono::duration<double>(
                    std::chrono::steady_clock::now()-started).count();
            });
        for(FStandaloneWorkerThread& thread:threads)thread.join();
        double total=0.0;
        for(std::size_t worker=0;worker<workers;++worker)
        {
            total+=active[worker];
            if(workerActiveSeconds&&worker<workerActiveCapacity)
                workerActiveSeconds[worker]=active[worker];
        }
        return total;
    }

private:
    std::size_t HelperLimit=8;
};