// Standalone tests for reasampler::vst::envelope_overlay — no VST3, no REAPER, no framework.
// Same fast assert loop as the sibling pure tests. Assert the S-VIEW-3 amp-envelope -> polyline
// FORWARD map: the Gate AHDSR shape (attack ramp / hold plateau / decay-to-sustain / plateau /
// release) and the Trigger fade/%-length shape, at the waveform time base (so the drawn curve
// lines up with the PCM under it).
//
// Covers: timeToX / levelToY (linear maps, edge clamps, release-past-end NOT clamped, degenerate
// area/duration); buildEnvelopePolyline Gate (node order, levels, cumulative time placement,
// sustain plateau to sample end, release past end, collapsed plateau when stages overrun);
// buildEnvelopePolyline Trigger (fade-in/unity/fade-out at fractions of the played span, overlap
// clamp); degenerate flat baseline.

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

#include <cstdio>
#include <vector>

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)

// A comfortable overlay area: 1000px wide, 100px tall, offset so left/top != 0 (catches origin
// bugs). Under levelToY the level span is height-1 = 99 rows.
static Rect wideArea() { return Rect{20, 10, 1020, 110}; }  // width 1000, height 100

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

// --- timeToX / levelToY -------------------------------------------------------

static void testTimeToXEndpoints() {
    const Rect a = wideArea();
    CHECK(timeToX(a, 2.0, 0.0) == a.left);          // t=0 -> left
    CHECK(timeToX(a, 2.0, 2.0) == a.right);          // t=total -> right
    CHECK(timeToX(a, 2.0, 1.0) == a.left + 500);     // midpoint
}

static void testTimeToXNegativePinsLeft() {
    const Rect a = wideArea();
    CHECK(timeToX(a, 2.0, -0.5) == a.left);          // t<0 pins left
}

static void testTimeToXPastEndNotClamped() {
    // The Gate release tail is drawn past the sample end BY DESIGN: t past total maps past right.
    const Rect a = wideArea();
    CHECK(timeToX(a, 2.0, 3.0) > a.right);           // t=1.5x total -> past the right edge
    CHECK(timeToX(a, 2.0, 3.0) == a.left + 1500);
}

static void testTimeToXDegenerate() {
    const Rect a = wideArea();
    CHECK(timeToX(a, 0.0, 1.0) == a.left);           // no duration -> left
    const Rect z = Rect{5, 5, 5, 45};                // zero width
    CHECK(timeToX(z, 2.0, 1.0) == z.left);
}

static void testLevelToYEndpoints() {
    const Rect a = wideArea();
    CHECK(levelToY(a, 1.0) == a.top);                // level 1 -> top row
    CHECK(levelToY(a, 0.0) == a.bottom - 1);         // level 0 -> bottom row
    CHECK(levelToY(a, 0.5) == a.top + 50);           // mid: round((1-0.5)*99)=round(49.5)=50
}

static void testLevelToYClamps() {
    const Rect a = wideArea();
    CHECK(levelToY(a, 2.0) == a.top);                // >1 clamps to top
    CHECK(levelToY(a, -1.0) == a.bottom - 1);        // <0 clamps to bottom
    const Rect z = Rect{5, 5, 45, 5};                // zero height
    CHECK(levelToY(z, 0.5) == z.top);
}

// --- Gate polyline ------------------------------------------------------------

static void testGateNodeOrderAndLevels() {
    AmpEnvelope env;
    env.mode = EnvMode::Gate;
    env.attackSeconds  = 0.2;
    env.holdSeconds    = 0.1;
    env.decaySeconds   = 0.3;
    env.sustainLevel   = 0.5;
    env.releaseSeconds = 0.4;
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, a, 2.0);

    // Six vertices, in draw order.
    CHECK(poly.size() == 6);
    CHECK(poly[0].node == EnvNode::Origin);
    CHECK(poly[1].node == EnvNode::AttackEnd);
    CHECK(poly[2].node == EnvNode::HoldEnd);
    CHECK(poly[3].node == EnvNode::DecayEnd);
    CHECK(poly[4].node == EnvNode::ReleaseStart);
    CHECK(poly[5].node == EnvNode::ReleaseEnd);

    // Levels: origin 0, attack/hold peak 1, decay settles to sustain, plateau holds sustain,
    // release ends at 0.
    CHECK(poly[0].level == 0.0);
    CHECK(poly[1].level == 1.0);
    CHECK(poly[2].level == 1.0);
    CHECK(poly[3].level == 0.5);   // sustain
    CHECK(poly[4].level == 0.5);   // plateau end holds sustain
    CHECK(poly[5].level == 0.0);
}

static void testGateCumulativeTimePlacement() {
    // total 2.0s over 1000px => 500 px/s. attack .2 -> x@100, hold end .3 -> x@150, decay end .6
    // -> x@300. Sustain plateau runs to the sample END (2.0 -> right). Release .4 trails past.
    AmpEnvelope env;
    env.mode = EnvMode::Gate;
    env.attackSeconds  = 0.2;
    env.holdSeconds    = 0.1;   // hold end at 0.3s
    env.decaySeconds   = 0.3;   // decay end at 0.6s
    env.sustainLevel   = 0.5;
    env.releaseSeconds = 0.4;   // release end at 2.4s (past the 2.0s end)
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, a, 2.0);

    EnvVertex v;
    CHECK(findNode(poly, EnvNode::AttackEnd, v)   && v.x == a.left + 100);
    CHECK(findNode(poly, EnvNode::HoldEnd, v)     && v.x == a.left + 150);
    CHECK(findNode(poly, EnvNode::DecayEnd, v)    && v.x == a.left + 300);
    CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.right);        // plateau to end
    CHECK(findNode(poly, EnvNode::ReleaseEnd, v)  && v.x == a.left + 1200);   // 2.4s -> 1200px past
}

static void testGatePlateauCollapsesWhenStagesOverrun() {
    // A/H/D sum to 3.0s > the 2.0s sample: the plateau collapses (ReleaseStart clamps to DecayEnd's
    // time), and the release still trails past.
    AmpEnvelope env;
    env.mode = EnvMode::Gate;
    env.attackSeconds  = 1.0;
    env.holdSeconds    = 1.0;
    env.decaySeconds   = 1.0;   // decay end at 3.0s
    env.sustainLevel   = 0.7;
    env.releaseSeconds = 0.5;
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, a, 2.0);

    EnvVertex decay, plateauEnd, rel;
    CHECK(findNode(poly, EnvNode::DecayEnd, decay));
    CHECK(findNode(poly, EnvNode::ReleaseStart, plateauEnd));
    CHECK(findNode(poly, EnvNode::ReleaseEnd, rel));
    CHECK(plateauEnd.x == decay.x);              // collapsed: plateau has zero width
    CHECK(rel.x > decay.x);                       // release trails past
    CHECK(plateauEnd.level == 0.7);               // still at sustain
}

// --- Trigger polyline ---------------------------------------------------------

static void testTriggerShape() {
    // played span = length * total = 0.5 * 2.0 = 1.0s -> 500px wide. fadeIn .2 of play -> 0.2s
    // (x@100), fade-out .3 of play -> begins at 0.7s (x@350), playEnd at 1.0s (x@500).
    AmpEnvelope env;
    env.mode = EnvMode::Trigger;
    env.lengthFraction  = 0.5;
    env.fadeInFraction  = 0.2;
    env.fadeOutFraction = 0.3;
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, a, 2.0);

    CHECK(poly.size() == 4);
    CHECK(poly[0].node == EnvNode::Origin);
    CHECK(poly[1].node == EnvNode::FadeInEnd);
    CHECK(poly[2].node == EnvNode::FadeOutStart);
    CHECK(poly[3].node == EnvNode::LengthEnd);

    EnvVertex v;
    CHECK(findNode(poly, EnvNode::FadeInEnd, v)    && v.x == a.left + 100 && v.level == 1.0);
    CHECK(findNode(poly, EnvNode::FadeOutStart, v) && v.x == a.left + 350 && v.level == 1.0);
    CHECK(findNode(poly, EnvNode::LengthEnd, v)    && v.x == a.left + 500 && v.level == 0.0);
}

static void testTriggerFadeOverlapClamp() {
    // fadeIn + fadeOut > 1: the fade-out is trimmed so they meet exactly (no crossed nodes).
    AmpEnvelope env;
    env.mode = EnvMode::Trigger;
    env.lengthFraction  = 1.0;   // played span = full 2.0s -> 1000px
    env.fadeInFraction  = 0.8;   // fade-in end at 0.8*2.0 = 1.6s -> x@800
    env.fadeOutFraction = 0.6;   // would be 1.4s -> clamped to 1-0.8=0.2 -> begins at 0.8*2.0 too
    const Rect a = wideArea();
    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, a, 2.0);

    EnvVertex fin, fout;
    CHECK(findNode(poly, EnvNode::FadeInEnd, fin));
    CHECK(findNode(poly, EnvNode::FadeOutStart, fout));
    CHECK(fin.x == fout.x);   // fades meet exactly, never cross
    CHECK(fin.x == a.left + 800);
}

// --- Degenerate ---------------------------------------------------------------

static void testDegenerateFlatBaseline() {
    AmpEnvelope env;   // any params
    const Rect zeroW = Rect{0, 0, 0, 100};
    const std::vector<EnvVertex> p1 = buildEnvelopePolyline(env, zeroW, 2.0);
    CHECK(p1.size() == 2);                       // always a drawable line
    CHECK(p1.front().level == 0.0 && p1.back().level == 0.0);

    const Rect ok = wideArea();
    const std::vector<EnvVertex> p2 = buildEnvelopePolyline(env, ok, 0.0);  // no duration
    CHECK(p2.size() == 2);
    CHECK(p2.front().level == 0.0 && p2.back().level == 0.0);
    CHECK(p2.front().x == ok.left && p2.back().x == ok.right);   // spans the whole area flat
}

int main() {
    testTimeToXEndpoints();
    testTimeToXNegativePinsLeft();
    testTimeToXPastEndNotClamped();
    testTimeToXDegenerate();
    testLevelToYEndpoints();
    testLevelToYClamps();

    testGateNodeOrderAndLevels();
    testGateCumulativeTimePlacement();
    testGatePlateauCollapsesWhenStagesOverrun();

    testTriggerShape();
    testTriggerFadeOverlapClamp();

    testDegenerateFlatBaseline();

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