jelq

use std::{fmt::Write as _, ops::ControlFlow, time::Instant};

use axum::http::{StatusCode, header};

use rand::Rng;

use serde_json::json;

use super::{

    Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,

    balance::{

        BAND_BONUS, BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, DANGER_EQ, EQ_BAND,

        EQ_WOBBLE, EXTENDER_GAIN, HOT_EQ, OBSERVED, PRIAPISM_EQ, PRIAPISM_TURNS, PULLED_MUSCLE,

        PULLED_MUSCLE_INTENSITY, RING_PRIAPISM, RING_RUPTURE_LINE, RUPTURE_LINE, STORAGE_GIRTH,

        SUSPICION_LIMIT,

    },

    not_extended, round3,

    state::{MumVisit, Observer, Pending},

    techniques::{LubeRule, Profile, Training, Utility},

};

use crate::{headers::SERVER_TIMING, problem::Problem};

impl Run {

    pub fn jelq(

        &mut self,

        techniques: &[Technique],

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        self.check_refractory(now)?;

        if self.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        if self.floor == Floor::Forum {

            return Ok(Outcome::json(

                StatusCode::SEE_OTHER,

                json!({ "detail": "Refer to the forum." }),

            )

            .header(header::LOCATION, super::FORUM_THREAD));

        }

        if self.items.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",

                "The cage is locked. The key is not in the box.",

            ));

        }

        match *techniques {

            [Technique::Utility(utility)] => self.utility(utility, lube, now),

            [Technique::Training(training)] => self.single(training, intensity, lube, now),

            [Technique::Training(a), Technique::Training(b)] => {

                self.combo(a, b, intensity, lube, now)

            }

            [_, _] => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "Only training techniques can be combined.",

            )),

            _ => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "too-many-techniques",

                "Two techniques at most. The server has limits even if you do not.",

            )),

        }

    }

    fn utility(

        &mut self,

        utility: Utility,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        match utility {

            Utility::Warmup => return self.warm_up(),

            Utility::Ice => return self.ice(),

            Utility::Supplement => return self.supplement(),

            Utility::Edge | Utility::Pump => {}

        }

        if utility == Utility::Pump {

            self.here.edges = 0;

        }

        self.ready(Technique::Utility(utility), lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        match utility {

            Utility::Edge => self.edge(now),

            _ => self.pump(now),

        }

    }

    fn single(

        &mut self,

        training: Training,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        self.here.edges = 0;

        self.ready(Technique::Training(training), lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        self.commit(intensity, lube, now, 1);

        if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {

            return Ok(interrupted);

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let outcome = self.roll(training, intensity, lube)?;

        Ok(self.gossip(outcome))

    }

    fn combo(

        &mut self,

        a: Training,

        b: Training,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        if a == b {

            return Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "A technique cannot be combined with itself. The server has checked.",

            ));

        }

        self.here.edges = 0;

        self.ready(Technique::Training(a), lube)?;

        self.ready(Technique::Training(b), lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        self.commit(intensity, lube, now, 2);

        for training in [a, b] {

            if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {

                return Ok(interrupted);

            }

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let mut statuses = Vec::new();

        for training in [a, b] {

            let result = self.roll(training, intensity, lube);

            if self.ended.is_some() {

                return result;

            }

            let status = match result {

                Ok(outcome) => self.gossip(outcome).status,

                Err(problem) => problem.status(),

            };

            statuses.push((training, status));

        }

        let mut xml = String::from(

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",

        );

        for (training, status) in statuses {

            let _ = write!(

                xml,

                "  <D:response>\n    <D:href>{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",

                self.path(""),

                training.name(),

                status.as_u16(),

                crate::problem::reason(status),

            );

        }

        xml.push_str(

            "  <D:responsedescription>Each technique has been reported separately.</D:responsedescription>\n</D:multistatus>\n",

        );

        Ok(Outcome::raw(

            StatusCode::MULTI_STATUS,

            "application/xml; charset=utf-8",

            xml,

        ))

    }

    fn ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {

        if technique == Technique::Training(Training::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", Utility::Warmup.name()));

        }

        let training = match technique {

            Technique::Utility(Utility::Pump) if !self.items.pump_pro => {

                return Err(Problem::new(

                    StatusCode::FAILED_DEPENDENCY,

                    "no-pump",

                    "The pump technique depends on a pump.",

                ));

            }

            Technique::Utility(_) => return Ok(()),

            Technique::Training(training) => training,

        };

        let profile = training.profile();

        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.",

                        training.name()

                    ),

                )

                .with("lubricants", json!(LUBRICANTS)));

            }

            (LubeRule::Forbidden, Some(_)) => {

                return Err(Problem::new(

                    StatusCode::UNSUPPORTED_MEDIA_TYPE,

                    "lubricant-declared",

                    format!(

                        "The {} technique was requested. A lubricant was declared.",

                        training.name()

                    ),

                ));

            }

            _ => {}

        }

        match profile.foreskin {

            Some((min, max)) => self.check_foreskin(min, max),

            None => 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, self.path("/foreskin")));

        };

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

        }

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

        }

        Ok(())

    }

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

        if self.items.extender && self.girth > STORAGE_GIRTH {

            return Err(Problem::new(

                StatusCode::INSUFFICIENT_STORAGE,

                "jeans-full",

                "The jeans are full. The extender is occupying the remaining storage.",

            )

            .with("extender", self.path("/inventory/extender")));

        }

        Ok(())

    }

    pub(super) fn commit(&mut self, intensity: i32, lube: Option<Lube>, now: Instant, cost: i32) {

        self.touch();

        self.turn += 1;

        self.here.turns += 1;

        self.realise();

        if self.items.extender {

            self.length += EXTENDER_GAIN;

        }

        self.stamina -= cost + i32::from(lube == Some(Lube::Lotion));

        if self.stamina <= 0 {

            self.exhaust(now);

        }

        let chill = if self.floor == Floor::ChangingRoom {

            CHANGING_ROOM_CHILL

        } else {

            0

        };

        let wobble = self.rng.random_range(-EQ_WOBBLE..=EQ_WOBBLE);

        self.eq = (self.eq + intensity * 2 - 6 - chill + wobble).clamp(0, 100);

        let mut suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));

        if matches!(self.floor, Floor::ChangingRoom | Floor::Nans) {

            suspicion *= 2;

        }

        if self.floor == Floor::Nans && lube == Some(Lube::CoconutOil) {

            suspicion += 2;

        }

        let was_below = self.suspicion < SUSPICION_LIMIT;

        self.suspicion =

            u8::try_from((i32::from(self.suspicion) + suspicion).min(i32::from(SUSPICION_LIMIT)))

                .unwrap_or(SUSPICION_LIMIT);

        self.maybe_summon_mum(was_below);

        if let Some(observer) = self.floor.observer()

            && self.chance(OBSERVED)

        {

            self.observed = Some(observer);

            self.shame += 1;

            if observer == Observer::Cat && self.chance(CAT_TAKES_TOWEL) {

                self.here.towel_stolen = true;

            }

        }

        if intensity >= PULLED_MUSCLE_INTENSITY

            && !self.conditions.pulled_muscle

            && self.chance(PULLED_MUSCLE)

        {

            self.conditions.pulled_muscle = true;

            self.stamina = self.stamina.min(self.max_stamina());

        }

        if self.items.ring && self.eq > HOT_EQ && self.chance(RING_PRIAPISM) {

            self.conditions.priapism_turns = PRIAPISM_TURNS;

        }

        if self.conditions.priapism_turns > 0 {

            self.conditions.priapism_turns -= 1;

            self.eq = self.eq.max(PRIAPISM_EQ);

        }

        if self.turn == BRANCH_TURN && self.story == Story::Unopened {

            self.story = Story::Pending;

        }

    }

    fn maybe_summon_mum(&mut self, was_below: bool) {

        if !self.floor.has_mum() || self.mum.is_some() {

            return;

        }

        let summoned = was_below && self.suspicion == SUSPICION_LIMIT;

        let visits = u32::from(self.suspicion) + 1;

        if summoned || self.rng.random_ratio(visits, super::balance::MUM_VISIT) {

            let errand = self.errand(summoned);

            let nonce = self.fresh_nonce();

            self.mum = Some(MumVisit {

                errand,

                nonce,

                strikes: 0,

            });

        }

    }

    fn roll(

        &mut self,

        training: Training,

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        let profile = training.profile();

        let natural: i32 = self.rng.random_range(1..=20);

        let band = if EQ_BAND.contains(&self.eq) {

            BAND_BONUS

        } else {

            0

        };

        let grip = match (self.grip, training) {

            (Grip::Underhand, Training::Stretch) => 2,

            (Grip::Underhand, Training::Wet) => -1,

            _ => 0,

        };

        let modifier = lube.map_or(0, Lube::modifier) + band + grip;

        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 (length, girth) = self.scaled_gains(&profile, intensity);

        let rupture_line = if self.items.ring {

            RING_RUPTURE_LINE

        } else {

            RUPTURE_LINE

        };

        if natural == 1 {

            return Err(timed(self.critical_failure(training, &profile)));

        }

        if natural == 2 && self.eq > DANGER_EQ {

            return Err(timed(self.rupture()));

        }

        if self.eq > rupture_line && total < dc {

            return Err(timed(self.rupture()));

        }

        if natural == 20 {

            self.gain(length * 2.0, girth * 2.0, profile.foreskin_growth);

            return Ok(Outcome::json(

                StatusCode::PERMANENT_REDIRECT,

                json!({

                    "detail": "Your length has moved permanently.",

                    "length": round3(length * 2.0),

                    "girth": round3(girth * 2.0),

                }),

            )

            .header(header::LOCATION, self.path("/length"))

            .header(SERVER_TIMING, timing));

        }

        if total < dc - 3 {

            return Err(timed(not_extended()));

        }

        if total < dc {

            return Ok(Outcome::empty(StatusCode::NO_CONTENT).header(SERVER_TIMING, timing));

        }

        let outcome = if self.eq < *EQ_BAND.start() {

            self.gain(length / 2.0, girth / 2.0, profile.foreskin_growth);

            Outcome::json(

                StatusCode::PARTIAL_CONTENT,

                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::json(

                StatusCode::OK,

                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::json(

                StatusCode::ACCEPTED,

                json!({

                    "detail": "Gains have been queued. They may arrive.",

                    "eta_turns": eta,

                }),

            )

        };

        Ok(outcome.header(SERVER_TIMING, timing))

    }

    fn scaled_gains(&self, profile: &Profile, intensity: i32) -> (f64, f64) {

        let scale = f64::from(intensity);

        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);

        if self.here.teapot {

            length *= 0.5;

            girth *= 1.5;

        }

        if self.items.ring {

            girth *= 2.0;

        }

        (length, girth)

    }

    fn critical_failure(&mut self, training: Training, profile: &Profile) -> Problem {

        let uses_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);