#include "latency.hpp"

#include <algorithm>
#include <future>
#include <vector>

// Каждый вызов получает свой диапазон и собственный приёмник результата.
extern "C" void scan_range(const Sample* first, const Sample* last,
                           std::uint16_t limit_ms, Summary* out) noexcept {
    Summary part{};
    for (const Sample* row = first; row != last; ++row) {
        const auto ms = row->elapsed_ms;
        if ((row->flags & 1u) == 0 || ms == UINT16_MAX)
            continue;
        part.total_ms += ms;
        ++part.accepted;
        part.slow += ms > limit_ms;
        part.peak_ms = std::max(part.peak_ms, ms);
    }
    *out = part;
}

Summary summarize_latency(std::span<const Sample> rows,
                          std::uint16_t limit_ms, unsigned workers) {
    if (rows.empty())
        return {};

    const auto count = std::min<std::size_t>(rows.size(), std::clamp(workers, 1u, 8u));
    const auto block = rows.size() / count;
    const auto extra = rows.size() % count;
    auto reduce = [limit_ms](const Sample* begin, const Sample* end) {
        Summary local{};
        scan_range(begin, end, limit_ms, &local);
        return local;
    };

    std::vector<std::future<Summary>> pending;
    pending.reserve(count - 1);
    const Sample* cursor = rows.data();
    for (std::size_t lane = 0; lane + 1 < count; ++lane) {
        const Sample* end = cursor + block + (lane < extra);
        pending.emplace_back(std::async(std::launch::async, reduce, cursor, end));
        cursor = end;
    }

    // Последний диапазон обрабатывает вызывающий поток.
    Summary result = reduce(cursor, rows.data() + rows.size());
    for (auto& task : pending) {
        const Summary part = task.get();
        result.total_ms += part.total_ms;
        result.accepted += part.accepted;
        result.slow += part.slow;
        result.peak_ms = std::max(result.peak_ms, part.peak_ms);
    }
    return result;
}
