// Standalone tests for reasampler::vst::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; first-match determinism); resolveNodeDrag Gate
// (each cumulative node edits its OWN segment; X->time, sustain node's Y->level; lower clamp at 0;
// upper clamp at the caller's max; only the dragged param changes); 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); degenerate area/duration + non-draggable node ->
// no motion.

#include "../src/vst/envelope_edit.h"

#include <cmath>
#include <cstdio>

using namespace reasampler::vst;

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; }

// 1000px wide, 100px tall, offset origin. 2.0s total => 500 px/s => 0.002 s/px.
static Rect wideArea() { return Rect{20, 10, 1020, 110}; }
static constexpr double kTotal = 2.0;

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+100 (0.2s), y = top (level 1). A grab there hits it.
    NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 100, a.top);
    CHECK(h.hit && h.node == EnvNode::AttackEnd);
    // The sustain node (DecayEnd) at 0.6s -> left+300, level 0.5 -> ~top+50.
    NodeHit s = nodeAtPoint(e, a, kTotal, a.left + 300, a.top + 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 (mid plateau, well away from a node).
    NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 700, a.top + 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, a, kTotal, a.left, a.bottom - 1);
    CHECK(!o.hit);
    // ReleaseStart draws at (right, sustain level). It is drawing-only -> not grabbable. But
    // ReleaseEnd is elsewhere, so a grab exactly at ReleaseStart's point must miss.
    // ReleaseStart x == right (plateau to sample end), y == sustain (~top+50).
    NodeHit rs = nodeAtPoint(e, a, kTotal, a.right, a.top + 50);
    CHECK(!rs.hit);
}

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

static void testGateAttackDragMovesOnlyAttack() {
    const AmpEnvelope e = gateEnv();
    const Rect a = wideArea();
    EnvClampBounds b;  // default maxima 4.0s
    // +50px at 0.002 s/px = +0.1s on attack (0.2 -> 0.3). Nothing else moves.
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, a, kTotal, b, 50, 0);
    CHECK(near(out.attackSeconds, 0.3));
    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 = -1.0s) from 0.2s: clamps to 0, never negative (monotonic:
    // the segment cannot go below zero).
    AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, 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 = +4.0s) 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, 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 = +0.2s decay (0.3 -> 0.5); +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, a, kTotal, b, 100, 10);
    CHECK(near(out.decaySeconds, 0.5));
    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, 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, 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, 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
}

// --- 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, 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, 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, a, kTotal, b, -50, 0);
    CHECK(near(out.fadeOutFraction, 0.3));
    CHECK(near(out.fadeInFraction, e.fadeInFraction));
}

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, a, kTotal, b, 2000, 0);
    CHECK(near(out.lengthFraction, 1.0));
    // Drag far LEFT clamps to 0.
    AmpEnvelope lo = resolveNodeDrag(e, EnvNode::LengthEnd, 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, a, kTotal, b, 500, 500);
    CHECK(near(o.attackSeconds, e.attackSeconds) && near(o.sustainLevel, e.sustainLevel));
    AmpEnvelope rs = resolveNodeDrag(e, EnvNode::ReleaseStart, a, kTotal, b, 500, 500);
    CHECK(near(rs.releaseSeconds, e.releaseSeconds));
}

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

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

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

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

    testNonDraggableNodeNoMotion();
    testDegenerateAreaNoMotion();

    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;
}