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

        self.access(technique)?;

        match technique {

            Technique::Training(training) => Self::check_lube(training, lube),

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

        }

    }

    /// Whether the run could attempt the technique now, ignoring the lubricant.

    fn access(&self, technique: Technique) -> 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()));

        }

        match technique {

            Technique::Utility(Utility::Pump) if !self.items.pump_pro => Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-pump",

                "The pump technique depends on a pump.",

            )),

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

            Technique::Training(training) => match training.profile().foreskin {

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

                None => Ok(()),

            },

        }

    }

    fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {

        match (training.profile().lube, lube) {

            (LubeRule::Required, None) => 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(_)) => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-declared",

                format!(

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

                    training.name()

                ),

            )),

            _ => Ok(()),

        }

    }

    /// The techniques a JELQ could use right now without being refused before the roll.

    pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {

        let blocked = !self.floor.timed()

            || self.items.cage

            || self.story == Story::Pending

            || self.refractory_until.is_some_and(|until| now < until);

        if blocked {

            return Vec::new();

        }

        Technique::ALL

            .into_iter()

            .filter(|&technique| match technique {

                Technique::Utility(Utility::Warmup) => true,

                Technique::Utility(Utility::Ice) => self.items.ice_packs > 0,

                Technique::Utility(Utility::Supplement) => self.items.supplements > 0,

                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),

            })

            .collect()

    }

    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,

            });