jelq

use super::*;

#[tokio::test]

async fn holding_calms_and_sometimes_reflects() {

    let mut calmed = 0;

    let mut reflected = 0;

    let mut ruptured = 0;

    for seed in 0..600u64 {

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

        run.body.eq = 75;

        match run.hold() {

            Ok(_) if run.body.eq == 0 => reflected += 1,

            Ok(_) => calmed += 1,

            Err(_) => ruptured += 1,

        }

    }

    assert!(

        (25..=80).contains(&reflected),

        "one HOLD in twelve should reflect, about 50 of 600, got {reflected} and {calmed} calm"

    );

    assert!(

        ruptured <= 7,

        "the flat 1 in 250 ruptured {ruptured} of 600 holds, about 2.4 expected"

    );

}

#[tokio::test]

async fn the_burn_shifts_the_rupture_tiers() {

    async fn ruptures(burned: bool) -> u32 {

        let mut gone = 0;

        for seed in 0..400u64 {

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

                run.body.warmed_up = true;

                run.body.eq = 60;

                run.items.lubes.baby_oil = 9;

                run.body.conditions.friction_burn = burned;

            });

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

            let jelq = send(

                &app,

                "JELQ",

                "/runs/cafebabe?technique=wet&intensity=5",

                &lube,

                "",

            )

            .await;

            if jelq.status() == StatusCode::INTERNAL_SERVER_ERROR {

                gone += 1;

            }

        }

        gone

    }

    let burned = ruptures(true).await;

    let calm = ruptures(false).await;

    assert!(

        burned >= 8 && calm <= 4,

        "burned {burned} ruptures against {calm}"

    );

}

#[tokio::test]

async fn the_top_tier_rolls_a_single_third() {

    let mut ruptures = 0;

    let mut early = 0;

    for seed in 0..400u64 {

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

            run.body.warmed_up = true;

            run.body.eq = 96;

            run.items.lubes.baby_oil = 9;

            run.items.kit.blinds = true;

        });

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

        let jelq = send(

            &app,

            "JELQ",

            "/runs/cafebabe?technique=wet&intensity=5",

            &lube,

            "",

        )

        .await;

        match jelq.status() {

            StatusCode::INTERNAL_SERVER_ERROR => ruptures += 1,

            StatusCode::TOO_EARLY => early += 1,

            other => panic!("seed {seed} ended in {other}"),

        }

    }

    assert!(

        (90..=175).contains(&ruptures),

        "ruptures {ruptures} of 400 against {early} early"

    );

    assert!(

        (225..=310).contains(&early),

        "early {early} of 400 against {ruptures} ruptures"

    );

}

#[tokio::test]

async fn holding_rolls_a_flat_rupture_chance() {

    async fn ruptures(eq: i32, stamina: i32) -> u32 {

        let mut gone = 0;

        for seed in 0..600u64 {

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

                run.body.warmed_up = true;

                run.body.eq = eq;

                run.body.stamina = stamina;

            });

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

            if held.status() == StatusCode::INTERNAL_SERVER_ERROR {

                gone += 1;

            }

        }

        gone

    }

    let high = ruptures(90, 10).await;

    let low = ruptures(30, 2).await;

    assert!((0..=7).contains(&high), "high holds ruptured {high}/600");

    assert!((0..=7).contains(&low), "low holds ruptured {low}/600");

}

#[tokio::test]

async fn the_kitchen_pays_out_at_the_documented_odds() {

    let mut oil = 0;

    let mut drinks = 0;

    let mut packs = 0;

    let mut raids = 0;

    for seed in 0..800u64 {

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

        let held = (

            run.items.lubes.coconut_oil,

            run.items.stores.energy_drinks,

            run.items.stores.ice_packs,

        );

        if run.raid_kitchen().is_err() {

            continue;

        }

        raids += 1;

        oil += u32::from(run.items.lubes.coconut_oil > held.0);

        drinks += u32::from(run.items.stores.energy_drinks > held.1);

        packs += u32::from(run.items.stores.ice_packs > held.2);

    }

    let rate = |found: u32| f64::from(found) / f64::from(raids);

    assert!(

        (0.28..=0.39).contains(&rate(oil)),

        "coconut {oil} in {raids}"

    );

    assert!(

        (0.15..=0.25).contains(&rate(drinks)),

        "energy {drinks} in {raids}"

    );

    assert!(

        (0.08..=0.17).contains(&rate(packs)),

        "ice {packs} in {raids}"

    );

}

#[tokio::test]

async fn the_kitchen_rolls_the_normal_tiers() {

    async fn ruptures(eq: i32) -> u32 {

        let mut gone = 0;

        for seed in 0..600u64 {

            let app = app_with(Floor::Bedroom, seed, |run| run.body.eq = eq);

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

            if raid.status() == StatusCode::INTERNAL_SERVER_ERROR {

                gone += 1;

            }

        }

        gone

    }

    let hot = ruptures(96).await;

    let cool = ruptures(40).await;

    assert!((40..=80).contains(&hot), "hot kitchen ruptured {hot}/600");

    assert!((0..=9).contains(&cool), "cool kitchen ruptured {cool}/600");

}

#[tokio::test]

async fn degloving_takes_one_hard_dry_stroke_in_twenty() {

    let mut degloved = 0;

    for seed in 0..1200u64 {

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

            run.here.wifi_accepted = true;

            run.body.warmed_up = true;

            run.body.eq = 55;

            run.body.foreskin = Some(1.0);

        });

        let dry = send(

            &app,

            "JELQ",

            "/runs/cafebabe?technique=dry&intensity=8",

            &[],

            "",

        )

        .await;

        if dry.status() == StatusCode::GONE

            && json(dry).await["type"]

                .as_str()

                .unwrap()

                .ends_with("degloved")

        {

            degloved += 1;

        }

    }

    assert!(

        (35..=90).contains(&degloved),

        "{degloved} degloved in 1200 hard dry strokes, about 60 expected"

    );

}

#[tokio::test]

async fn degloving_takes_one_cold_stroke_in_twenty() {

    let mut degloved = 0;

    for seed in 0..1200u64 {

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

            run.here.wifi_accepted = true;

            run.body.eq = 55;

            run.body.foreskin = Some(1.0);

        });

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

        if cold.status() != StatusCode::GONE {

            continue;

        }

        let bare = header(&cold, "x-foreskin") == "gone";

        let problem = json(cold).await;

        if problem["type"].as_str().unwrap().ends_with("degloved") {

            assert!(bare, "degloving takes the foreskin with it");

            assert_eq!(problem["foreskin"], -1.0);

            degloved += 1;

        }

    }

    assert!(

        (35..=90).contains(&degloved),

        "{degloved} degloved in 1200 cold strokes, about 60 expected"

    );

}