// Standalone tests for reasampler::vst::velocity_curve — no VST3, no REAPER, no framework. Same fast
// assert loop as the sibling pure tests. Assert the S-VIEW-9 velocity->amp transfer curve HARD:
//
//  * eval — flat y=1 default (R10-F1 Option A: EVERY velocity -> 1.0), linear ramp, curved shape
//    between points, box-clamp of an out-of-range velocity, monotonic-in-x over the whole domain.
//  * editing — addPoint keeps X-order + box-clamp; movePoint clamps an interior point between its
//    neighbours (can't cross) and box-clamps amp; endpoints are X-pinned (velocity 0 / 127) with
//    only amp mobile; deletePoint removes interior points but REFUSES the two endpoints.
//  * hit-test + inverse map — pointAtPixel grabs a drawn node; resolvePointDrag maps pixel delta to
//    a clamped point (endpoint X-pinned; interior clamped to neighbours); degenerate box -> no motion.
//  * fromPoints — the deserialization repair: sorts by X, box-clamps, forces endpoints, and falls
//    back to flat() for a sub-2-point list.

#include "../src/vst/velocity_curve.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; }

using Box = VelocityCurve::Box;

// --- eval ---------------------------------------------------------------------

static void testFlatIsUnityEverywhere() {
    const VelocityCurve c = VelocityCurve::flat();
    // R10-F1 Option A: every velocity plays at full level. Sweep the whole domain.
    for (int v = 0; v <= 127; ++v) CHECK(near(c.eval(v), 1.0));
    // Two endpoints only.
    CHECK(c.size() == 2);
}

static void testLinearRamp() {
    const VelocityCurve c = VelocityCurve::linear();
    CHECK(near(c.eval(0), 0.0));
    CHECK(near(c.eval(127), 1.0));
    // linear() is an EXACT straight line y = velocity/127: at any velocity the amp equals v/127.
    CHECK(near(c.eval(63.5), 0.5));       // the exact midpoint
    CHECK(near(c.eval(64.0), 64.0 / 127.0));
    CHECK(near(c.eval(100.0), 100.0 / 127.0));
}

static void testEvalBoxClampsOutOfRangeVelocity() {
    const VelocityCurve c = VelocityCurve::linear();
    CHECK(near(c.eval(-10.0), 0.0));    // below 0 -> reads velocity-0 endpoint amp
    CHECK(near(c.eval(200.0), 1.0));    // above 127 -> reads velocity-127 endpoint amp
}

static void testEvalMonotonicInX() {
    // A curve that dips then rises must still be a well-defined FUNCTION (one amp per velocity) and
    // monotonic WITHIN each segment. Build (0,1)->(64,0)->(127,1): eval sweeps must be single-valued
    // and each half monotonic (down then up), never oscillating within a segment.
    VelocityCurve c = VelocityCurve::flat();
    c.movePoint(0, 0, 1.0);
    c.addPoint(64.0, 0.0);
    c.movePoint(2, 127, 1.0);  // index 2 is the last endpoint after the insert
    CHECK(c.size() == 3);
    // Descending half [0,64]: non-increasing.
    double prev = c.eval(0);
    for (int v = 1; v <= 64; ++v) {
        const double cur = c.eval(v);
        CHECK(cur <= prev + 1e-9);
        prev = cur;
    }
    // Ascending half [64,127]: non-decreasing.
    prev = c.eval(64);
    for (int v = 65; v <= 127; ++v) {
        const double cur = c.eval(v);
        CHECK(cur >= prev - 1e-9);
        prev = cur;
    }
    CHECK(near(c.eval(64), 0.0));  // the trough sits exactly on the moved point
}

// --- editing: addPoint --------------------------------------------------------

static void testAddPointKeepsXOrderAndClamps() {
    VelocityCurve c = VelocityCurve::linear();  // (0,0), (127,1)
    const std::size_t i = c.addPoint(60.0, 0.3);
    CHECK(i == 1);  // inserted between the two endpoints
    CHECK(c.size() == 3);
    CHECK(near(c.points()[1].velocity, 60.0) && near(c.points()[1].amp, 0.3));
    // Out-of-box add clamps into [0,127] x [0,1].
    c.addPoint(500.0, 5.0);
    const VelocityPoint& last = c.points().back();
    CHECK(near(last.velocity, 127.0) && near(last.amp, 1.0));
    // Points remain X-ordered.
    for (std::size_t k = 1; k < c.size(); ++k)
        CHECK(c.points()[k - 1].velocity <= c.points()[k].velocity);
}

// --- editing: movePoint -------------------------------------------------------

static void testMoveInteriorClampsToNeighbours() {
    VelocityCurve c = VelocityCurve::linear();
    c.addPoint(40.0, 0.4);   // idx 1
    c.addPoint(80.0, 0.8);   // idx 2
    CHECK(c.size() == 4);    // (0,0)(40,.4)(80,.8)(127,1)
    // Try to drag idx 1 PAST idx 2 (velocity 200): clamps to idx 2's velocity (80), not beyond.
    const VelocityPoint r = c.movePoint(1, 200.0, 0.5);
    CHECK(near(r.velocity, 80.0));
    CHECK(near(r.amp, 0.5));  // amp is free (box-clamped only)
    // Try to drag idx 1 BELOW idx 0 (velocity -5): clamps to idx 0's velocity (0).
    const VelocityPoint r2 = c.movePoint(1, -5.0, 0.5);
    CHECK(near(r2.velocity, 0.0));
}

static void testMoveEndpointsArePinnedInX() {
    VelocityCurve c = VelocityCurve::linear();
    // Move the first endpoint: velocity argument ignored (pinned at 0), amp moves.
    const VelocityPoint f = c.movePoint(0, 50.0, 0.25);
    CHECK(near(f.velocity, 0.0));
    CHECK(near(f.amp, 0.25));
    // Move the last endpoint: pinned at 127, amp moves, and amp box-clamps.
    const VelocityPoint l = c.movePoint(1, 10.0, 5.0);
    CHECK(near(l.velocity, 127.0));
    CHECK(near(l.amp, 1.0));
}

static void testMoveOutOfRangeIndexIsNoOp() {
    VelocityCurve c = VelocityCurve::linear();
    c.movePoint(99, 50.0, 0.5);
    CHECK(c.size() == 2);
    CHECK(near(c.points()[0].amp, 0.0) && near(c.points()[1].amp, 1.0));  // unchanged
}

// --- editing: deletePoint -----------------------------------------------------

static void testDeleteRemovesInteriorRefusesEndpoints() {
    VelocityCurve c = VelocityCurve::linear();
    c.addPoint(60.0, 0.5);   // idx 1
    CHECK(c.size() == 3);
    // Endpoints refuse deletion.
    CHECK(!c.deletePoint(0));
    CHECK(!c.deletePoint(2));
    CHECK(c.size() == 3);
    // Interior deletes.
    CHECK(c.deletePoint(1));
    CHECK(c.size() == 2);
    // Out-of-range refuses.
    CHECK(!c.deletePoint(9));
}

// --- hit-test + inverse map ---------------------------------------------------

// A 127px-wide, 101px-tall box at origin: velocity->x is 1px/unit, amp->y spans 100 rows (1 px per
// 0.01 amp), amp 1 at top (y=0), amp 0 at bottom (y=100).
static Box wideBox() { return Box{0, 0, 127, 101}; }

static void testPointAtPixelGrabsDrawnNode() {
    VelocityCurve c = VelocityCurve::linear();  // (0,0) at (0,100); (127,1) at (127,0)
    const Box b = wideBox();
    // Grab near the first endpoint's drawn point (x=0, y=100).
    CHECK(c.pointAtPixel(b, 0, 100) == 0);
    // Grab near the last endpoint (x=127, y=0).
    CHECK(c.pointAtPixel(b, 127, 0) == 1);
    // A point far from any node misses.
    CHECK(c.pointAtPixel(b, 63, 50) == -1);
}

static void testResolveDragMovesAndClamps() {
    VelocityCurve grab = VelocityCurve::linear();
    grab.addPoint(60.0, 0.5);  // idx 1, drawn at x=60, y=50
    const Box b = wideBox();
    // Drag idx 1 right 10px, up 10px: velocity +10 (->70), amp +0.10 (up = higher amp -> 0.60).
    const VelocityCurve moved = VelocityCurve::resolvePointDrag(grab, 1, b, 10, -10);
    CHECK(near(moved.points()[1].velocity, 70.0, 1e-6));
    CHECK(near(moved.points()[1].amp, 0.60, 1e-6));
    // Dragging the first endpoint horizontally does not move it in X (pinned), only amp.
    const VelocityCurve movedEnd = VelocityCurve::resolvePointDrag(grab, 0, b, 40, -20);
    CHECK(near(movedEnd.points()[0].velocity, 0.0));
    CHECK(near(movedEnd.points()[0].amp, 0.20, 1e-6));  // dragged up 20px = +0.20 from 0
}

static void testResolveDragDegenerateBoxNoMotion() {
    const VelocityCurve grab = VelocityCurve::linear();
    const VelocityCurve r = VelocityCurve::resolvePointDrag(grab, 1, Box{0, 0, 0, 0}, 50, 50);
    CHECK(r.equals(grab));  // zero-size box -> unchanged
}

// --- fromPoints (deserialization repair) --------------------------------------

static void testFromPointsSortsClampsAndForcesEndpoints() {
    // Unsorted, out-of-box, missing endpoints -> repaired to a valid curve.
    std::vector<VelocityPoint> raw = {{80.0, 0.9}, {20.0, -1.0}, {50.0, 2.0}};
    const VelocityCurve c = VelocityCurve::fromPoints(raw);
    // X-ordered.
    for (std::size_t k = 1; k < c.size(); ++k)
        CHECK(c.points()[k - 1].velocity <= c.points()[k].velocity);
    // Endpoints forced present at 0 and 127.
    CHECK(near(c.points().front().velocity, 0.0));
    CHECK(near(c.points().back().velocity, 127.0));
    // Interior amps box-clamped (the -1 became 0, the 2 became 1).
    for (const VelocityPoint& p : c.points()) {
        CHECK(p.amp >= 0.0 - 1e-12 && p.amp <= 1.0 + 1e-12);
    }
}

static void testFromPointsSubTwoFallsBackToFlat() {
    const VelocityCurve c0 = VelocityCurve::fromPoints({});
    CHECK(c0.equals(VelocityCurve::flat()));
    const VelocityCurve c1 = VelocityCurve::fromPoints({{50.0, 0.3}});
    CHECK(c1.equals(VelocityCurve::flat()));
}

static void testFromPointsRoundTripsAValidCurve() {
    VelocityCurve orig = VelocityCurve::linear();
    orig.addPoint(40.0, 0.2);
    orig.addPoint(90.0, 0.7);
    // fromPoints over its OWN points reproduces it exactly (already valid, sort is stable no-op).
    const VelocityCurve rebuilt = VelocityCurve::fromPoints(orig.points());
    CHECK(rebuilt.equals(orig));
}

int main() {
    testFlatIsUnityEverywhere();
    testLinearRamp();
    testEvalBoxClampsOutOfRangeVelocity();
    testEvalMonotonicInX();
    testAddPointKeepsXOrderAndClamps();
    testMoveInteriorClampsToNeighbours();
    testMoveEndpointsArePinnedInX();
    testMoveOutOfRangeIndexIsNoOp();
    testDeleteRemovesInteriorRefusesEndpoints();
    testPointAtPixelGrabsDrawnNode();
    testResolveDragMovesAndClamps();
    testResolveDragDegenerateBoxNoMotion();
    testFromPointsSortsClampsAndForcesEndpoints();
    testFromPointsSubTwoFallsBackToFlat();
    testFromPointsRoundTripsAValidCurve();

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