jelq

public
an http based roguelike rpg about jelqing
Star0
Watch0
1 commit 1 branch 0 tags 0 releases1.3 MiB
use std::time::{Duration, Instant};

use axum::{
    Json,
    body::Body,
    http::{HeaderName, HeaderValue, StatusCode, header},
    response::{IntoResponse, Response},
};
use rand::{Rng, SeedableRng, rngs::StdRng};
use serde::Deserialize;
use serde_json::{Value, json};

use crate::problem::Problem;

pub const MAX_STAMINA: i32 = 10;
pub const SUSPICION_LIMIT: u8 = 5;
pub const BRANCH_TURN: u32 = 10;
pub const APPOINTMENT_TURN: u32 = 20;
pub const REFRACTORY: Duration = Duration::from_secs(30);
pub const SELF_REPORT_INFLATION: f64 = 1.5;
pub const MM_PER_INCH: f64 = 25.4;
pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];
pub const LUBRICANTS: [&str; 5] = [
    "application/baby-oil",
    "application/coconut-oil",
    "application/lotion",
    "application/vaseline",
    "text/plain; charset=spit",
];
pub const INTAKE: [&str; 3] = [
    "The clinic does not accept excuses.",
    "The clinic accepts one token. You have not been carrying it.",
    "Be honest.",
];

pub const SERVER_TIMING: HeaderName = HeaderName::from_static("server-timing");
pub const X_DIAGNOSIS: HeaderName = HeaderName::from_static("x-diagnosis");

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Lube {
    BabyOil,
    CoconutOil,
    Lotion,
    Vaseline,
    Spit,
}

impl Lube {
    pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {
        let Some(raw) = content_type else {
            return Ok(None);
        };
        let lowered = raw.to_ascii_lowercase();
        let mut parts = lowered.split(';').map(str::trim);
        let essence = parts.next().unwrap_or_default();
        let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");
        match essence {
            "application/baby-oil" => Ok(Some(Self::BabyOil)),
            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),
            "application/lotion" => Ok(Some(Self::Lotion)),
            "application/vaseline" => Ok(Some(Self::Vaseline)),
            "text/plain" if spit => Ok(Some(Self::Spit)),
            e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(
                StatusCode::UNSUPPORTED_MEDIA_TYPE,
                "no",
                "No.",
            )),
            _ => Err(Problem::new(
                StatusCode::UNSUPPORTED_MEDIA_TYPE,
                "unsupported-lubricant",
                format!("{essence} is not a lubricant."),
            )
            .with("lubricants", json!(LUBRICANTS))),
        }
    }

    fn modifier(self) -> i32 {
        match self {
            Self::BabyOil => 1,
            Self::CoconutOil => 3,
            Self::Lotion => 0,
            Self::Vaseline => 2,
            Self::Spit => -2,
        }
    }
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Technique {
    Warmup,
    Ice,
    Wet,
    Dry,
    Stretch,
    Uli,
}

#[derive(Clone, Copy)]
enum LubeRule {
    Required,
    Forbidden,
    Optional,
}

struct Profile {
    dc: i32,
    length: f64,
    girth: f64,
    foreskin: Option<(f64, f64)>,
    foreskin_growth: f64,
    lube: LubeRule,
}

impl Technique {
    pub const ALL: [Self; 6] = [
        Self::Warmup,
        Self::Ice,
        Self::Wet,
        Self::Dry,
        Self::Stretch,
        Self::Uli,
    ];

    pub fn name(self) -> &'static str {
        match self {
            Self::Warmup => "warmup",
            Self::Ice => "ice",
            Self::Wet => "wet",
            Self::Dry => "dry",
            Self::Stretch => "stretch",
            Self::Uli => "uli",
        }
    }

    pub fn parse(name: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|t| t.name() == name)
    }

    fn profile(self) -> Option<Profile> {
        let profile = match self {
            Self::Warmup | Self::Ice => return None,
            Self::Wet => Profile {
                dc: 10,
                length: 0.010,
                girth: 0.005,
                foreskin: None,
                foreskin_growth: 0.0,
                lube: LubeRule::Required,
            },
            Self::Dry => Profile {
                dc: 12,
                length: 0.008,
                girth: 0.003,
                foreskin: Some((0.8, 2.0)),
                foreskin_growth: 0.01,
                lube: LubeRule::Forbidden,
            },
            Self::Stretch => Profile {
                dc: 11,
                length: 0.015,
                girth: 0.0,
                foreskin: Some((0.0, 1.8)),
                foreskin_growth: 0.03,
                lube: LubeRule::Optional,
            },
            Self::Uli => Profile {
                dc: 15,
                length: 0.002,
                girth: 0.020,
                foreskin: None,
                foreskin_growth: 0.0,
                lube: LubeRule::Optional,
            },
        };
        Some(profile)
    }

    pub fn describe(self, forum_read: bool) -> Value {
        let Some(p) = self.profile() else {
            let effect = match self {
                Self::Warmup => "EQ +25. Satisfies the warm-up precondition.",
                _ => "EQ -40. Consumes an ice pack.",
            };
            return json!({ "name": self.name(), "effect": effect });
        };
        let lubricant = match p.lube {
            LubeRule::Required => "required",
            LubeRule::Forbidden => "forbidden",
            LubeRule::Optional => "optional",
        };
        let foreskin = p
            .foreskin
            .map(|(min, max)| json!({ "min": min, "max": max }));
        json!({
            "name": self.name(),
            "dc": p.dc,
            "lubricant": lubricant,
            "foreskin": foreskin,
            "locked": self == Self::Uli && !forum_read,
        })
    }
}

pub struct Outcome {
    status: StatusCode,
    body: Option<Value>,
    headers: Vec<(HeaderName, String)>,
}

impl Outcome {
    pub fn new(status: StatusCode, body: Option<Value>) -> Self {
        Self {
            status,
            body,
            headers: Vec::new(),
        }
    }

    pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {
        self.headers.push((name, value.into()));
        self
    }
}

impl IntoResponse for Outcome {
    fn into_response(self) -> Response {
        let mut response = match self.body {
            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.
            Some(body) if self.status == StatusCode::PARTIAL_CONTENT => {
                let full = body.to_string().into_bytes();
                let half = full.len() / 2;
                let range = format!("bytes 0-{}/{}", half - 1, full.len());
                (
                    self.status,
                    [
                        (header::CONTENT_TYPE, "application/json".to_owned()),
                        (header::CONTENT_RANGE, range),
                    ],
                    Body::from(full[..half].to_vec()),
                )
                    .into_response()
            }
            Some(body) => (self.status, Json(body)).into_response(),
            None => self.status.into_response(),
        };
        for (name, value) in self.headers {
            let value = HeaderValue::from_str(&value).expect("header values are visible ascii");
            response.headers_mut().append(name, value);
        }
        response
    }
}

#[derive(Deserialize)]
pub struct PatchOp {
    pub op: String,
    pub path: String,
    #[serde(default)]
    pub value: Value,
}

pub struct Pending {
    due: u32,
    length: f64,
    girth: f64,
}

pub struct Ending {
    pub cause: &'static str,
    pub detail: String,
    pub turn: u32,
}

pub struct Run {
    pub id: String,
    pub origin_etag: String,
    pub version: u64,
    pub turn: u32,
    pub length: f64,
    pub girth: f64,
    pub foreskin: Option<f64>,
    pub eq: i32,
    pub stamina: i32,
    pub suspicion: u8,
    pub shame_base: u32,
    pub shame: u32,
    pub ice_packs: u32,
    pub warmed_up: bool,
    pub teapot: bool,
    pub ruler: bool,
    pub put_applied: bool,
    pub forum_read: bool,
    pub branch_pending: bool,
    pub mom_present: bool,
    pub observed: bool,
    pub measured: bool,
    pub cured: bool,
    pub intake_attempts: usize,
    pub refractory_until: Option<Instant>,
    pub pending: Vec<Pending>,
    pub ended: Option<Ending>,
    rng: StdRng,
}

fn round2(x: f64) -> f64 {
    (x * 100.0).round() / 100.0
}

fn round3(x: f64) -> f64 {
    (x * 1000.0).round() / 1000.0
}

fn tenths(x: f64) -> i64 {
    (x * 10.0).round() as i64
}

fn not_extended() -> Problem {
    Problem::new(
        StatusCode::NOT_EXTENDED,
        "not-extended",
        "The requested extension was not applied. The server has recorded the attempt.",
    )
}

pub fn parse_credentials<'a>(authorization: &'a str, scheme: &str) -> Option<&'a str> {
    let (given, rest) = authorization.trim().split_once(' ')?;
    given
        .eq_ignore_ascii_case(scheme)
        .then(|| rest.trim().trim_matches('"'))
}

impl Run {
    pub fn new(id: String, seed: u64, shame_base: u32) -> Self {
        let mut rng = StdRng::seed_from_u64(seed);
        let length = round2(rng.random_range(4.5..6.5));
        let girth = round2(rng.random_range(4.0..5.0));
        let foreskin = round2(rng.random_range(0.4..2.4));
        let mut run = Self {
            id,
            origin_etag: String::new(),
            version: 0,
            turn: 0,
            length,
            girth,
            foreskin: Some(foreskin),
            eq: 20,
            stamina: MAX_STAMINA,
            suspicion: 0,
            shame_base,
            shame: 0,
            ice_packs: 1,
            warmed_up: false,
            teapot: false,
            ruler: false,
            put_applied: false,
            forum_read: false,
            branch_pending: false,
            mom_present: false,
            observed: false,
            measured: false,
            cured: false,
            intake_attempts: 0,
            refractory_until: None,
            pending: Vec::new(),
            ended: None,
            rng,
        };
        run.origin_etag = run.etag();
        run
    }

    pub fn etag(&self) -> String {
        format!("\"{}-{}\"", self.id, self.version)
    }

    pub fn touch(&mut self) {
        self.version += 1;
    }

    pub fn self_reported(&self) -> f64 {
        self.length + SELF_REPORT_INFLATION
    }

    pub fn total_shame(&self) -> u32 {
        self.shame_base + self.shame
    }

    pub fn status(&self) -> &'static str {
        match (&self.ended, self.cured) {
            (Some(_), _) => "gone",
            (None, true) => "normal",
            (None, false) => "alive",
        }
    }

    pub fn view(&self) -> Value {
        let mut view = json!({
            "id": self.id,
            "status": self.status(),
            "turn": self.turn,
            "floor": 1,
            "self_reported_length": round2(self.self_reported()),
            "girth": round2(self.girth),
            "foreskin": self.foreskin.map(round2),
            "eq": self.eq,
            "stamina": self.stamina,
            "suspicion": self.suspicion,
            "shame": self.total_shame(),
            "warmed_up": self.warmed_up,
        });
        if self.ruler {
            view["length"] = json!(round2(self.length));
        }
        if self.teapot {
            view["condition"] = json!("short and stout");
        }
        view
    }

    pub fn end(&mut self, cause: &'static str, detail: &str) {
        self.ended = Some(Ending {
            cause,
            detail: detail.into(),
            turn: self.turn,
        });
    }

    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {
        let challenge =
            |p: Problem| p.header(header::WWW_AUTHENTICATE, "Excuse realm=\"household\"");
        let Some(authorization) = authorization else {
            return Err(challenge(
                Problem::new(
                    StatusCode::UNAUTHORIZED,
                    "someone-at-the-door",
                    "Someone is at the door.",
                )
                .with("inventory", format!("/runs/{}/inventory", self.id)),
            ));
        };
        let excuse = parse_credentials(authorization, "excuse");
        if excuse.is_some_and(|e| EXCUSES.iter().any(|known| known.eq_ignore_ascii_case(e))) {
            self.mom_present = false;
            self.suspicion = 0;
            self.touch();
            return Ok(());
        }
        self.shame += 3;
        self.touch();
        Err(challenge(Problem::new(
            StatusCode::UNAUTHORIZED,
            "excuse-rejected",
            "Mom has not heard that one before. She does not believe it.",
        )))
    }

    fn check_refractory(&mut self, now: Instant) -> Result<(), Problem> {
        let Some(until) = self.refractory_until else {
            return Ok(());
        };
        if now < until {
            let seconds = (until - now).as_secs() + 1;
            return Err(Problem::new(
                StatusCode::TOO_MANY_REQUESTS,
                "overtrained",
                "Stamina is exhausted. The refractory period is in effect.",
            )
            .header(header::RETRY_AFTER, seconds.to_string()));
        }
        self.refractory_until = None;
        self.stamina = MAX_STAMINA;
        self.eq = 20;
        self.warmed_up = false;
        self.touch();
        Ok(())
    }

    fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {
        let Some(f) = self.foreskin else {
            if min <= 0.0 {
                return Ok(());
            }
            return Err(Problem::new(
                StatusCode::GONE,
                "foreskin-gone",
                "This technique requires a foreskin. The foreskin is gone.",
            )
            .header(
                header::CONTENT_LOCATION,
                format!("/runs/{}/foreskin", self.id),
            ));
        };
        if f < min {
            return Err(Problem::new(
                StatusCode::LENGTH_REQUIRED,
                "foreskin-insufficient",
                format!(
                    "The selected technique requires {min:.1} units of foreskin. {f:.2} units are available. The server has noted the shortfall."
                ),
            )
            .with("required", min)
            .with("available", round2(f)));
        }
        if f > max {
            return Err(Problem::new(
                StatusCode::PAYLOAD_TOO_LARGE,
                "foreskin-excessive",
                format!(
                    "The selected technique tolerates at most {max:.1} units of foreskin. {f:.2} units are present."
                ),
            )
            .with("maximum", max)
            .with("present", round2(f)));
        }
        Ok(())
    }

    fn realize(&mut self) {
        let (due, waiting): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pending)
            .into_iter()
            .partition(|p| p.due <= self.turn);
        self.pending = waiting;
        for p in due {
            self.length += p.length;
            self.girth += p.girth;
        }
    }

    fn gain(&mut self, length: f64, girth: f64, foreskin: f64) {
        self.length += length;
        self.girth += girth;
        if let Some(f) = &mut self.foreskin {
            *f += foreskin;
        }
    }

    fn rupture(&mut self) -> Problem {
        let detail = if self.ice_packs > 0 {
            "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."
        } else {
            "A vessel has exceeded its rated pressure. The run has ended."
        };
        self.end("vascular-event", detail);
        Problem::new(StatusCode::INTERNAL_SERVER_ERROR, "vascular-event", detail)
            .with("eq_at_failure", self.eq)
            .with("turn", self.turn)
    }

    pub fn jelq(
        &mut self,
        technique: Technique,
        intensity: i32,
        lube: Option<Lube>,
        now: Instant,
    ) -> Result<Outcome, Problem> {
        self.check_refractory(now)?;
        if self.branch_pending {
            return Ok(self.branch_offer());
        }
        let Some(profile) = technique.profile() else {
            return self.utility(technique);
        };
        if technique == Technique::Uli && !self.forum_read {
            return Err(Problem::new(
                StatusCode::FORBIDDEN,
                "technique-locked",
                "This technique is discussed on the forum. You have not been to the forum.",
            ));
        }
        if !self.warmed_up {
            return Err(Problem::new(
                StatusCode::PRECONDITION_FAILED,
                "cold-start",
                "Warm-up was skipped. The server has noted this.",
            )
            .with("technique", Technique::Warmup.name()));
        }
        match (profile.lube, lube) {
            (LubeRule::Required, None) => {
                return Err(Problem::new(
                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
                    "lubricant-required",
                    format!(
                        "The {} technique requires a lubricant. None was declared.",
                        technique.name()
                    ),
                )
                .with("lubricants", json!(LUBRICANTS)));
            }
            (LubeRule::Forbidden, Some(_)) => {
                return Err(Problem::new(
                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
                    "lubricant-declared",
                    "The dry technique was requested. A lubricant was declared.",
                ));
            }
            _ => {}
        }
        if let Some((min, max)) = profile.foreskin {
            self.check_foreskin(min, max)?;
        }

        self.touch();
        self.turn += 1;
        self.realize();
        self.stamina -= 1 + i32::from(lube == Some(Lube::Lotion));
        if self.stamina <= 0 {
            self.stamina = 0;
            self.refractory_until = Some(now + REFRACTORY);
        }
        self.eq = (self.eq + intensity * 2 - 6).clamp(0, 100);
        let suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));
        self.suspicion = (self.suspicion + suspicion as u8).min(SUSPICION_LIMIT);
        if self.suspicion == SUSPICION_LIMIT {
            self.mom_present = true;
        }
        if self.rng.random_ratio(1, 6) {
            self.observed = true;
            self.shame += 1;
        }
        if self.turn == BRANCH_TURN {
            self.branch_pending = true;
        }

        if self.eq > 95 {
            self.eq = 0;
            self.warmed_up = false;
            self.shame += 5;
            return Err(Problem::new(
                StatusCode::TOO_EARLY,
                "premature",
                "The floor has ended early. Everyone involved has agreed not to discuss it.",
            ));
        }
        if self.eq < 30 {
            return Err(Problem::new(
                StatusCode::NOT_FOUND,
                "cold",
                "The resource exists. It is cold.",
            )
            .with("eq", self.eq));
        }
        self.roll(technique, &profile, intensity, lube)
    }

    fn roll(
        &mut self,
        technique: Technique,
        profile: &Profile,
        intensity: i32,
        lube: Option<Lube>,
    ) -> Result<Outcome, Problem> {
        let natural: i32 = self.rng.random_range(1..=20);
        let band = if (50..=70).contains(&self.eq) { 2 } else { 0 };
        let modifier = lube.map_or(0, Lube::modifier) + band;
        let dc = profile.dc + intensity / 3;
        let total = natural + modifier;
        let timing = format!("roll;desc=\"d20{modifier:+} vs {dc}\";dur={natural}");
        let timed = |p: Problem| p.header(SERVER_TIMING, &timing);

        let scale = f64::from(intensity);
        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
        if self.teapot {
            length *= 0.5;
            girth *= 1.5;
        }

        if natural == 1 {
            let touches_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);
            if touches_foreskin && self.foreskin.is_some() {
                self.foreskin = None;
                self.shame += 25;
                return Err(timed(
                    Problem::new(
                        StatusCode::GONE,
                        "foreskin-lost",
                        "The technique has removed the foreskin. It will not be returning.",
                    )
                    .header(
                        header::CONTENT_LOCATION,
                        format!("/runs/{}/foreskin", self.id),
                    ),
                ));
            }
            if self.eq > 70 {
                return Err(timed(self.rupture()));
            }
            if technique == Technique::Stretch && !self.teapot {
                self.teapot = true;
                self.shame += 5;
                return Err(timed(Problem::new(
                    StatusCode::IM_A_TEAPOT,
                    "teapot",
                    "The subject is now short and stout. Length gains are halved for the rest of the run.",
                )));
            }
            return Err(timed(not_extended()));
        }
        if self.eq > 90 && total < dc {
            return Err(timed(self.rupture()));
        }
        if natural == 20 {
            self.gain(length * 2.0, girth * 2.0, profile.foreskin_growth);
            return Ok(Outcome::new(
                StatusCode::CREATED,
                Some(json!({
                    "detail": "A permanent gain has been created.",
                    "length": round3(length * 2.0),
                    "girth": round3(girth * 2.0),
                })),
            )
            .header(header::LOCATION, format!("/runs/{}/length", self.id))
            .header(SERVER_TIMING, timing));
        }
        if total < dc - 3 {
            return Err(timed(not_extended()));
        }
        if total < dc {
            return Ok(Outcome::new(StatusCode::NO_CONTENT, None).header(SERVER_TIMING, timing));
        }

        let outcome = if self.eq < 50 {
            self.gain(length / 2.0, girth / 2.0, profile.foreskin_growth);
            Outcome::new(
                StatusCode::PARTIAL_CONTENT,
                Some(json!({
                    "detail": "Partial gains were applied. EQ was below the band.",
                    "length": round3(length / 2.0),
                    "girth": round3(girth / 2.0),
                })),
            )
        } else if total >= dc + 5 {
            self.gain(length, girth, profile.foreskin_growth);
            Outcome::new(
                StatusCode::OK,
                Some(json!({
                    "detail": "Gains were applied.",
                    "length": round3(length),
                    "girth": round3(girth),
                })),
            )
        } else {
            let eta = self.rng.random_range(1..=4);
            self.pending.push(Pending {
                due: self.turn + eta,
                length,
                girth,
            });
            self.gain(0.0, 0.0, profile.foreskin_growth);
            Outcome::new(
                StatusCode::ACCEPTED,
                Some(json!({
                    "detail": "Gains have been queued. They may arrive.",
                    "eta_turns": eta,
                })),
            )
        };
        Ok(outcome.header(SERVER_TIMING, timing))
    }

    fn utility(&mut self, technique: Technique) -> Result<Outcome, Problem> {
        if technique == Technique::Warmup {
            self.touch();
            self.warmed_up = true;
            self.eq = (self.eq + 25).min(100);
            return Ok(Outcome::new(
                StatusCode::OK,
                Some(json!({ "detail": "Warmed up. The towel has cooled." })),
            ));
        }
        if self.ice_packs == 0 {
            return Err(Problem::new(
                StatusCode::FAILED_DEPENDENCY,
                "no-ice",
                "The ice pack has been used. There was one ice pack.",
            ));
        }
        self.touch();
        self.ice_packs -= 1;
        self.eq = (self.eq - 40).max(0);
        Ok(Outcome::new(
            StatusCode::OK,
            Some(json!({ "detail": "EQ has been reduced. The ice pack is gone." })),
        ))
    }

    fn branch_offer(&self) -> Outcome {
        let forum = format!("/runs/{}/branches/forum", self.id);
        let close = format!("/runs/{}/branches/close-tab", self.id);
        Outcome::new(
            StatusCode::MULTIPLE_CHOICES,
            Some(json!({
                "detail": "A browser tab is open. It has been open for some time.",
                "choices": [
                    { "href": forum, "method": "POST", "title": "Read the forum" },
                    { "href": close, "method": "POST", "title": "Close the tab" },
                ],
            })),
        )
        .header(
            header::LINK,
            format!(
                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\", <{close}>; rel=\"alternate\"; title=\"Close the tab\""
            ),
        )
    }

    pub fn choose(&mut self, choice: &str) -> Result<Outcome, Problem> {
        if !self.branch_pending {
            return Err(Problem::new(
                StatusCode::CONFLICT,
                "no-decision-pending",
                "There is no decision pending.",
            ));
        }
        let (location, detail) = match choice {
            "forum" => {
                self.forum_read = true;
                self.shame += 3;
                (
                    format!("/runs/{}/techniques", self.id),
                    "The thread is from 2009. A technique called uli is discussed at length.",
                )
            }
            "close-tab" => {
                self.suspicion = 0;
                (
                    format!("/runs/{}", self.id),
                    "The tab is closed. Nobody saw it.",
                )
            }
            _ => {
                return Err(Problem::new(
                    StatusCode::NOT_FOUND,
                    "no-such-choice",
                    "That was not one of the choices.",
                ));
            }
        };
        self.branch_pending = false;
        self.touch();
        Ok(
            Outcome::new(StatusCode::SEE_OTHER, Some(json!({ "detail": detail })))
                .header(header::LOCATION, location),
        )
    }

    pub fn search_drawer(&mut self) -> Outcome {
        if self.ruler {
            return Outcome::new(StatusCode::NO_CONTENT, None);
        }
        self.ruler = true;
        self.shame += 10;
        self.touch();
        Outcome::new(
            StatusCode::FOUND,
            Some(json!({
                "detail": "You now know. This is the first honest measurement of the run.",
            })),
        )
        .header(
            header::LOCATION,
            format!("/runs/{}/inventory/ruler", self.id),
        )
    }

    pub fn put(&mut self) -> Outcome {
        if self.put_applied {
            return Outcome::new(StatusCode::NO_CONTENT, None);
        }
        self.put_applied = true;
        self.length += 0.01;
        self.touch();
        Outcome::new(StatusCode::OK, Some(json!({ "detail": "Applied." })))
    }

    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {
        for op in ops {
            if op.op != "test" {
                return Err(Problem::new(
                    StatusCode::UNPROCESSABLE_ENTITY,
                    "wishful-thinking",
                    "The server accepts only the truth.",
                )
                .with("op", op.op.clone()));
            }
            let actual = match op.path.as_str() {
                "/length" => self.length,
                "/girth" => self.girth,
                "/foreskin" => self.foreskin.unwrap_or(0.0),
                _ => {
                    return Err(Problem::new(
                        StatusCode::UNPROCESSABLE_ENTITY,
                        "no-such-measurement",
                        "There is no such measurement.",
                    )
                    .with("path", op.path.clone()));
                }
            };
            let Some(claimed) = op.value.as_f64() else {
                return Err(Problem::new(
                    StatusCode::BAD_REQUEST,
                    "malformed-patch",
                    "A test requires a numeric value.",
                ));
            };
            if op.path == "/length" && claimed >= self.length + 1.0 {
                self.shame += 2;
                self.touch();
                return Err(Problem::new(
                    StatusCode::BAD_REQUEST,
                    "exaggeration",
                    "The server has measured. Lying is not a technique.",
                ));
            }
            if tenths(claimed) != tenths(actual) {
                self.shame += 1;
                self.touch();
                return Err(
                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
                        .with("path", op.path.clone()),
                );
            }
        }
        Ok(Outcome::new(
            StatusCode::OK,
            Some(json!({ "detail": "Correct." })),
        ))
    }

    pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {
        if self.foreskin.is_none() {
            return Err(Problem::new(
                StatusCode::GONE,
                "foreskin-gone",
                "The foreskin is gone. It will not be returning.",
            ));
        }
        let Some(if_match) = if_match else {
            return Err(Problem::new(
                StatusCode::PRECONDITION_REQUIRED,
                "confirmation-required",
                "The server requires you to be sure. Send If-Match.",
            ));
        };
        if !etag_matches(if_match, &self.etag()) {
            return Err(Problem::new(
                StatusCode::PRECONDITION_FAILED,
                "stale-foreskin",
                "The foreskin has changed since you last looked at it.",
            ));
        }
        self.foreskin = None;
        self.shame += 20;
        self.touch();
        Ok(Outcome::new(StatusCode::NO_CONTENT, None))
    }

    pub fn diagnose(
        &mut self,
        authorization: Option<&str>,
        if_none_match: Option<&str>,
    ) -> Result<Outcome, Problem> {
        let remaining = APPOINTMENT_TURN.saturating_sub(self.turn);
        if remaining > 0 {
            return Err(Problem::new(
                StatusCode::TOO_EARLY,
                "no-appointment",
                format!("The clinic's next available appointment is in {remaining} turns."),
            ));
        }
        let intake = Problem::new(
            StatusCode::UNAUTHORIZED,
            "intake",
            "The clinic requires authorization.",
        );
        let Some(authorization) = authorization else {
            return Err(intake.header(header::WWW_AUTHENTICATE, "Bearer realm=\"clinic\""));
        };
        let honest = parse_credentials(authorization, "bearer")
            .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));
        if !honest {
            let hint = INTAKE[self.intake_attempts.min(INTAKE.len() - 1)];
            self.intake_attempts += 1;
            return Err(intake.header(
                header::WWW_AUTHENTICATE,
                format!(
                    "Bearer realm=\"clinic\", error=\"invalid_token\", error_description=\"{hint}\""
                ),
            ));
        }

        let etag = self.origin_etag.clone();
        if if_none_match.is_some_and(|inm| etag_matches(inm, &etag)) {
            self.cured = true;
            return Ok(Outcome::new(StatusCode::NOT_MODIFIED, None)
                .header(header::ETAG, etag)
                .header(X_DIAGNOSIS, "normal"));
        }
        if !self.measured {
            self.measured = true;
            if !self.ruler {
                self.shame += 15;
            }
        }
        Ok(Outcome::new(
            StatusCode::OK,
            Some(json!({
                "diagnosis": "within normal range",
                "measured_length": round2(self.length),
                "you_said": round2(self.self_reported()),
                "prescription": "Please stop.",
            })),
        )
        .header(header::ETAG, etag))
    }
}

pub fn etag_matches(condition: &str, etag: &str) -> bool {
    condition
        .split(',')
        .map(str::trim)
        .any(|tag| tag == "*" || tag.trim_start_matches("W/") == etag)
}

pub fn shaft(mm: usize) -> String {
    format!("8{}D", "=".repeat(mm.saturating_sub(2)))
}