reasampler/tests/test_envelope_edit.cpp

// Standalone tests for reasampler::instrument::ui::envelope_edit — no VST3, no REAPER, no framework.
// Same fast assert loop as the sibling pure tests. Assert the S-VIEW-3 draggable-node INVERSE
// map: node hit-test + pixel-delta -> clamped/monotonic param set, HARD at the clamp + monotonic
// boundaries (the load-bearing "a drag can never produce a param a slider couldn't" invariant).
//
// Covers: nodeAtPoint (grabs a drawn handle within the pick radius; misses off every node; skips
// the non-draggable Origin/ReleaseStart anchors AND other-mode nodes; NEAREST-node-wins with
// draw-order tie-break; EVERY Gate node individually grabbable at the tier-0 defaults — FA2);
// resolveNodeDrag Gate (each cumulative node edits its OWN segment at the PARAM-DOMAIN px scale;
// X->time, sustain node's Y->level; lower clamp at 0; upper clamp at the caller's max; only the
// dragged param changes; ReleaseEnd grabbable + draggable; per-node drag round-trip tracks the
// cursor ~1:1 — FA2); resolveNodeDrag Trigger (fades as fractions of the played span;
// fadeIn/fadeOut mutual clamp so they never cross; length clamp; FadeOutStart moves OPPOSITE the
// pixel delta; zero-fade-out node grabbable at the right edge and draggable inward — FA2);
// degenerate area/duration + non-draggable node + cross-mode node -> no motion.

#include "../src/core/instrument/ui/envelope_edit.h"

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>

using namespace reasampler;
using namespace reasampler::instrument::ui;

static int g_fail = 0;
#define CHECK(cond) do { if(!(cond)) { \
    std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)

static bool near(double a, double b, double eps = 1e-9) { return std::fabs(a - b) <= eps; }

// Find the first vertex with a given node in a polyline; asserts presence via the returned bool.
static bool findNode(const std::vector<EnvVertex>& poly, EnvNode node, EnvVertex& out) {
    for (const EnvVertex& v : poly) {
        if (v.node == node) { out = v; return true; }
    }
    return false;
}

// 1000px wide, 100px tall, offset origin. Trigger scale: 2.0s over 1000px => 0.002 s/px. Gate
// scale (FA2 param-domain schematic — sample-length-free): (850-1-32)px over the 8.0s schematic
// domain => 102.125 px/s, each segment prefixed by the 8px separation base; the gateEnv() nodes
// draw at A x@28, H x@47, D x@85, RS x@235, RE x@284.
static Rect wideArea() { return Rect::ltrb(20, 10, 1020, 110); }
static constexpr double kTotal = 2.0;

// nodeAtPoint/resolveNodeDrag take the overlay type, not a bare Rect (the distinct-type
// enforcement in editor_geometry.h) — this wraps a plain test Rect for them.
static OverlayArea overlayOf(const Rect& r) { return OverlayArea{r}; }
static const double kGateSecPerPx = 1.0 / gatePxPerSecond(wideArea());

static AmpEnvelope gateEnv() {
    AmpEnvelope e;
    e.mode = EnvMode::Gate;
    e.attackSeconds  = 0.2;
    e.holdSeconds    = 0.1;
    e.decaySeconds   = 0.3;
    e.sustainLevel   = 0.5;
    e.releaseSeconds = 0.4;
    return e;
}

static AmpEnvelope triggerEnv() {
    AmpEnvelope e;
    e.mode = EnvMode::Trigger;
    e.lengthFraction  = 0.5;   // played span 1.0s -> 500px
    e.fadeInFraction  = 0.2;
    e.fadeOutFraction = 0.2;
    return e;
}

// --- nodeAtPoint --------------------------------------------------------------

static void testHitGrabsDrawnHandle() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    // AttackEnd draws at x = left+28 (8px base + 0.2s * 102.125 px/s), y = top (level 1).
    NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 28, a.y);
    CHECK(h.hit && h.node == EnvNode::AttackEnd);
    // The sustain node (DecayEnd) at left+85, level 0.5 -> ~top+50.
    NodeHit s = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 85, a.y + 50);
    CHECK(s.hit && s.node == EnvNode::DecayEnd);
}

static void testHitMissesOffEveryNode() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    // A point far from any drawn handle (right of the release ramp, well away from a node).
    NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 700, a.y + 5);
    CHECK(!h.hit);
}

static void testHitSkipsNonDraggableAnchors() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    // Origin draws at (left, bottom-1). Even a pixel-perfect grab there is NOT a draggable node.
    NodeHit o = nodeAtPoint(e, overlayOf(a), kTotal, a.x, a.bottom() - 1);
    CHECK(!o.hit);
    // ReleaseStart draws at (left+235, sustain level ~top+50) — the fixed plateau end. It is
    // drawing-only -> not grabbable; no other node is within the radius, so this grab misses.
    NodeHit rs = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 235, a.y + 50);
    CHECK(!rs.hit);
}

static void testHitNearestNodeWinsOverDrawOrder() {
    // FA2 nearest-wins: with a SHORT hold, AttackEnd (x@28) and HoldEnd (x@37 — the 8px base
    // plus 0.01s ~= 1px) both fall within the grab radius of a point at x@33 — the NEAREST
    // (HoldEnd, 4px) must win, not the earlier draw-order AttackEnd (5px), so tightly packed
    // handles stay individually grabbable.
    AmpEnvelope e = gateEnv();
    e.holdSeconds = 0.01;
    const Rect a = wideArea();
    NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 33, a.y);
    CHECK(h.hit && h.node == EnvNode::HoldEnd);
}

static void testGateDefaultsEveryNodeGrabbable() {
    // THE FA2 headline regression: at the tier-0 Gate defaults (attack 3ms, hold 0, decay 0,
    // sustain 1.0, release 60ms) the forward map's kGateNodeSepPx separation keeps every
    // draggable node distinct, and a grab AT each drawn vertex resolves to THAT node — HoldEnd
    // and DecayEnd are no longer shadowed by AttackEnd (pre-fix they were permanently
    // ungrabbable in the default state).
    const AmpEnvelope e;   // struct defaults ARE the tier-0 Gate defaults
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(e, overlayOf(a), kTotal);
    CHECK(poly.size() == 6);
    for (const EnvVertex& v : poly) {
        if (v.node == EnvNode::Origin || v.node == EnvNode::ReleaseStart) continue;
        const NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, v.x, v.y);
        CHECK(h.hit && h.node == v.node);
    }
}

// --- resolveNodeDrag Gate -----------------------------------------------------

static void testGateAttackDragMovesOnlyAttack() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;  // default maxima 4.0s
    // +50px at the GATE param-domain scale (~0.0098 s/px) on attack. Nothing else moves.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, b, 50, 0);
    CHECK(near(out.attackSeconds, 0.2 + 50.0 * kGateSecPerPx));
    CHECK(near(out.holdSeconds, e.holdSeconds));
    CHECK(near(out.decaySeconds, e.decaySeconds));
    CHECK(near(out.sustainLevel, e.sustainLevel));
    CHECK(near(out.releaseSeconds, e.releaseSeconds));
}

static void testGateTimeLowerClampAtZero() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    // Drag attack far LEFT (-500px ~= -4.9s at the gate scale) from 0.2s: clamps to 0, never
    // negative (monotonic: the segment cannot go below zero).
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, b, -500, 0);
    CHECK(near(out.attackSeconds, 0.0));
}

static void testGateTimeUpperClampAtSliderMax() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    b.maxDecaySeconds = 1.0;   // the shell's decay slider tops out at 1.0s
    // Drag decay far RIGHT (+2000px ~= +19.6s at the gate scale) from 0.3s: clamps to the slider
    // max 1.0, NOT beyond (the drag can't produce a param the slider couldn't).
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 2000, 0);
    CHECK(near(out.decaySeconds, 1.0));
}

static void testGateSustainNodeBothAxes() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    // DecayEnd: +100px X at the gate timed scale on decay; +bottom-ward Y LOWERS the level. Level
    // span is 99 px for [0,1]; drag DOWN by ~10px (positive dy) lowers sustain by ~10/99 ~= 0.101.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 100, 10);
    CHECK(near(out.decaySeconds, 0.3 + 100.0 * kGateSecPerPx));
    CHECK(out.sustainLevel < e.sustainLevel);            // dragged DOWN -> lower sustain
    CHECK(near(out.sustainLevel, 0.5 - 10.0 / 99.0, 1e-6));
}

static void testGateSustainLevelClamps01() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    // Drag sustain UP hard (dy very negative): clamps to 1.0.
    AmpEnvelope up = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, -10000);
    CHECK(near(up.sustainLevel, 1.0));
    // Drag sustain DOWN hard (dy very positive): clamps to 0.0.
    AmpEnvelope dn = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, 10000);
    CHECK(near(dn.sustainLevel, 0.0));
}

static void testGateTimeOnlyNodeIgnoresY() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    // HoldEnd is time-only: a big Y delta must NOT change any level (there is no level to change).
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, b, 0, 500);
    CHECK(near(out.holdSeconds, e.holdSeconds));   // dx 0 -> no time change either
    CHECK(near(out.sustainLevel, e.sustainLevel)); // Y ignored for a time-only node
}

static void testGateReleaseEndGrabAndDrag() {
    // The FA2 fix: ReleaseEnd is a drawn, IN-BOUNDS, grabbable handle (pre-FA2 it mapped past
    // area.right() and could never be grabbed). gateEnv() draws it at x@284, level 0 (bottom row).
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 284, a.bottom() - 1);
    CHECK(h.hit && h.node == EnvNode::ReleaseEnd);
    // Dragging it RIGHT lengthens the release at the gate timed scale; only release changes.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::ReleaseEnd, overlayOf(a), kTotal, b, 85, 0);
    CHECK(near(out.releaseSeconds, 0.4 + 85.0 * kGateSecPerPx));
    CHECK(near(out.sustainLevel, e.sustainLevel));
    CHECK(near(out.decaySeconds, e.decaySeconds));
    // Far LEFT clamps to 0; far RIGHT clamps to the slider max.
    AmpEnvelope lo = resolveNodeDrag(e, EnvNode::ReleaseEnd, overlayOf(a), kTotal, b, -2000, 0);
    CHECK(near(lo.releaseSeconds, 0.0));
    AmpEnvelope hi = resolveNodeDrag(e, EnvNode::ReleaseEnd, overlayOf(a), kTotal, b, 5000, 0);
    CHECK(near(hi.releaseSeconds, b.maxReleaseSeconds));
}

static void testGateDragRoundTripTracksPixels() {
    // 1:1 tracking (FA2): drag a Gate node by N px, rebuild the polyline from the edited params,
    // and the node's drawn vertex has moved by ~N px (rounding may shift the landing by 1). The
    // forward map is affine in each node's own segment duration with slope gatePxPerSecond and
    // the inverse uses exactly the reciprocal, so the handle follows the cursor.
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    const int dx = 25;
    for (EnvNode n : {EnvNode::AttackEnd, EnvNode::HoldEnd, EnvNode::DecayEnd,
                      EnvNode::ReleaseEnd}) {
        EnvVertex before, after;
        CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), n, before));
        const AmpEnvelope edited = resolveNodeDrag(e, n, overlayOf(a), kTotal, b, dx, 0);
        CHECK(findNode(buildEnvelopePolyline(edited, overlayOf(a), kTotal), n, after));
        CHECK(std::abs((after.x - before.x) - dx) <= 1);
    }
    // The sustain node's Y axis tracks too: +10px down moves the drawn vertex ~10px down.
    EnvVertex before, after;
    CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), EnvNode::DecayEnd, before));
    const AmpEnvelope edited = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, 10);
    CHECK(findNode(buildEnvelopePolyline(edited, overlayOf(a), kTotal), EnvNode::DecayEnd, after));
    CHECK(std::abs((after.y - before.y) - 10) <= 1);
}

// --- resolveNodeDrag Trigger --------------------------------------------------

static void testTriggerFadeInIsFractionOfPlaySpan() {
    const AmpEnvelope e = triggerEnv();   // played span 1.0s -> 500px
    const Rect a = wideArea();
    EnvClampBounds b;
    // +50px = +0.1s on the play timeline = +0.1/1.0 = +0.1 fraction. fadeIn 0.2 -> 0.3.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeInEnd, overlayOf(a), kTotal, b, 50, 0);
    CHECK(near(out.fadeInFraction, 0.3));
    CHECK(near(out.fadeOutFraction, e.fadeOutFraction));  // unchanged
}

static void testTriggerFadesCannotCross() {
    AmpEnvelope e = triggerEnv();
    e.fadeInFraction  = 0.5;
    e.fadeOutFraction = 0.3;   // sum 0.8, room 0.2 before they'd cross
    const Rect a = wideArea();
    EnvClampBounds b;
    // Drag fade-in far RIGHT (+2000px): would push fadeIn well past 1-fadeOut=0.7, but the mutual
    // clamp caps it at 0.7 so the fade nodes never cross (monotonic on the play timeline).
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeInEnd, overlayOf(a), kTotal, b, 2000, 0);
    CHECK(near(out.fadeInFraction, 0.7));
    CHECK(near(out.fadeOutFraction, 0.3));
}

static void testTriggerFadeOutMovesOppositePixelDelta() {
    const AmpEnvelope e = triggerEnv();   // fadeOut 0.2, play span 1.0s -> 500px
    const Rect a = wideArea();
    EnvClampBounds b;
    // FadeOutStart sits at (1-fadeOut) of the span; dragging it LEFT (-50px) LENGTHENS the fade-out.
    // -50px = -0.1s = -0.1 fraction on the span, applied OPPOSITE -> fadeOut 0.2 -> 0.3.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeOutStart, overlayOf(a), kTotal, b, -50, 0);
    CHECK(near(out.fadeOutFraction, 0.3));
    CHECK(near(out.fadeInFraction, e.fadeInFraction));
}

static void testTriggerZeroFadeOutGrabbableAtRightEdge() {
    // The FA2 fix: at fade-out == 0 and full length, FadeOutStart draws AT the right edge
    // (right-1, level 1). It must be grabbable there and draggable INWARD to grow the fade from
    // zero (drag LEFT -> longer fade-out, opposite the pixel delta).
    AmpEnvelope e;
    e.mode = EnvMode::Trigger;
    e.lengthFraction  = 1.0;   // played span = full 2.0s -> 1000px
    e.fadeInFraction  = 0.1;
    e.fadeOutFraction = 0.0;
    const Rect a = wideArea();
    EnvClampBounds b;
    NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.right() - 1, a.y);
    CHECK(h.hit && h.node == EnvNode::FadeOutStart);
    // -100px = -0.2s on the 2.0s played span, applied OPPOSITE -> fadeOut 0.0 -> 0.1.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeOutStart, overlayOf(a), kTotal, b, -100, 0);
    CHECK(near(out.fadeOutFraction, 0.1));
    CHECK(near(out.lengthFraction, e.lengthFraction));   // length untouched
    // LengthEnd sits at the same x but level 0 (bottom row) — grabbable at ITS drawn point.
    NodeHit le = nodeAtPoint(e, overlayOf(a), kTotal, a.right() - 1, a.bottom() - 1);
    CHECK(le.hit && le.node == EnvNode::LengthEnd);
}

static void testTriggerLengthClampsAtMax() {
    const AmpEnvelope e = triggerEnv();   // length 0.5
    const Rect a = wideArea();
    EnvClampBounds b;                     // maxLengthFraction 1.0
    // LengthEnd maps to a fraction of the WHOLE sample: +2000px = +4.0s = +2.0 fraction, clamps 1.0.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::LengthEnd, overlayOf(a), kTotal, b, 2000, 0);
    CHECK(near(out.lengthFraction, 1.0));
    // Drag far LEFT clamps to 0.
    AmpEnvelope lo = resolveNodeDrag(e, EnvNode::LengthEnd, overlayOf(a), kTotal, b, -2000, 0);
    CHECK(near(lo.lengthFraction, 0.0));
}

// --- No-motion guards ---------------------------------------------------------

static void testNonDraggableNodeNoMotion() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;
    AmpEnvelope o = resolveNodeDrag(e, EnvNode::Origin, overlayOf(a), kTotal, b, 500, 500);
    CHECK(near(o.attackSeconds, e.attackSeconds) && near(o.sustainLevel, e.sustainLevel));
    AmpEnvelope rs = resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, b, 500, 500);
    CHECK(near(rs.releaseSeconds, e.releaseSeconds));
}

static void testDegenerateAreaNoMotion() {
    const AmpEnvelope e = gateEnv();
    EnvClampBounds b;
    const Rect zeroW = Rect::ltrb(0, 0, 0, 100);
    AmpEnvelope o1 = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(zeroW), kTotal, b, 500, 0);
    CHECK(near(o1.attackSeconds, e.attackSeconds));
    AmpEnvelope o2 = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(wideArea()), 0.0, b, 500, 0);  // no time
    CHECK(near(o2.attackSeconds, e.attackSeconds));
}

static void testCrossModeNodeNoMotion() {
    // A node from the OTHER mode never writes (FA2 guard): the degenerate baseline polyline
    // carries a ReleaseEnd vertex regardless of mode, so a Trigger-mode grab of it (e.g. over a
    // zero-height canvas) must NOT write releaseSeconds — and symmetrically a Trigger node is
    // inert on a Gate envelope.
    EnvClampBounds b;
    const AmpEnvelope t = triggerEnv();
    AmpEnvelope out = resolveNodeDrag(t, EnvNode::ReleaseEnd, overlayOf(wideArea()), kTotal, b, 50, 0);
    CHECK(near(out.releaseSeconds, t.releaseSeconds));
    const AmpEnvelope g = gateEnv();
    out = resolveNodeDrag(g, EnvNode::FadeInEnd, overlayOf(wideArea()), kTotal, b, 50, 0);
    CHECK(near(out.fadeInFraction, g.fadeInFraction));
    // And the zero-height baseline's ReleaseEnd is not even reported grabbable in Trigger mode.
    const Rect flat = Rect::ltrb(0, 0, 100, 0);
    const NodeHit h = nodeAtPoint(t, overlayOf(flat), kTotal, 99, 0);
    CHECK(!h.hit);
}

int main() {
    testHitGrabsDrawnHandle();
    testHitMissesOffEveryNode();
    testHitSkipsNonDraggableAnchors();
    testHitNearestNodeWinsOverDrawOrder();
    testGateDefaultsEveryNodeGrabbable();

    testGateAttackDragMovesOnlyAttack();
    testGateTimeLowerClampAtZero();
    testGateTimeUpperClampAtSliderMax();
    testGateSustainNodeBothAxes();
    testGateSustainLevelClamps01();
    testGateTimeOnlyNodeIgnoresY();
    testGateReleaseEndGrabAndDrag();
    testGateDragRoundTripTracksPixels();

    testTriggerFadeInIsFractionOfPlaySpan();
    testTriggerFadesCannotCross();
    testTriggerFadeOutMovesOppositePixelDelta();
    testTriggerZeroFadeOutGrabbableAtRightEdge();
    testTriggerLengthClampsAtMax();

    testNonDraggableNodeNoMotion();
    testDegenerateAreaNoMotion();
    testCrossModeNodeNoMotion();

    if (g_fail == 0) std::printf("envelope_edit: all tests passed\n");
    else std::printf("envelope_edit: %d FAILED\n", g_fail);
    return g_fail == 0 ? 0 : 1;
}