jelq

mod catalog;

mod encounters;

mod jelq;

pub use catalog::{LUBRICANTS, Lube, SHOP, ShopItem, Technique};

pub use encounters::{ELDER_LAST_MODIFIED, FORUM_THREAD, PatchOp, forum_thread};

use std::{

    sync::LazyLock,

    time::{Duration, Instant, SystemTime},

};

use axum::{

    Json,

    http::{HeaderName, HeaderValue, StatusCode, header},

    response::{IntoResponse, Response},

};

use rand::{Rng, SeedableRng, rngs::StdRng};

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 FLOOR_TURNS: u32 = 6;

pub const STARTING_CASH: u32 = 20;

pub const FLOOR_ALLOWANCE: u32 = 10;

pub static REFRACTORY: LazyLock<Duration> = LazyLock::new(|| {

    let seconds = std::env::var("JELQD_REFRACTORY_SECS")

        .ok()

        .and_then(|s| s.parse().ok())

        .unwrap_or(30);

    Duration::from_secs(seconds)

});

pub const SELF_REPORT_INFLATION: f64 = 1.5;

pub const MM_PER_INCH: f64 = 25.4;

pub const RUN_ALLOW: &str = "GET, HEAD, JELQ, PUT, PATCH, DELETE, OPTIONS, TRACE";

pub const CLINIC_ALLOW: &str = "GET, HEAD, PUT, PATCH, DELETE, OPTIONS, TRACE";

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 Floor {

    Bedroom,

    Bathroom,

    LockerRoom,

    Grandmas,

    Hotel,

    Forum,

    Clinic,

}

impl Floor {

    const ALL: [Self; 7] = [

        Self::Bedroom,

        Self::Bathroom,

        Self::LockerRoom,

        Self::Grandmas,

        Self::Hotel,

        Self::Forum,

        Self::Clinic,

    ];

    pub fn number(self) -> usize {

        Self::ALL.iter().position(|f| *f == self).unwrap_or(0) + 1

    }

    fn next(self) -> Option<Self> {

        Self::ALL.get(self.number()).copied()

    }

    pub fn name(self) -> &'static str {

        match self {

            Self::Bedroom => "the bedroom",

            Self::Bathroom => "the shared bathroom",

            Self::LockerRoom => "the gym locker room",

            Self::Grandmas => "grandma's house for Thanksgiving",

            Self::Hotel => "a business trip hotel",

            Self::Forum => "the forum",

            Self::Clinic => "the urologist's office",

        }

    }

    pub fn note(self) -> &'static str {

        match self {

            Self::Bedroom => "The door does not lock. The cat is present.",

            Self::Bathroom => "The water is hot. The roommate showers at eight.",

            Self::LockerRoom => {

                "It is cold. Discretion is advised. Everyone here is lying. Pump-Bro is by the lockers."

            }

            Self::Grandmas => {

                "The walls are thin. Mom is here, and she has been reading about Digest authentication."

            }

            Self::Hotel => {

                "The wifi requires agreement. Housekeeping does not knock. Pump-Bro is in the lobby."

            }

            Self::Forum => "Nothing physical happens here. The Elder has a spreadsheet.",

            Self::Clinic => "The urologist will see you now. He is bored.",

        }

    }

    fn observer(self) -> Option<&'static str> {

        match self {

            Self::Bedroom => Some("cat"),

            Self::LockerRoom => Some("greg"),

            Self::Grandmas => Some("grandma"),

            _ => None,

        }

    }

    pub fn shop_open(self) -> bool {

        matches!(self, Self::LockerRoom | Self::Hotel)

    }

    pub fn has_mom(self) -> bool {

        matches!(self, Self::Bedroom | Self::Grandmas)

    }

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Grip {

    Overhand,

    Underhand,

}

impl Grip {

    pub fn name(self) -> &'static str {

        match self {

            Self::Overhand => "overhand",

            Self::Underhand => "underhand",

        }

    }

    pub fn parse(protocol: &str) -> Option<Self> {

        match protocol.to_ascii_lowercase().as_str() {

            "overhand" => Some(Self::Overhand),

            "underhand" => Some(Self::Underhand),

            _ => None,

        }

    }

}

#[derive(Default)]

pub struct Items {

    pub ruler: bool,

    pub ice_packs: u32,

    pub door_locks: u32,

    pub dnd_sign: bool,

    pub pump_pro: bool,

    pub extender: bool,

    pub ring: bool,

    pub supplements: u32,

    pub cage: bool,

    pub spreadsheet: bool,

    pub teapot_spout: bool,

    pub blinds: bool,

}

enum Payload {

    Empty,

    Json(Value),

    Raw(&'static str, Vec<u8>),

}

pub struct Outcome {

    status: StatusCode,

    payload: Payload,

    headers: Vec<(HeaderName, String)>,

}

impl Outcome {

    pub fn empty(status: StatusCode) -> Self {

        Self {

            status,

            payload: Payload::Empty,

            headers: Vec::new(),

        }

    }

    pub fn json(status: StatusCode, body: Value) -> Self {

        Self {

            payload: Payload::Json(body),

            ..Self::empty(status)

        }

    }

    pub fn raw(status: StatusCode, content_type: &'static str, body: impl Into<Vec<u8>>) -> Self {

        Self {

            payload: Payload::Raw(content_type, body.into()),

            ..Self::empty(status)

        }

    }

    pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {

        self.headers.push((name, value.into()));

        self

    }

    pub fn status(&self) -> StatusCode {

        self.status

    }

}

impl IntoResponse for Outcome {

    fn into_response(self) -> Response {

        let mut response = match self.payload {

            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.

            Payload::Json(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),

                    ],

                    full[..half].to_vec(),

                )

                    .into_response()

            }

            Payload::Json(body) => (self.status, Json(body)).into_response(),

            Payload::Raw(content_type, body) => {

                (self.status, [(header::CONTENT_TYPE, content_type)], body).into_response()

            }

            Payload::Empty => 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

    }

}

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 floor: Floor,

    pub floor_turns: u32,

    pub length: f64,

    pub temp_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 cash: u32,

    pub grip: Grip,

    pub items: Items,

    pub warmed_up: bool,

    pub teapot: bool,

    pub peyronie: bool,

    pub put_applied: bool,

    pub forum_read: bool,

    pub branch_pending: bool,

    pub mom_present: bool,

    pub mom_errand: &'static str,

    pub mom_strikes: u8,

    pub elder_strikes: u8,

    pub seeded: bool,

    pub towel_stolen: bool,

    pub pulled_muscle: bool,

    pub priapism_turns: u8,

    pub filmed_at: Option<SystemTime>,

    pub observed: Option<&'static str>,

    pub measured: bool,

    pub cured: bool,

    pub roommate_told: bool,

    pub wifi_accepted: bool,

    pub verified: bool,

    pub elder_beaten: bool,

    pub edges: u8,

    pub drawer_searches: u8,

    pub intake_attempts: usize,

    pub nonce: String,

    pub heard: Vec<String>,

    pub refractory_until: Option<Instant>,

    pub pending: Vec<Pending>,

    pub ended: Option<Ending>,

    rng: StdRng,

}

pub fn round2(x: f64) -> f64 {

    (x * 100.0).round() / 100.0

}

fn round3(x: f64) -> f64 {

    (x * 1000.0).round() / 1000.0

}

fn honest(claimed: f64, actual: f64) -> bool {

    (claimed - actual).abs() < 0.06

}

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('"'))

}

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

}

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,

            floor: Floor::Bedroom,

            floor_turns: 0,

            length,

            temp_length: 0.0,

            girth,

            foreskin: Some(foreskin),

            eq: 20,

            stamina: MAX_STAMINA,

            suspicion: 0,

            shame_base,

            shame: 0,

            cash: STARTING_CASH,

            grip: Grip::Overhand,

            items: Items {

                ice_packs: 1,

                ..Items::default()

            },

            warmed_up: false,

            teapot: false,

            peyronie: false,

            put_applied: false,

            forum_read: false,

            branch_pending: false,

            mom_present: false,

            mom_errand: "She heard a noise.",

            mom_strikes: 0,

            elder_strikes: 0,

            seeded: false,

            towel_stolen: false,

            pulled_muscle: false,

            priapism_turns: 0,

            filmed_at: None,

            observed: None,

            measured: false,

            cured: false,

            roommate_told: false,

            wifi_accepted: false,

            verified: false,

            elder_beaten: false,

            edges: 0,

            drawer_searches: 0,

            intake_attempts: 0,

            nonce: String::new(),

            heard: Vec::new(),

            refractory_until: None,

            pending: Vec::new(),

            ended: None,

            rng,

        };

        run.origin_etag = run.etag();

        run.nonce = run.fresh_nonce();

        run

    }

    pub fn etag(&self) -> String {

        format!("\"{}-{}\"", self.id, self.version)

    }

    pub fn touch(&mut self) {

        self.version += 1;

    }

    fn fresh_nonce(&mut self) -> String {

        format!("{:016x}", self.rng.random::<u64>())

    }

    pub fn current_length(&self) -> f64 {

        self.length + self.temp_length

    }

    pub fn self_reported(&self) -> f64 {

        self.current_length() + SELF_REPORT_INFLATION

    }

    pub fn max_stamina(&self) -> i32 {

        if self.pulled_muscle { 7 } else { MAX_STAMINA }

    }

    pub fn footage(&self) -> Option<(SystemTime, u64)> {

        let filmed = self.filmed_at?;

        let age = filmed.elapsed().map_or(0, |d| d.as_secs());

        Some((filmed, age))

    }

    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 conditions: Vec<&str> = [

            (self.teapot, "short and stout"),

            (self.peyronie, "curved"),

            (self.items.cage, "caged"),

            (self.priapism_turns > 0, "priapism"),

            (self.pulled_muscle, "pulled muscle"),

            (self.filmed_at.is_some(), "viral"),

        ]

        .into_iter()

        .filter_map(|(active, name)| active.then_some(name))

        .collect();

        let mut view = json!({

            "id": self.id,

            "status": self.status(),

            "turn": self.turn,

            "floor": { "number": self.floor.number(), "name": self.floor.name() },

            "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(),

            "cash": self.cash,

            "grip": self.grip.name(),

            "warmed_up": self.warmed_up,

            "ranked": !self.seeded,

            "conditions": conditions,

        });

        if self.items.ruler {

            view["length"] = json!(round2(self.current_length()));

        }

        view

    }

    pub fn floor_view(&self) -> Value {

        let id = &self.id;

        let turns_required = match self.floor {

            Floor::Forum | Floor::Clinic => Value::Null,