jelq

pub mod balance;

mod body;

mod clinic;

mod floors;

mod forum;

mod hazards;

mod household;

mod items;

mod kitchen;

pub(crate) mod oracle;

mod outcome;

mod shop;

mod state;

mod techniques;

mod turn;

mod utility;

pub use body::PatchOp;

pub use forum::{ELDER_LAST_MODIFIED, FORUM_THREAD, forum_thread};

pub use items::{Item, Items, SHOP};

pub use outcome::{Outcome, Payload};

pub use state::{

    Cause, Clinic, Conditions, Elder, Ending, Floor, FloorState, Grip, MumVisit, Observer, Story,

};

pub use techniques::{LUBRICANTS, Lube, Technique};

use std::{

    hash::{DefaultHasher, Hash, Hasher},

    time::{Instant, SystemTime},

};

use axum::http::StatusCode;

use serde_json::{Value, json};

use crate::problem::Problem;

use balance::{

    BRANCH_TURN, HONEST_TOLERANCE, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, SELF_REPORT_INFLATION,

    STARTING_CASH, STARTING_EQ,

};

use oracle::{Oracle, OracleTemplate};

use state::Pending;

pub struct Run {

    /// The private id in the run's URL. Knowing it is the only authorisation a run has.

    pub id: String,

    pub public_id: String,

    etag_salt: u64,

    pub version: u64,

    pub turn: u32,

    pub floor: Floor,

    pub here: FloorState,

    pub length: f64,

    pub girth: f64,

    pub foreskin: Option<f64>,

    pub eq: i32,

    pub stamina: i32,

    pub suspicion: u8,

    pub shame: u32,

    pub shame_reported: u32,

    pub shame_total: u32,

    pub cash: u32,

    pub grip: Grip,

    pub friction: i32,

    pub jelq_grip: Option<Grip>,

    pub items: Items,

    pub conditions: Conditions,

    pub warmed_up: bool,

    pub put_applied: bool,

    pub story: Story,

    pub uli_taught: bool,

    pub kitchen_tellings: u8,

    pub mum: Option<MumVisit>,

    pub heard: Vec<String>,

    pub elder: Elder,

    pub clinic: Clinic,

    pub seeded: bool,

    pub filmed_at: Option<SystemTime>,

    pub observed: Option<Observer>,

    pub exhausted: bool,

    pub pending: Vec<Pending>,

    pub notices: Vec<&'static str>,

    pub ended: Option<Ending>,

    pub last_seen: Instant,

    oracle: Oracle,

}

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

}

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 {

    #[cfg(test)]

    pub fn new(id: String, public_id: String, seed: u64) -> Self {

        Self::with_oracle(id, public_id, seed, &OracleTemplate::Rng)

    }

    pub fn with_oracle(

        id: String,

        public_id: String,

        seed: u64,

        template: &OracleTemplate,

    ) -> Self {

        let mut oracle = Oracle::build(template, seed);

        let length = round2(oracle.span(

            Run::unborn("length", "How long is it, in inches?"),

            4.5,

            6.5,

        ));

        let girth = round2(oracle.span(

            Run::unborn("girth", "How thick is it, in inches?"),

            4.0,

            5.0,

        ));

        let foreskin = round2(oracle.span(

            Run::unborn("foreskin", "How much foreskin is there, in inches?"),

            0.4,

            2.4,

        ));

        let etag_salt = oracle.u64();

        Self {

            id,

            public_id,

            etag_salt,

            version: 0,

            turn: 0,

            floor: Floor::Bedroom,

            here: FloorState::default(),

            length,

            girth,

            foreskin: Some(foreskin),

            eq: STARTING_EQ,

            stamina: MAX_STAMINA,

            suspicion: 0,

            shame: 0,

            shame_reported: 0,

            shame_total: 0,

            cash: STARTING_CASH,

            grip: Grip::Overhand,

            friction: 0,

            jelq_grip: None,

            items: Items::default(),

            conditions: Conditions::default(),

            warmed_up: false,

            put_applied: false,

            story: Story::Unopened,

            uli_taught: false,

            kitchen_tellings: 0,

            mum: None,

            heard: Vec::new(),

            notices: Vec::new(),

            elder: Elder::Unverified { strikes: 0 },

            clinic: Clinic::default(),

            seeded: false,

            filmed_at: None,

            observed: None,

            exhausted: false,

            pending: Vec::new(),

            ended: None,

            last_seen: Instant::now(),

            oracle,

        }

    }

    /// A roll for a run that does not exist yet, so there is no state to describe.

    fn unborn(site: &'static str, ask: &str) -> oracle::Roll {

        oracle::Roll {

            state: "A new run is being created. No game has been played yet.".into(),

            site,

            ask: ask.into(),

        }

    }

    fn etag_at(&self, version: u64) -> String {

        let mut hasher = DefaultHasher::new();

        (self.etag_salt, version).hash(&mut hasher);

        format!("\"{:016x}\"", hasher.finish())

    }

    pub fn etag(&self) -> String {

        self.etag_at(self.version)

    }

    /// The ETag the run had when it was created, which the true ending asks for.

    pub fn origin_etag(&self) -> String {

        self.etag_at(0)

    }

    pub fn touch(&mut self) {

        self.version += 1;

    }

    pub(super) fn shed(&mut self, friction: i32) {

        self.friction = (self.friction - friction).max(0);

    }

    /// Priapism holds EQ up no matter what else moves it.

    pub(super) fn reset_eq(&mut self, eq: i32) {

        let floor = if self.conditions.priapism_turns > 0 {

            PRIAPISM_EQ

        } else {

            0

        };

        self.eq = eq.max(floor);

    }

    /// A melon offer stands only while the raiding streak continues. Any other action ends it.

    pub(super) fn end_kitchen_visit(&mut self) {

        self.here.melon_offered = false;

    }

    /// Going back to the jelq walks away from both the fridge and Pump-Bro.

    pub(super) fn step_away(&mut self) {

        self.end_kitchen_visit();

        self.here.shopping = false;

    }

    fn fresh_nonce(&mut self) -> String {

        format!("{:016x}", self.oracle.u64())

    }

    /// One game decision for the oracle, phrased for the model and stamped

    /// with the state as the player sees it.

    fn decision(&self, site: &'static str, ask: impl std::fmt::Display) -> oracle::Roll {

        oracle::Roll {

            state: self.oracle_state(),

            site,

            ask: ask.to_string(),

        }

    }

    fn oracle_state(&self) -> String {

        let mut s = String::new();

        let place = match self.floor {

            Floor::Bedroom => "the bedroom",

            Floor::Bathroom => "the bathroom",

            Floor::ChangingRoom => "the changing room",

            Floor::Nans => "Nan's house",

            Floor::Hotel => "the hotel room",

            Floor::Forum => "the forum floor",

            Floor::Clinic => "the clinic",

        };

        s.push_str(&format!(

            "Floor {}, {place}. Turn {}.\n\n",

            self.floor.number(),

            self.turn

        ));

        s.push_str(&format!(

            "eq: {}\nstamina: {}\nfriction: {}\n",

            self.eq, self.stamina, self.friction

        ));

        if self.conditions.friction_burn {

            s.push_str("friction burn: yes, untreated\n");

        }

        if self.conditions.priapism_turns > 0 {

            s.push_str("priapism: yes\n");

        }

        if self.conditions.peyronie {

            s.push_str("peyronie's disease: yes\n");

        }

        if self.conditions.pulled_muscle {

            s.push_str("pulled muscle: yes\n");

        }

        s.push_str(&format!(

            "suspicion: {}\nshame: {}\nwarmed up: {}\ngrip: {}\n",

            self.suspicion,

            self.shame,

            if self.warmed_up { "yes" } else { "no" },

            self.grip.name(),

        ));

        let held: Vec<&str> = self.items.owned().iter().map(|item| item.slug()).collect();

        if !held.is_empty() {

            s.push_str(&format!("items: {}\n", held.join(", ")));

        }

        if self.mum.is_some() {

            s.push_str("Mum is at the door\n");

        }

        s

    }

    fn chance(&mut self, roll: oracle::Roll, odds: u32) -> bool {

        self.oracle.chance(roll, odds)

    }

    pub fn path(&self, sub: &str) -> String {

        format!("/runs/{}{sub}", self.id)

    }

    pub fn current_length(&self) -> f64 {

        self.length + self.here.temp_length

    }

    pub fn self_reported(&self) -> f64 {

        self.current_length() + SELF_REPORT_INFLATION

    }

    pub fn max_stamina(&self) -> i32 {

        if self.conditions.pulled_muscle {

            PULLED_STAMINA

        } else {

            MAX_STAMINA

        }

    }

    pub fn forum_read(&self) -> bool {

        self.story == Story::ReadForum

    }

    pub fn thread_reachable(&self) -> bool {

        self.turn >= BRANCH_TURN

            || self.forum_read()

            || self.floor.number() >= Floor::Forum.number()

    }

    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 status(&self) -> &'static str {

        match (&self.ended, self.clinic.cured) {

            (Some(_), _) => "gone",

            (None, true) => "normal",

            (None, false) => "alive",

        }

    }

    /// The parts of the run that its response headers do not already carry.

    pub fn view(&self) -> Value {

        let conditions: Vec<&str> = [

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

            (self.conditions.peyronie, "curved"),

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

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

            (self.conditions.pulled_muscle, "pulled muscle"),

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

        ]

        .into_iter()

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

        .collect();

        json!({

            "public_id": self.public_id,

            "status": self.status(),

            "turn": self.turn,

            "run_shame": self.shame,

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

            "warmed_up": self.warmed_up,

            "ranked": !self.seeded,

            "conditions": conditions,

        })

    }

    pub fn end(&mut self, cause: Cause) -> Problem {

        self.ended = Some(Ending {

            cause,

            turn: self.turn,

        });

        cause.problem().with("turn", self.turn)

    }

    /// The refractory period is the next HOLD. It comes back with full stamina and nothing else.

    fn recover(&mut self) {

        self.exhausted = false;

        self.stamina = self.max_stamina();

        self.reset_eq(STARTING_EQ);

        self.warmed_up = false;

    }

    fn check_exhausted(&self) -> Result<(), Problem> {

        if !self.exhausted {

            return Ok(());

        }

        Err(Problem::new(

            StatusCode::TOO_MANY_REQUESTS,

            "overtrained",

            "Stamina is exhausted. HOLD for the refractory period.",

        ))

    }

    fn exhaust(&mut self) {

        self.stamina = 0;

        self.exhausted = true;

    }

    fn realise(&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 cause = Cause::Ruptured {

            ice_unused: self.items.ice_packs > 0,

        };

        self.end(cause)

    }

}