#include "MetaCoreRendering/MetaCoreRendering.h"

#include <algorithm>
#include <chrono>
#include <iostream>
#include <vector>

int main() {
    constexpr std::size_t kInstanceCount = 100000U;
    constexpr std::size_t kFrameCount = 120U;
    std::vector<MetaCore::MetaCoreBvhItem> items;
    items.reserve(kInstanceCount);
    for (std::size_t index = 0; index < kInstanceCount; ++index) {
        const float x = static_cast<float>(index % 500U) * 0.015F - 3.75F;
        const float y = static_cast<float>((index / 500U) % 200U) * 0.015F - 1.5F;
        const float z = static_cast<float>(index % 13U) * 0.002F;
        const glm::vec3 center{x, y, z};
        items.push_back({static_cast<MetaCore::MetaCoreId>(index + 1U), {center - glm::vec3(0.005F), center + glm::vec3(0.005F)}, 1U, 0.0F, false});
    }
    MetaCore::MetaCoreStaticVisibilityBvh bvh;
    const auto buildStart = std::chrono::steady_clock::now();
    bvh.Build(items);
    const auto buildEnd = std::chrono::steady_clock::now();
    const auto frustum = MetaCore::MetaCoreExtractFrustum(glm::mat4(1.0F));
    std::vector<double> frameTimes;
    frameTimes.reserve(kFrameCount);
    std::size_t visibleCount = 0U;
    for (std::size_t frame = 0; frame < kFrameCount; ++frame) {
        const auto begin = std::chrono::steady_clock::now();
        MetaCore::MetaCoreVisibilityStatistics statistics;
        const auto visible = bvh.Query(frustum, {}, 1U, &statistics);
        std::vector<MetaCore::MetaCoreInstanceCandidate> candidates;
        candidates.reserve(visible.size());
        for (const auto id : visible) candidates.push_back({id, {}, {}, 1U, 1U, true});
        const auto batches = MetaCore::MetaCoreBuildInstanceBatches(candidates);
        visibleCount = visible.size() + (batches.empty() ? 0U : 0U);
        const auto end = std::chrono::steady_clock::now();
        frameTimes.push_back(std::chrono::duration<double, std::milli>(end - begin).count());
    }
    std::sort(frameTimes.begin(), frameTimes.end());
    const double p95 = frameTimes[static_cast<std::size_t>(0.95 * static_cast<double>(frameTimes.size() - 1U))];
    const double buildMs = std::chrono::duration<double, std::milli>(buildEnd - buildStart).count();
    std::cout << "{\"instances\":" << kInstanceCount << ",\"visible\":" << visibleCount
              << ",\"bvh_nodes\":" << bvh.GetNodeCount() << ",\"build_ms\":" << buildMs
              << ",\"steady_cpu_p95_ms\":" << p95 << "}\n";
    return visibleCount > 0U && bvh.GetNodeCount() > 0U ? 0 : 1;
}