jelq

use super::*;

#[tokio::test]

async fn meditation_is_free_but_only_once_per_floor() {

    let held = harness(Floor::Bedroom, SEED, |run| {

        run.online.meditation_taught = true;

        run.standing.suspicion = 3;

    });

    let app = &held.app;

    let response = send(app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;

    assert_eq!(response.status(), StatusCode::OK);

    assert_eq!(header(&response, "x-eq"), "Cold");

    assert_eq!(held.eq(), 10);

    assert_eq!(header(&response, "x-suspicion"), "1/5");

    assert_eq!(header(&response, "x-stamina"), "10/10");

    let again = send(app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;

    assert_eq!(again.status(), StatusCode::CONFLICT);

}

#[tokio::test]

async fn meditation_respects_the_priapism_floor() {

    let held = harness(Floor::Bedroom, SEED, |run| {

        run.body.eq = 80;

        run.body.conditions.priapism_turns = 3;

        run.online.meditation_taught = true;

    });

    let calmed = send(

        &held.app,

        "JELQ",

        "/runs/cafebabe?technique=meditate",

        &[],

        "",

    )

    .await;

    assert_eq!(calmed.status(), StatusCode::OK);

    assert_eq!(header(&calmed, "x-eq"), "Priapic");

    assert_eq!(held.eq(), 75);

}

#[tokio::test]

async fn priapism_holds_the_floor_through_every_reset() {

    let exit = harness(Floor::Bedroom, SEED, |run| {

        run.body.eq = 90;

        run.here.turns = 99;

        run.body.conditions.priapism_turns = 3;

    });

    let out = send(&exit.app, "POST", "/runs/cafebabe/floor", &[], "").await;

    assert_eq!(out.status(), StatusCode::SEE_OTHER);

    assert_eq!(exit.eq(), 75);

    let melon = harness(Floor::Bedroom, SEED, |run| {

        run.body.eq = 95;

        run.here.kitchen.melon_offered = true;

        run.body.conditions.priapism_turns = 2;

    });

    let bite = send(

        &melon.app,

        "POST",

        "/runs/cafebabe/kitchen/watermelon",

        &[],

        "",

    )

    .await;

    assert_eq!(bite.status(), StatusCode::OK);

    assert_eq!(melon.eq(), 75);

}

#[tokio::test]

async fn the_towel_warms_once_until_the_kettle_boils() {

    let app = seeded_with(Floor::Bedroom, |_| {});

    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    assert_eq!(warm.status(), StatusCode::OK);

    let again = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    assert_eq!(again.status(), StatusCode::CONFLICT);

    let app = seeded_with(Floor::Bedroom, |run| {

        run.here.towel_warmed = true;

        run.here.kitchen.kettle_boiled = true;

    });

    let reheated = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    assert_eq!(reheated.status(), StatusCode::OK);

    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    assert_eq!(cold.status(), StatusCode::CONFLICT);

}

#[tokio::test]

async fn the_refractory_period_is_the_next_hold() {

    let app = seeded_with(Floor::Hotel, |run| {

        run.here.wifi_accepted = true;

        run.here.towel_warmed = true;

        run.body.eq = 60;

        run.body.stamina = 0;

        run.body.exhausted = true;

    });

    let tired = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;

    assert_eq!(tired.status(), StatusCode::TOO_MANY_REQUESTS);

    let hold = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;

    assert_eq!(hold.status(), StatusCode::OK);

    assert!(["4/10", "5/10", "6/10", "10/10"].contains(&header(&hold, "x-stamina")));

    let towel = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    assert_eq!(towel.status(), StatusCode::CONFLICT, "the towel stays cold");

}

#[tokio::test]

async fn a_refused_jelq_does_not_break_the_edging_streak() {

    let app = seeded_with(Floor::ChangingRoom, |run| {

        run.body.eq = 45;

        run.here.edges = 2;

    });

    let refused = send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=dry",

        &[("content-type", "application/baby-oil")],

        "",

    )

    .await;

    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);

    let third = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;

    assert_eq!(third.status(), StatusCode::LOOP_DETECTED);

}

#[tokio::test]

async fn an_interrupted_edge_keeps_no_gains() {

    let app = seeded_with(Floor::Hotel, |run| {

        run.here.wifi_accepted = true;

        run.body.eq = 100;

    });

    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    let girth = header(&before, "x-girth").to_owned();

    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;

    assert!(!edge.status().is_success());

    assert_eq!(header(&edge, "x-girth"), girth);

}

#[tokio::test]

async fn greed_multiplies_gains_above_the_band() {

    let lube = [("content-type", "application/baby-oil")];

    for (eq, greed) in [(75, 1.5), (88, 2.0)] {

        let mut compared = false;

        for seed in 0..120u64 {

            let app = app_with(Floor::Bedroom, seed, |run| {

                run.body.eq = 60;

            });

            let in_band = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

            let app = app_with(Floor::Bedroom, seed, |run| {

                run.body.eq = eq;

            });

            let greedy = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

            if in_band.status() != StatusCode::OK || greedy.status() != StatusCode::OK {

                continue;

            }

            let steady = json(in_band).await["length"].as_f64().unwrap();

            let eager = json(greedy).await["length"].as_f64().unwrap();

            assert!(

                (eager - steady * greed).abs() < 1e-9,

                "seed {seed} gained {eager} at {eq} EQ against {steady} inside the band"

            );

            compared = true;

            break;

        }

        assert!(compared, "no seed produced two clean rolls at {eq} EQ");

    }

}

#[tokio::test]

async fn queued_gains_arrive_on_their_turn() {

    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);

    run.body.eq = 75;

    let before = run.body.length;

    run.body.pending.push(crate::game::Pending {

        due: run.turn + 1,

        length: 0.5,

        girth: 0.0,

        foreskin: 0.0,

    });

    assert!(run.hold().is_ok());

    assert!((run.body.length - before - 0.5).abs() < 1e-9);

    assert!(run.body.pending.is_empty());

}

#[tokio::test]

async fn hold_keeps_the_shop_and_the_melon_open() {

    let hotel = seeded_with(Floor::Hotel, |run| {

        run.here.wifi_accepted = true;

        run.body.eq = 80;

    });

    send(&hotel, "GET", "/runs/cafebabe/shop", &[], "").await;

    let held = send(&hotel, "HOLD", "/runs/cafebabe", &[], "").await;

    assert!(linked_rels(&held).contains(&"shop-item".to_owned()));

    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);

    run.body.eq = 80;

    run.here.kitchen.melon_offered = true;

    assert!(run.hold().is_ok());

    assert!(run.here.kitchen.melon_offered, "the offer survives a HOLD");

}

#[tokio::test]

async fn leaving_the_band_warms_the_next_floor() {

    let app = seeded_with(Floor::Bedroom, |run| {

        run.body.eq = 60;

        run.here.turns = 6;

        run.items.lubes.baby_oil = 9;

    });

    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;

    assert_eq!(left.status(), StatusCode::SEE_OTHER);

    let detail = json(left).await["detail"].as_str().unwrap().to_owned();

    assert!(detail.contains("the warmth came with you"));

    let lube = [("content-type", "application/baby-oil")];

    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;

    // The shower is a +35 warm-up, so EQ lands in the band and the band bonus rides along.

    // The arrival bonus is the one point the second jelq loses.

    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

    assert!(

        header(&first, "server-timing").contains("d20+4"),

        "the first jelq of a warm arrival rolls with +1, got {}",

        header(&first, "server-timing")

    );

    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;

    assert!(header(&second, "server-timing").contains("d20+3"));

}

#[tokio::test]

async fn energy_drinks_add_three_stamina() {

    let app = seeded_with(Floor::Bedroom, |run| {

        run.body.stamina = 2;

        run.items.stores.energy_drinks = 1;

    });

    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    assert!(header(&view, "link").contains("technique=energy"));

    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;

    assert_eq!(drink.status(), StatusCode::OK);

    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    assert_eq!(header(&view, "x-stamina"), "5/10");

    let again = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;

    assert_eq!(again.status(), StatusCode::FAILED_DEPENDENCY);

}

#[tokio::test]

async fn queued_gains_announce_their_arrival() {

    let app = seeded_with(Floor::Bedroom, |run| {

        run.body.eq = 75;

        run.body.foreskin = Some(1.0);

        run.body.pending.push(crate::game::Pending {

            due: run.turn + 1,

            length: 0.105,

            girth: 0.0,

            foreskin: 0.03,

        });

    });

    let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;

    assert_eq!(

        header(&held, "x-gains-arrived"),

        "length=0.105, girth=0.000, foreskin=0.030"

    );

    assert!(

        warnings(&held)

            .iter()

            .any(|w| w.contains("the queued gains have arrived"))

    );

    let later = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    assert!(later.headers().get("x-gains-arrived").is_none());

}

#[tokio::test]

async fn an_energy_drink_ends_exhaustion_without_the_refractory_period() {

    let app = seeded_with(Floor::Bedroom, |run| {

        run.body.eq = 60;

        run.body.stamina = 0;

        run.body.exhausted = true;

        run.items.stores.energy_drinks = 1;

    });

    let tired = send(&app, "GET", "/runs/cafebabe", &[], "").await;

    assert_eq!(advertised(&tired), ["energy"]);

    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;

    assert_eq!(drink.status(), StatusCode::OK);

    assert_eq!(header(&drink, "x-stamina"), "3/10");

    assert_eq!(

        header(&drink, "x-eq"),

        "Ideal",

        "still warm, unlike the refractory HOLD"

    );

    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;

    assert_ne!(jelq.status(), StatusCode::TOO_MANY_REQUESTS);

}

#[tokio::test]

async fn edging_climbs_out_of_the_cold() {

    let app = seeded_with(Floor::ChangingRoom, |run| run.body.eq = 20);

    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;

    assert_eq!(edge.status(), StatusCode::OK);

    assert!(warnings(&edge).iter().all(|w| !w.contains("Cold start")));

    assert_eq!(

        header(&edge, "x-friction"),

        "2/10",

        "edging pays no cold tax"

    );

}

#[tokio::test]

async fn overstaying_a_floor_is_warned_then_punished() {

    let mut busted = 0;

    let mut moved = 0;

    for seed in 0..60u64 {

        let held = harness(Floor::ChangingRoom, seed, |run| {

            run.body.eq = 80;

            run.body.conditions.priapism_turns = 9;

            run.here.turns = 7;

        });

        let app = &held.app;

        let eighth = send(app, "HOLD", "/runs/cafebabe", &[], "").await;

        assert!(

            warnings(&eighth)

                .iter()

                .any(|w| w.contains("The gym closes"))

        );

        let ninth = send(app, "HOLD", "/runs/cafebabe", &[], "").await;

        assert!(warnings(&ninth).iter().any(|w| w.contains("last turn")));

        let tenth = send(app, "HOLD", "/runs/cafebabe", &[], "").await;

        match tenth.status() {

            StatusCode::GONE => busted += 1,

            StatusCode::REQUEST_TIMEOUT => {

                assert_eq!(header(&tenth, "x-floor"), "4");

                assert_eq!(held.eq(), 75, "priapism holds the deflation at 75");

                moved += 1;

            }

            other => panic!("seed {seed} overstayed into {other}"),

        }

    }

    assert!(

        busted > 15 && moved > 15,

        "{busted} busted, {moved} moved along"

    );

}

#[tokio::test]

async fn friction_at_the_limit_tears_the_foreskin() {

    let app = seeded_with(Floor::ChangingRoom, |run| {

        run.body.eq = 60;

        run.body.friction = 10;

        run.body.foreskin = Some(1.0);

    });

    let raw = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;

    assert!(warnings(&raw).iter().any(|w| w.contains("giving way")));

    let left: f64 = header(&raw, "x-foreskin").parse().unwrap();

    assert!(left < 1.0, "the foreskin is down to {left}");

    let thin = seeded_with(Floor::ChangingRoom, |run| {

        run.body.eq = 60;

        run.body.friction = 10;

        run.body.foreskin = Some(0.05);

    });

    let gone = send(&thin, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;

    assert_eq!(gone.status(), StatusCode::GONE);

    assert_eq!(header(&gone, "x-foreskin"), "gone");

    assert_eq!(json(gone).await["foreskin"], -0.05);

}

#[tokio::test]

async fn ice_treats_a_burn_even_through_priapism() {

    let held = harness(Floor::ChangingRoom, SEED, |run| {

        run.body.eq = 80;

        run.body.conditions.priapism_turns = 3;

        run.body.conditions.friction_burn = true;

        run.body.friction = 9;

        run.items.stores.ice_packs = 1;

    });

    let iced = send(&held.app, "JELQ", "/runs/cafebabe?technique=ice", &[], "").await;

    assert_eq!(held.eq(), 80);

    assert_eq!(header(&iced, "x-friction"), "6/10");

    assert!(warnings(&iced).iter().all(|w| !w.contains("friction burn")));

}

#[tokio::test]

async fn leaving_a_floor_delivers_every_queued_gain() {

    let app = seeded_with(Floor::ChangingRoom, |run| {

        run.here.turns = 6;

        run.body.pending.push(crate::game::Pending {

            due: run.turn + 4,

            length: 0.2,

            girth: 0.1,

            foreskin: 0.0,

        });

    });

    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;

    assert_eq!(left.status(), StatusCode::SEE_OTHER);

    assert_eq!(

        header(&left, "x-gains-arrived"),

        "length=0.200, girth=0.100"

    );

}

#[tokio::test]

async fn an_overstayed_jelq_spends_no_lube() {

    let app = seeded_with(Floor::ChangingRoom, |run| {

        run.body.eq = 60;

        run.here.turns = 9;

        run.items.lubes.baby_oil = 1;

    });

    let late = send(

        &app,

        "JELQ",

        "/runs/cafebabe?technique=wet",

        &[("content-type", "application/baby-oil")],

        "",

    )

    .await;

    assert!([StatusCode::GONE, StatusCode::REQUEST_TIMEOUT].contains(&late.status()));

    if late.status() == StatusCode::REQUEST_TIMEOUT {

        let held = json(send(&app, "GET", "/runs/cafebabe/inventory", &[], "").await).await;

        assert!(

            held["items"]

                .as_array()

                .unwrap()

                .iter()

                .any(|i| i["name"] == "baby-oil")

        );

    }

}

#[tokio::test]

async fn the_refractory_period_gives_back_some_stamina_and_rarely_all() {

    let mut full = 0;

    for seed in 0..400u64 {

        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);

        run.floor = Floor::ChangingRoom;

        run.body.stamina = 0;

        run.body.exhausted = true;

        if run.hold().is_err() {

            continue;

        }

        match run.body.stamina {

            4..=6 => {}

            10 => full += 1,

            other => panic!("seed {seed} recovered {other} stamina"),

        }

    }

    assert!((8..=35).contains(&full), "{full} second winds in 400");