/*
 * Copyright 2026 Rive
 */

#include "rive/renderer/triangulation_controller.hpp"

#include <algorithm>
#include <cassert>
#include <cmath>

namespace rive::gpu
{
bool TriangulationController::admits(float area, size_t verbCount)
{
    assert(isEligible(area, verbCount));
    if (std::isinf(m_thresholds.frameBudgetMs))
    {
        // The guards decide alone. There's no budget to spend down and
        // endFrame() won't tune, so there's no score or bracket worth tracking
        // either.
        return true;
    }
    if (budgetExhausted())
    {
        // Out of budget. That's no verdict on the path's score, so don't record
        // it as a rejection: it would tell endFrame() to loosen when the real
        // problem is that we already admitted too much.
        return false;
    }

    // Triangulate based on value density: the biggest wins are large-area /
    // low-verb fills, so score = area / cost, where cost models triangulation's
    // ~N-log-N verb complexity.
    assert(verbCount > 1);
    const float n = static_cast<float>(verbCount);
    const float score = area / (n * std::log2(n));
    if (score > m_scoreThreshold)
    {
        m_frameMinAdmittedScore = std::min(m_frameMinAdmittedScore, score);
        return true;
    }
    else
    {
        m_frameMaxRejectedScore = std::max(m_frameMaxRejectedScore, score);
        return false;
    }
}

void TriangulationController::endFrame()
{
    const double frameBudgetMs = m_thresholds.frameBudgetMs;
    if (frameBudgetMs <= 0 || std::isinf(frameBudgetMs))
    {
        // Nothing to tune: at 0 we never triangulate, and at infinity the
        // guards decide alone. Leave the threshold where it is so the decision
        // stays independent of measured time.
        return;
    }

    const double frameMs = m_frameSeconds * 1e3;
    // Low-pass (EWMA) the noisy per-frame signal so the controller tracks the
    // trend -- including slow thermal/DVFS drift -- rather than frame-to-frame
    // jitter in which paths happen to be onscreen.
    constexpr double Alpha = 0.1;
    m_timeEwmaMs += Alpha * (frameMs - m_timeEwmaMs);

    // Nudge the value-density threshold toward the budget, with a hysteresis
    // dead-band. Over budget -> raise it (admit fewer, shedding the
    // lowest-value paths first); under -> lower it.
    const double ratio = m_timeEwmaMs / frameBudgetMs;
    if (ratio > 1.05 || ratio < 0.95)
    {
        // Both sides aim at a score measured on this frame's bracket, betting
        // it recurs in the next one. Overshoot a little so the decision still
        // flips if it drifts.
        constexpr float BracketBackoff = .99f;
        // The sqrt makes the step large when far from budget and gentle near
        // it, so it converges in a handful of frames without oscillating.
        const double factor = std::clamp(std::sqrt(ratio), 0.5, 2.0);
        if (factor > 1)
        {
            // EWMA called for us to tighten (reject more triangulations).
            if (m_frameMinAdmittedScore !=
                std::numeric_limits<float>::infinity()) // If we admitted
                                                        // nothing, we already
                                                        // rejected everything,
                                                        // so tightening further
                                                        // does nothing.
            {
                // The multiplicative step is blind to the actual triangulations
                // being scored, operating solely on the time ratio to tighten
                // the heuristic. However, we do track the frame's min admitted
                // triangulation score, which lets us tighten enough to reject
                // at least one more path when the step alone wouldn't make a
                // difference.
                // NOTE: The EWMA would converge either way, but the bracket
                // gets us there in one frame instead of a geometric climb, and
                // doesn't overrun the budget along the way.
                m_scoreThreshold =
                    std::max(m_scoreThreshold * static_cast<float>(factor),
                             m_frameMinAdmittedScore / BracketBackoff);
            }
        }
        else
        {
            // EWMA called for us to loosen (admit more triangulations).
            if (m_frameMaxRejectedScore != 0) // If we rejected nothing, we
                                              // already admitted everything, so
                                              // loosening further does nothing.
            {
                // The multiplicative step is blind to the actual triangulations
                // being scored, operating solely on the time ratio to loosen
                // the heuristic. However, we do track the frame's max rejected
                // triangulation score, which lets us loosen enough to admit at
                // least one more path when the step alone wouldn't make a
                // difference.
                // NOTE: The EWMA would converge either way, but the bracket
                // gets us there in one frame instead of a geometric descent,
                // and doesn't leave triangulations on the table along the way.
                m_scoreThreshold =
                    std::min(m_scoreThreshold * static_cast<float>(factor),
                             m_frameMaxRejectedScore * BracketBackoff);
            }
        }
    }
    m_scoreThreshold = std::clamp(m_scoreThreshold, 1.f, 1e9f);
}
} // namespace rive::gpu