jelq

use std::{

    hash::{DefaultHasher, Hash, Hasher},

    time::{Instant, SystemTime},

};

use axum::http::StatusCode;

use serde_json::{Value, json};

use super::{

    Body, Cause, Clinic, Ending, Floor, FloorState, Household, Item, Items, Notice, Observer,

    Online, RunStatus, Standing, Story,

    balance::{

        BRANCH_TURN, FLOOR_LIMIT, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, REFRACTORY_STAMINA,

        SECOND_WIND, SELF_REPORT_INFLATION, STARTING_BABY_OIL, STARTING_EQ, STARTING_LUBE,

    },

    measure::round2,

    oracle::{Oracle, OracleTemplate, Roll},

};

use crate::problem::Problem;

pub struct Identity {

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

    pub(crate) id: String,

    pub(crate) public_id: String,

    pub(crate) seeded: bool,

    etag_salt: u64,

    pub(crate) version: u64,

    pub(crate) last_seen: Instant,

}

pub struct Run {

    pub(crate) ident: Identity,

    pub(crate) body: Body,

    pub(crate) standing: Standing,

    pub(crate) household: Household,

    pub(crate) online: Online,

    pub(crate) items: Items,

    pub(crate) clinic: Clinic,

    pub(crate) turn: u32,

    pub(crate) floor: Floor,

    pub(crate) here: FloorState,

    pub(crate) observed: Option<Observer>,

    pub(crate) notices: Vec<Notice>,

    pub(crate) ended: Option<Ending>,

    pub(super) oracle: Oracle,

}

impl Run {

    #[cfg(test)]

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

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

    }

    pub fn with_oracle(

        id: String,

        public_id: String,

        seed: u64,

        seeded: bool,

        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 inflation = f64::from(oracle.span_int(

            Run::unborn(

                "inflation",

                "How far does the self-report round up, in tenths of an inch?",

            ),

            *SELF_REPORT_INFLATION.start(),

            *SELF_REPORT_INFLATION.end(),

        )) / 10.0;

        let mut items = Items::default();

        if oracle.chance(

            Run::unborn(

                "starting-lube",

                "Is there a bottle of lube in the drawer already?",

            ),

            STARTING_LUBE,

        ) {

            let baby_oil = oracle.chance(

                Run::unborn(

                    "starting-bottle",

                    "Is the bottle baby oil, rather than lotion?",

                ),

                STARTING_BABY_OIL,

            );

            items.grant(if baby_oil {

                Item::BabyOil

            } else {

                Item::Lotion

            });

        }

        let etag_salt = oracle.u64();

        Self {

            ident: Identity {

                id,

                public_id,

                seeded,

                etag_salt,

                version: 0,

                last_seen: Instant::now(),

            },

            body: Body::new(length, girth, foreskin, inflation),

            standing: Standing::default(),

            household: Household::default(),

            online: Online::default(),

            items,

            clinic: Clinic::default(),

            turn: 0,

            floor: Floor::Bedroom,

            here: FloorState::default(),

            observed: None,

            notices: Vec::new(),

            ended: None,

            oracle,

        }

    }

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

        Roll {

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

            site,

            ask,

        }

    }

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

        let mut hasher = DefaultHasher::new();

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

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

    }

    pub fn etag(&self) -> String {

        self.etag_at(self.ident.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.ident.version += 1;

    }

    pub(super) fn begin_turn(&mut self) -> Result<(), Problem> {

        self.check_clock()?;

        self.touch();

        self.turn += 1;

        self.here.turns += 1;

        self.body.torn = 0.0;

        self.standing.at_turn_start = self.standing.suspicion;

        self.realise(false);

        if self.floor.timed() && self.here.turns + 2 == FLOOR_LIMIT {

            self.notices.push(Notice::RunningLong(self.floor));

        } else if self.floor.timed() && self.here.turns + 1 == FLOOR_LIMIT {

            self.notices.push(Notice::LastTurn);

        }

        Ok(())

    }

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

        self.body.friction = (self.body.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.body.conditions.priapism_turns > 0 {

            PRIAPISM_EQ

        } else {

            0

        };

        self.body.eq = eq.max(floor);

    }

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

        self.here.kitchen.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;

    }

    pub(super) fn fresh_nonce(&mut self) -> String {

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

    }

    /// One game decision. The dice ignore the state prose, so it is only written for the model.

    pub(super) fn decision(&self, site: &'static str, ask: &'static str) -> Roll {

        Roll {

            state: if self.oracle.listens() {

                self.oracle_state()

            } else {

                String::new()

            },

            site,

            ask,

        }

    }

    fn oracle_state(&self) -> String {

        let mut s = format!(

            "Floor {}, {}. Turn {}.\n\neq: {}\nstamina: {}\nfriction: {}\n",

            self.floor.number(),

            self.floor.place(),

            self.turn,

            self.body.eq,

            self.body.stamina,

            self.body.friction

        );

        let conditions = &self.body.conditions;

        for (active, line) in [

            (conditions.friction_burn, "friction burn: yes, untreated\n"),

            (conditions.priapism_turns > 0, "priapism: yes\n"),

            (conditions.peyronie, "peyronie's disease: yes\n"),

            (conditions.pulled_muscle, "pulled muscle: yes\n"),

        ] {

            if active {

                s.push_str(line);

            }

        }

        s.push_str(&format!(

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

            self.standing.suspicion,

            self.standing.shame,

            self.body.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.household.mum.is_some() {

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

        }

        s

    }

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

        self.oracle.chance(roll, odds)

    }

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

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

    }

    pub fn current_length(&self) -> f64 {

        self.body.length + self.here.temp_length

    }

    pub fn self_reported(&self) -> f64 {

        self.current_length() + self.body.inflation

    }

    pub fn shown_length(&self) -> f64 {

        if self.items.kit.ruler {

            self.current_length()

        } else {

            self.self_reported()

        }

    }

    pub fn max_stamina(&self) -> i32 {

        if self.body.conditions.pulled_muscle {

            PULLED_STAMINA

        } else {

            MAX_STAMINA

        }

    }

    pub fn forum_read(&self) -> bool {

        self.online.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.online.filmed_at?;

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

        Some((filmed, age))

    }

    pub fn status(&self) -> RunStatus {

        if self.ended.is_some() {

            RunStatus::Gone

        } else if self.clinic.cured {

            RunStatus::Normal

        } else if self.clinic.prescribed {

            RunStatus::Prescribed

        } else {

            RunStatus::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.body.conditions.peyronie, "curved"),

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

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

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

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

        ]

        .into_iter()

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

        .collect();

        json!({

            "public_id": self.ident.public_id,

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

            "turn": self.turn,

            "run_shame": self.standing.shame,

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

            "ranked": !self.ident.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. Returns whether it rolled the second wind that refills stamina outright.

    pub(super) fn recover(&mut self) -> bool {

        self.body.exhausted = false;

        let second_wind = self.chance(

            self.decision(

                "second-wind",

                "Does the refractory period end in a second wind?",

            ),

            SECOND_WIND,

        );

        self.body.stamina = if second_wind {

            self.max_stamina()

        } else {

            let (lo, hi) = REFRACTORY_STAMINA;

            let back = self.oracle.span_int(

                self.decision(

                    "refractory",

                    "How much stamina comes back after the refractory period?",

                ),

                lo,

                hi,

            );

            back.min(self.max_stamina())

        };

        self.reset_eq(STARTING_EQ);

        second_wind

    }

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

        if !self.body.exhausted {

            return Ok(());

        }

        Err(Problem::new(

            StatusCode::TOO_MANY_REQUESTS,

            "overtrained",

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

        ))

    }

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

        self.body.stamina = 0;

        self.body.exhausted = true;

    }

    /// Leaving a floor lets time pass, so everything still queued arrives at once.

    pub(super) fn realise(&mut self, everything: bool) {

        let (due, waiting): (Vec<_>, Vec<_>) = std::mem::take(&mut self.body.pending)

            .into_iter()

            .partition(|p| everything || p.due <= self.turn);

        self.body.pending = waiting;

        for p in due {

            let foreskin = self.gain(p.length, p.girth, p.foreskin);

            let arrived = self.body.arrived.get_or_insert_default();

            arrived.length += p.length;

            arrived.girth += p.girth;

            if let Some(grown) = foreskin {

                *arrived.foreskin.get_or_insert(0.0) += grown;

            }

        }

    }

    /// The foreskin change it returns nets out whatever friction tore off this turn.

    pub(super) fn gain(&mut self, length: f64, girth: f64, foreskin: f64) -> Option<f64> {

        self.body.length += length;

        self.body.girth += girth;

        let torn = std::mem::take(&mut self.body.torn);

        let grown = match &mut self.body.foreskin {

            Some(f) => {

                *f += foreskin;

                foreskin

            }

            None => 0.0,

        };

        (grown != 0.0 || torn != 0.0).then_some(grown - torn)

    }

    pub(super) fn rupture(&mut self) -> Problem {

        let cause = Cause::Ruptured {

            ice_unused: self.items.stores.ice_packs > 0,

        };

        self.end(cause)

    }

    /// A run whose lock was poisoned by a panic mid-turn cannot be trusted to carry on.

    pub fn lose(&mut self) {

        if self.ended.is_none() {

            self.end(Cause::Lost);

        }

    }

}