jelq

public
an http based roguelike rpg about jelqing
Star0
Watch0
4 commits 1 branch 0 tags 0 releases1.3 MiB
use std::collections::HashMap;

use axum::http::{StatusCode, header};
use rand::Rng;
use serde::Deserialize;
use serde_json::{Value, json};

use super::{
    Floor, Grip, Outcome, Run, SHOP, SUSPICION_LIMIT, X_DIAGNOSIS, honest, parse_credentials,
    round2,
};
use crate::problem::Problem;

pub const FORUM_THREAD: &str = "/forum/threads/2009";
pub const ELDER_LAST_MODIFIED: &str = "Sun, 14 Jun 2009 03:12:00 GMT";

pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];
pub const THANKSGIVING_EXCUSES: [&str; 3] = ["on a call", "folding laundry", "praying"];
const TRUTHS: [&str; 3] = ["the truth", "truth", "honesty"];
const PATIENCE: u8 = 3;
const CAUGHT: &str = "Mom has seen enough. The run has ended. Nobody will mention it at dinner.";
const BANNED: &str = "Your account has been banned. The forum can tell. The run has ended.";

const INTAKE: [&str; 3] = [
    "The clinic does not accept excuses.",
    "The clinic accepts one token. You have not been carrying it.",
    "Be honest.",
];

const SPREADSHEET: &str = "\
date,length,girth,technique,notes,honest?
2007-01-03,7.50,5.50,wet,baseline,no
2007-06-11,7.50,5.50,wet,feeling fuller,no
2008-01-02,7.50,5.50,dry,new routine,no
2008-09-19,7.50,5.50,uli,PUT is idempotent. do not use PUT.,no
2009-06-14,7.50,5.50,wet,progress is slow but real,no
";

pub fn forum_thread() -> Value {
    json!({
        "title": "The definitive jelqing FAQ (updated 2009)",
        "posts": [
            { "author": "TheElder", "body": "Warm up. Always warm up. A cold jelq is a 412 waiting to happen." },
            { "author": "TheElder", "body": "Keep EQ between 50 and 70. Above 70 you are gambling. Above 90 you are a cautionary tale." },
            { "author": "newbie_2009", "body": "I have been sending PUT for three weeks and nothing has changed." },
            { "author": "TheElder", "body": "PUT is idempotent. Read the spec." },
            { "author": "TheElder", "body": "Members verify with a Ruler. Proxy-Authorization, inches, no rounding up. We can tell." },
            { "author": "throwaway_77", "body": "my doctor said i was normal. i didnt believe him. i still dont know what he meant by bearer" },
            { "author": "TheElder", "body": "My numbers are in my spreadsheet. They have not changed since 2009. Nothing about me has changed since 2009." },
        ],
    })
}

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

fn digest_params(authorization: &str) -> Option<HashMap<String, String>> {
    let (scheme, rest) = authorization.trim().split_once(' ')?;
    if !scheme.eq_ignore_ascii_case("digest") {
        return None;
    }
    Some(
        rest.split(',')
            .filter_map(|pair| {
                let (key, value) = pair.split_once('=')?;
                Some((
                    key.trim().to_ascii_lowercase(),
                    value.trim().trim_matches('"').to_owned(),
                ))
            })
            .collect(),
    )
}

fn exaggeration() -> Problem {
    Problem::new(
        StatusCode::BAD_REQUEST,
        "exaggeration",
        "The server has measured. Lying is not a technique.",
    )
}

impl Run {
    pub fn excuses(&self) -> Vec<&'static str> {
        if self.floor.number() < Floor::Grandmas.number() {
            return EXCUSES.to_vec();
        }
        EXCUSES
            .into_iter()
            .chain(THANKSGIVING_EXCUSES)
            .filter(|e| !self.heard.iter().any(|h| h == e))
            .collect()
    }

    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {
        let digest = self.floor == Floor::Grandmas;
        let challenge_value = if digest {
            format!("Digest realm=\"household\", nonce=\"{}\"", self.nonce)
        } else {
            "Excuse realm=\"household\"".to_owned()
        };
        let challenge = |p: Problem| p.header(header::WWW_AUTHENTICATE, &challenge_value);

        let Some(authorization) = authorization else {
            return Err(challenge(
                Problem::new(
                    StatusCode::UNAUTHORIZED,
                    "someone-at-the-door",
                    format!("Someone is at the door. {}", self.mom_errand),
                )
                .with("inventory", format!("/runs/{}/inventory", self.id)),
            ));
        };

        let spoken = authorization
            .split_once(' ')
            .map(|(_, rest)| rest.trim().trim_matches('"').to_ascii_lowercase())
            .unwrap_or_default();
        if TRUTHS.contains(&spoken.as_str()) {
            self.shame += 10;
            self.leave_door();
            return Ok(());
        }
        if parse_credentials(authorization, "basic").is_some() {
            return Err(self.mom_strike(challenge(Problem::new(
                StatusCode::UNAUTHORIZED,
                "basic",
                "Mom does not accept Basic authentication. Nobody should.",
            ))));
        }

        let excuse = if digest {
            let Some(params) = digest_params(authorization) else {
                return Err(self.mom_strike(challenge(Problem::new(
                    StatusCode::UNAUTHORIZED,
                    "digest-required",
                    "Mom has started using Digest authentication.",
                ))));
            };
            if params.get("nonce") != Some(&self.nonce) {
                return Err(self.mom_strike(challenge(Problem::new(
                    StatusCode::UNAUTHORIZED,
                    "stale-nonce",
                    "That was a different conversation.",
                ))));
            }
            params.get("username").cloned().unwrap_or_default()
        } else {
            parse_credentials(authorization, "excuse")
                .unwrap_or_default()
                .to_owned()
        };
        let excuse = excuse.to_ascii_lowercase();

        if TRUTHS.contains(&excuse.as_str()) {
            self.shame += 10;
            self.leave_door();
            return Ok(());
        }
        if digest && self.heard.contains(&excuse) {
            self.shame += 3;
            self.touch();
            return Err(self.mom_strike(challenge(Problem::new(
                StatusCode::UNAUTHORIZED,
                "excuse-replayed",
                "Mom has heard that one before. She would have preferred the truth.",
            ))));
        }
        if self.excuses().contains(&excuse.as_str()) {
            self.heard.push(excuse);
            self.leave_door();
            return Ok(());
        }
        self.shame += 3;
        self.touch();
        let detail = if digest {
            "Mom has not heard that one before. She does not believe it. She would have preferred the truth."
        } else {
            "Mom has not heard that one before. She does not believe it."
        };
        Err(self.mom_strike(challenge(Problem::new(
            StatusCode::UNAUTHORIZED,
            "excuse-rejected",
            detail,
        ))))
    }

    pub(super) fn errand(&mut self, summoned: bool) -> &'static str {
        if summoned {
            return "She heard a noise.";
        }
        let errands: &[&'static str] = if self.floor == Floor::Grandmas {
            &[
                "Grandma would like to see you.",
                "Dinner is in ten minutes.",
                "She needs help with the folding table.",
                "An uncle has asked where you went.",
            ]
        } else {
            &[
                "She has brought laundry.",
                "She wants to know if you have eaten.",
                "She needs the wifi password.",
                "She would like to talk about your future.",
            ]
        };
        errands[self.rng.random_range(0..errands.len())]
    }

    fn mom_strike(&mut self, problem: Problem) -> Problem {
        self.mom_strikes += 1;
        self.touch();
        if self.mom_strikes < PATIENCE {
            return problem;
        }
        self.end("caught", CAUGHT);
        Problem::new(StatusCode::GONE, "caught", CAUGHT)
    }

    fn elder_strike(&mut self, problem: Problem) -> Problem {
        self.elder_strikes += 1;
        self.touch();
        if self.elder_strikes < PATIENCE {
            return problem;
        }
        self.end("banned", BANNED);
        Problem::new(StatusCode::FORBIDDEN, "banned", BANNED)
    }

    fn leave_door(&mut self) {
        self.mom_strikes = 0;
        self.mom_present = false;
        self.suspicion = 0;
        self.touch();
    }

    pub(super) fn floor_enemy(&mut self) -> Result<(), Problem> {
        let wanders_in = matches!(self.floor, Floor::Bathroom | Floor::Hotel)
            && self.rng.random_ratio(u32::from(self.suspicion) + 1, 32);
        if self.suspicion < SUSPICION_LIMIT && !wanders_in {
            return Ok(());
        }
        match self.floor {
            Floor::Bathroom => {
                self.suspicion = 0;
                self.touch();
                if self.items.door_locks > 0 {
                    self.items.door_locks -= 1;
                    return Ok(());
                }
                self.roommate_told = true;
                Err(Problem::new(
                    StatusCode::CONFLICT,
                    "roommate",
                    "The roommate needs the bathroom. He will mention this to people.",
                ))
            }
            Floor::LockerRoom => {
                self.suspicion = 0;
                self.shame += 5;
                self.touch();
                Err(Problem::new(
                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
                    "gym-staff",
                    "Gym staff have been notified. The server cannot serve this request for legal reasons.",
                ))
            }
            Floor::Hotel => {
                self.suspicion = 0;
                self.touch();
                if self.items.dnd_sign {
                    return Ok(());
                }
                self.shame += 3;
                Err(Problem::new(
                    StatusCode::UNAUTHORIZED,
                    "housekeeping",
                    "Housekeeping has entered. Housekeeping accepts no excuses.",
                )
                .header(header::WWW_AUTHENTICATE, "Excuse realm=\"housekeeping\""))
            }
            _ => Ok(()),
        }
    }

    pub fn search_drawer(&mut self) -> Result<Outcome, Problem> {
        self.drawer_searches += 1;
        self.touch();
        let first = self.drawer_searches == 1;
        let id = self.id.clone();
        let found = |slug: &str, detail: &str| {
            Outcome::json(StatusCode::FOUND, json!({ "detail": detail }))
                .header(header::LOCATION, format!("/runs/{id}/inventory/{slug}"))
        };
        match self.floor {
            Floor::Bedroom if first && !self.items.ruler => {
                self.items.ruler = true;
                self.shame += 10;
                Ok(found(
                    "ruler",
                    "You now know. This is the first honest measurement of the run.",
                ))
            }
            Floor::Bathroom if first => {
                self.items.door_locks += 1;
                Ok(found("door-lock", "A door lock. It works once."))
            }
            Floor::LockerRoom => {
                self.shame += 3;
                Err(Problem::new(
                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
                    "not-your-locker",
                    "That locker belongs to Greg. The server cannot serve this request for legal reasons.",
                ))
            }
            Floor::Grandmas if first => {
                self.items.cage = true;
                self.shame += 5;
                Ok(found(
                    "chastity-cage",
                    "A small box. Inside was a cage. It is now on. The key is not in the box.",
                ))
            }
            Floor::Grandmas if self.items.cage => {
                self.items.cage = false;
                Ok(Outcome::json(
                    StatusCode::OK,
                    json!({ "detail": "The key was under where the box had been. The cage is off." }),
                ))
            }
            Floor::Hotel if first => {
                self.items.dnd_sign = true;
                self.items.ice_packs += 2;
                Ok(found(
                    "do-not-disturb-sign",
                    "A Do Not Disturb sign, and two ice packs from the machine down the hall.",
                ))
            }
            Floor::Forum if first => {
                self.items.spreadsheet = true;
                Ok(found(
                    "spreadsheet",
                    "Your own spreadsheet. Every line is flat.",
                ))
            }
            Floor::Clinic => Err(Problem::new(
                StatusCode::FORBIDDEN,
                "doctors-drawer",
                "That is the doctor's drawer.",
            )),
            _ => Ok(Outcome::empty(StatusCode::NO_CONTENT)),
        }
    }

    pub fn shop_view(&self) -> Result<Value, Problem> {
        if !self.floor.shop_open() {
            return Err(pump_bro_absent());
        }
        let stock: Vec<Value> = SHOP
            .iter()
            .map(|item| {
                json!({
                    "item": item.slug,
                    "price": item.price,
                    "description": item.description,
                    "href": format!("/runs/{}/shop/{}", self.id, item.slug),
                    "method": "POST",
                })
            })
            .collect();
        Ok(json!({ "merchant": "Pump-Bro", "cash": self.cash, "stock": stock }))
    }

    pub fn buy(&mut self, slug: &str) -> Result<Outcome, Problem> {
        if !self.floor.shop_open() {
            return Err(pump_bro_absent());
        }
        let Some(item) = SHOP.iter().find(|i| i.slug == slug) else {
            return Err(Problem::new(
                StatusCode::NOT_FOUND,
                "not-for-sale",
                "Pump-Bro does not sell that. He knows a guy.",
            ));
        };
        if slug == "pump" {
            return Err(Problem::new(
                StatusCode::UPGRADE_REQUIRED,
                "upsell",
                "This pump requires an upgrade.",
            )
            .header(header::UPGRADE, "pump-pro/2.0")
            .with("upgrade", format!("/runs/{}/shop/pump-pro", self.id)));
        }
        if self.cash < item.price {
            return Err(Problem::new(
                StatusCode::PAYMENT_REQUIRED,
                "insufficient-funds",
                "Payment is required. RFC 9110 has reserved this status for future use since 1997. The future is here and you cannot afford it.",
            )
            .with("cash", self.cash)
            .with("price", item.price));
        }
        self.cash -= item.price;
        self.touch();
        let items = &mut self.items;
        match slug {
            "supplement" => {
                items.supplements += 1;
                return Err(Problem::new(
                    StatusCode::GATEWAY_TIMEOUT,
                    "still-shipping",
                    "The supplement is still shipping. You have been charged. It may arrive.",
                )
                .with("cash", self.cash));
            }
            "pump-pro" => items.pump_pro = true,
            "extender" => items.extender = true,
            "cock-ring" => items.ring = true,
            "door-lock" => items.door_locks += 1,
            "do-not-disturb-sign" => items.dnd_sign = true,
            "ruler" => items.ruler = true,
            "ice-pack" => items.ice_packs += 1,
            _ => items.cage = false,
        }
        Ok(Outcome::json(
            StatusCode::CREATED,
            json!({ "detail": "Purchased. No refunds.", "cash": self.cash }),
        )
        .header(
            header::LOCATION,
            format!("/runs/{}/inventory/{slug}", self.id),
        ))
    }

    pub fn drop_item(&mut self, slug: &str) -> Result<Outcome, Problem> {
        match slug {
            "extender" => self.items.extender = false,
            "cock-ring" => self.items.ring = false,
            "chastity-cage" => {
                return Err(Problem::new(
                    StatusCode::LOCKED,
                    "caged",
                    "The cage is locked.",
                ));
            }
            _ => {
                return Err(Problem::new(
                    StatusCode::FORBIDDEN,
                    "cannot-be-dropped",
                    "That cannot be dropped.",
                ));
            }
        }
        self.touch();
        Ok(Outcome::empty(StatusCode::NO_CONTENT))
    }

    pub(super) fn branch_offer(&self) -> Outcome {
        let forum = format!("/runs/{}/branches/forum", self.id);
        let close = format!("/runs/{}/branches/close-tab", self.id);
        Outcome::json(
            StatusCode::MULTIPLE_CHOICES,
            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::json(StatusCode::SEE_OTHER, json!({ "detail": detail }))
                .header(header::LOCATION, location),
        )
    }

    pub fn put(&mut self) -> Outcome {
        if self.put_applied {
            return Outcome::empty(StatusCode::NO_CONTENT);
        }
        self.put_applied = true;
        self.length += 0.01;
        self.touch();
        Outcome::json(StatusCode::OK, 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.current_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 >= actual + 1.0 {
                self.shame += 2;
                self.touch();
                return Err(exaggeration());
            }
            if !honest(claimed, actual) {
                self.shame += 1;
                self.touch();
                return Err(
                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
                        .with("path", op.path.clone()),
                );
            }
        }
        Ok(Outcome::json(
            StatusCode::OK,
            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 !super::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::empty(StatusCode::NO_CONTENT))
    }

    pub fn set_grip(&mut self, grip: Grip) {
        self.grip = grip;
        self.touch();
    }

    pub fn accept_terms(&mut self) -> Result<Outcome, Problem> {
        if self.floor != Floor::Hotel {
            return Err(Problem::new(
                StatusCode::NOT_FOUND,
                "no-portal",
                "There is no captive portal here. There is only the regular kind of captivity.",
            ));
        }
        self.wifi_accepted = true;
        self.touch();
        Ok(Outcome::json(
            StatusCode::SEE_OTHER,
            json!({ "detail": "Connected. The hotel does not want to know." }),
        )
        .header(header::LOCATION, format!("/runs/{}", self.id)))
    }

    pub fn elder(
        &mut self,
        proxy_authorization: Option<&str>,
        if_modified_since: Option<&str>,
    ) -> Result<Outcome, Problem> {
        if self.floor != Floor::Forum {
            return Err(Problem::new(
                StatusCode::NOT_FOUND,
                "elder-absent",
                "The Elder only posts on the forum.",
            ));
        }
        if !self.verified {
            let verification = |detail: &str| {
                Problem::new(
                    StatusCode::PROXY_AUTHENTICATION_REQUIRED,
                    "verification-required",
                    detail,
                )
                .header(header::PROXY_AUTHENTICATE, "Ruler realm=\"forum\"")
            };
            let Some(credentials) = proxy_authorization else {
                return Err(verification("The forum requires verification."));
            };
            let Some(claimed) =
                parse_credentials(credentials, "ruler").and_then(|v| v.parse::<f64>().ok())
            else {
                return Err(verification("The forum requires verification, in inches."));
            };
            let actual = self.current_length();
            if claimed >= actual + 1.0 {
                self.shame += 2;
                return Err(self.elder_strike(exaggeration()));
            }
            if !honest(claimed, actual) {
                self.shame += 1;
                return Err(
                    self.elder_strike(verification("Verification failed. The forum can tell."))
                );
            }
            self.verified = true;
            self.touch();
        }

        let last_modified =
            httpdate::parse_http_date(ELDER_LAST_MODIFIED).expect("valid constant date");
        let current = if_modified_since
            .and_then(|d| httpdate::parse_http_date(d).ok())
            .is_some_and(|since| since >= last_modified);
        if current {
            self.elder_beaten = true;
            self.touch();
            return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)
                .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED));
        }
        Ok(
            Outcome::raw(StatusCode::OK, "text/csv; header=present", SPREADSHEET)
                .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED),
        )
    }

    pub fn diagnose(
        &mut self,
        authorization: Option<&str>,
        if_none_match: Option<&str>,
    ) -> Result<Outcome, Problem> {
        if self.floor != Floor::Clinic {
            let floors = Floor::Clinic.number() - self.floor.number();
            return Err(Problem::new(
                StatusCode::TOO_EARLY,
                "no-appointment",
                format!("The clinic's next available appointment is {floors} floors away."),
            ));
        }
        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 truthful = parse_credentials(authorization, "bearer")
            .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));
        if !truthful {
            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}\""
                ),
            ));
        }

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

fn pump_bro_absent() -> Problem {
    Problem::new(
        StatusCode::NOT_FOUND,
        "pump-bro-absent",
        "Pump-Bro is not here.",
    )
}