jelq

use super::*;

#[tokio::test]

async fn meditation_is_free_but_only_once_per_floor() {

    let app = seeded_with(Floor::Bedroom, |run| run.online.meditation_taught = true);

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

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

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

    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 app = seeded_with(Floor::Bedroom, |run| {

        run.body.eq = 80;

        run.body.conditions.priapism_turns = 3;

        run.online.meditation_taught = true;

    });

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

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

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

    assert_eq!(header(&view, "x-eq"), "75");

}

#[tokio::test]

async fn priapism_holds_the_floor_through_every_reset() {

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

        run.body.warmed_up = true;

        run.body.eq = 90;

        run.here.turns = 99;

        run.body.conditions.priapism_turns = 3;

    });

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

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

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

    assert_eq!(header(&view, "x-eq"), "75");

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

        run.body.eq = 95;

        run.here.kitchen.melon_offered = true;

        run.body.conditions.priapism_turns = 2;

    });

    let bite = send(&melon, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;

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

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

    assert_eq!(header(&view, "x-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.body.warmed_up = 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_eq!(header(&hold, "x-stamina"), "10/10");

    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.warmed_up = true;

        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::ChangingRoom, |run| {

        run.body.warmed_up = true;

        run.body.eq = 10;

    });

    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_eq!(edge.status(), StatusCode::NOT_FOUND);

    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;

                run.body.warmed_up = true;

            });

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

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

                run.body.eq = eq;

                run.body.warmed_up = true;

            });

            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.body.warmed_up = true;

        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());

}